Refactoring: Get rid of "Jet" in the names of refactoring/quick fixes-related classes

idea/src/META-INF/plugin.xml

@@ -336,7 +336,7 @@
         language="kotlin" />
     <refactoring.copyHandler implementation="org.jetbrains.kotlin.idea.refactoring.copy.CopyKotlinFileHandler" order="first" />
     <refactoring.changeSignatureUsageProcessor
-        implementation="org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureUsageProcessor"
+        implementation="org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureUsageProcessor"
         order="after javaProcessor" />
     <refactoring.introduceParameterMethodUsagesProcessor
         implementation="org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.KotlinIntroduceParameterMethodUsageProcessor"/>

idea/src/org/jetbrains/kotlin/idea/codeInsight/unwrap/KotlinUnwrapRemoveBase.java

@@ -22,7 +22,7 @@ import com.intellij.psi.PsiWhiteSpace;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinBundle;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.psi.KtBlockExpression;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.psi.KtExpression;
@@ -44,7 +44,7 @@ public abstract class KotlinUnwrapRemoveBase extends AbstractUnwrapper<KotlinUnw
     @Override
     public String getDescription(PsiElement e) {
         assert e instanceof KtElement;
-        return KotlinBundle.message(key, JetRefactoringUtil.getExpressionShortText((KtElement) e));
+        return KotlinBundle.message(key, KotlinRefactoringUtil.getExpressionShortText((KtElement) e));
     }
 
     protected boolean canExtractExpression(@NotNull KtExpression expression, @NotNull KtElement parent) {

idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.idea.findUsages.handlers.DelegatingFindMemberUsagesH
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinFindClassUsagesHandler
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinFindMemberUsagesHandler
 import org.jetbrains.kotlin.idea.findUsages.handlers.KotlinTypeParameterFindUsagesHandler
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.plugin.findUsages.handlers.KotlinFindUsagesHandlerDecorator
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.isOverridable
@@ -108,7 +108,7 @@ public class KotlinFindUsagesHandlerFactory(project: Project) : FindUsagesHandle
                     return KotlinFindMemberUsagesHandler.getInstance(declaration, factory = this)
                 }
 
-                val declarationsToSearch = JetRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")
+                val declarationsToSearch = KotlinRefactoringUtil.checkSuperMethods(declaration, null, "super.methods.action.key.find.usages")
                 return handlerForMultiple(declaration, declarationsToSearch)
             }
 

idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindClassUsagesDialog.java

@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil;
 import org.jetbrains.kotlin.asJava.LightClassUtilsKt;
 import org.jetbrains.kotlin.idea.KotlinBundle;
 import org.jetbrains.kotlin.idea.findUsages.KotlinClassFindUsagesOptions;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.psi.KtClass;
 import org.jetbrains.kotlin.psi.KtClassOrObject;
 import org.jetbrains.kotlin.psi.psiUtil.KtPsiUtilKt;
@@ -153,7 +153,7 @@ public class KotlinFindClassUsagesDialog extends FindClassUsagesDialog {
                                          : klass.getUserData(ORIGINAL_CLASS);
 
         if (originalClass != null) {
-            coloredComponent.append(JetRefactoringUtil.formatClass(originalClass));
+            coloredComponent.append(KotlinRefactoringUtil.formatClass(originalClass));
         }
     }
 

idea/src/org/jetbrains/kotlin/idea/findUsages/dialogs/KotlinFindFunctionUsagesDialog.java

@@ -26,7 +26,7 @@ import com.intellij.ui.SimpleColoredComponent;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.idea.KotlinBundle;
 import org.jetbrains.kotlin.idea.findUsages.KotlinFunctionFindUsagesOptions;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil;
 
 import javax.swing.*;
 
@@ -50,7 +50,7 @@ public class KotlinFindFunctionUsagesDialog extends FindMethodUsagesDialog {
 
     @Override
     public void configureLabelComponent(@NotNull SimpleColoredComponent coloredComponent) {
-        coloredComponent.append(JetRefactoringUtil.formatJavaOrLightMethod((PsiMethod) myPsiElement));
+        coloredComponent.append(KotlinRefactoringUtil.formatJavaOrLightMethod((PsiMethod) myPsiElement));
     }
 
     @Override

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertParameterToReceiverIntention.kt

@@ -20,8 +20,8 @@ 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.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureConfiguration
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -38,9 +38,9 @@ public class ConvertParameterToReceiverIntention : SelfTargetingIntention<KtPara
         return function.getValueParameterList() == element.getParent() && function.getReceiverTypeReference() == null
     }
 
-    private fun configureChangeSignature(parameterIndex: Int): JetChangeSignatureConfiguration {
+    private fun configureChangeSignature(parameterIndex: Int): KotlinChangeSignatureConfiguration {
-        return object : JetChangeSignatureConfiguration {
+        return object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 return originalDescriptor.modify { it.receiver = originalDescriptor.getParameters()[parameterIndex] }
             }
 

idea/src/org/jetbrains/kotlin/idea/intentions/ConvertReceiverToParameterIntention.kt

@@ -20,8 +20,8 @@ import com.intellij.codeInsight.intention.LowPriorityAction
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureConfiguration
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -33,9 +33,9 @@ public class ConvertReceiverToParameterIntention : SelfTargetingOffsetIndependen
         return (element.getParent() as? KtNamedFunction)?.getReceiverTypeReference() == element
     }
 
-    private fun configureChangeSignature(): JetChangeSignatureConfiguration {
+    private fun configureChangeSignature(): KotlinChangeSignatureConfiguration {
-        return object : JetChangeSignatureConfiguration {
+        return object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 return originalDescriptor.modify { it.receiver = null }
             }
         }

idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt

@@ -78,9 +78,9 @@ public class AddFunctionParametersFix(
         runChangeSignature(project, functionDescriptor, addParameterConfiguration(), callElement, text)
     }
 
-    private fun addParameterConfiguration(): JetChangeSignatureConfiguration {
+    private fun addParameterConfiguration(): KotlinChangeSignatureConfiguration {
-        return object : JetChangeSignatureConfiguration {
+        return object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 return originalDescriptor.modify {
                     val parameters = functionDescriptor.valueParameters
                     val arguments = callElement.valueArguments
@@ -132,11 +132,11 @@ public class AddFunctionParametersFix(
             functionDescriptor: FunctionDescriptor,
             argument: ValueArgument,
             validator: (String) -> Boolean
-    ): JetParameterInfo {
+    ): KotlinParameterInfo {
         val name = getNewArgumentName(argument, validator)
         val expression = argument.getArgumentExpression()
         val type = expression?.let { it.analyze().getType(it) } ?: functionDescriptor.builtIns.nullableAnyType
-        return JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null)
+        return KotlinParameterInfo(functionDescriptor, -1, name, type, null, null, KotlinValVar.None, null)
                 .apply { currentTypeText = IdeDescriptorRenderers.SOURCE_CODE.renderType(type) }
     }
 

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionLiteralSignatureFix.kt

@@ -42,14 +42,14 @@ class ChangeFunctionLiteralSignatureFix private constructor(
         runChangeSignature(
                 project,
                 functionDescriptor,
-                object : JetChangeSignatureConfiguration {
+                object : KotlinChangeSignatureConfiguration {
-                    override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+                    override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                         return originalDescriptor.modify { descriptor ->
                             val validator = CollectingNameValidator()
                             descriptor.clearNonReceiverParameters()
                             for (type in parameterTypes) {
                                 val name = KotlinNameSuggester.suggestNamesByType(type, validator, "param").get(0)
-                                descriptor.addParameter(JetParameterInfo(functionDescriptor, -1, name, type, null, null, JetValVar.None, null))
+                                descriptor.addParameter(KotlinParameterInfo(functionDescriptor, -1, name, type, null, null, KotlinValVar.None, null))
                             }
                         }
                     }

idea/src/org/jetbrains/kotlin/idea/quickfix/ChangeFunctionSignatureFix.kt

@@ -32,8 +32,8 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.mapArgumentsToParameters
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureConfiguration
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
 import org.jetbrains.kotlin.psi.KtCallElement
@@ -140,8 +140,8 @@ abstract class ChangeFunctionSignatureFix(
             runChangeSignature(
                     context.project,
                     functionDescriptor,
-                    object : JetChangeSignatureConfiguration {
+                    object : KotlinChangeSignatureConfiguration {
-                        override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+                        override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                             return originalDescriptor.modify { descriptor ->
                                 val index = if (descriptor.receiver != null) parameterDescriptor.index + 1 else parameterDescriptor.index
                                 descriptor.removeParameter(index)

idea/src/org/jetbrains/kotlin/idea/quickfix/MissingConstructorKeywordFix.kt

@@ -39,7 +39,7 @@ public class MissingConstructorKeywordFix(element: KtPrimaryConstructor) : Kotli
                 diagnostic.createIntentionForFirstParentOfType(::MissingConstructorKeywordFix)
 
         public fun createWholeProjectFixFactory(): KotlinSingleIntentionActionFactory = createIntentionFactory {
-            JetWholeProjectForEachElementOfTypeFix.createByPredicate<KtPrimaryConstructor>(
+            WholeProjectForEachElementOfTypeFix.createByPredicate<KtPrimaryConstructor>(
                     predicate = { it.getModifierList() != null && !it.hasConstructorKeyword() },
                     taskProcessor = { it.addConstructorKeyword() },
                     name = "Add missing 'constructor' keyword in whole project"

idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt

@@ -50,7 +50,7 @@ public class ReplaceObsoleteLabelSyntaxFix(element: KtAnnotationEntry) : KotlinQ
             if (!(diagnostic.getPsiElement().getNonStrictParentOfType<KtAnnotationEntry>()?.looksLikeObsoleteLabelWithReferencesInCode()
                 ?: false)) return@factory null
 
-            JetWholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<KtAnnotatedExpression, KtAnnotationEntry>(
+            WholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<KtAnnotatedExpression, KtAnnotationEntry>(
                     tasksFactory = { collectTasks(it) },
                     tasksProcessor ={ it.forEach { ann -> replaceWithLabel(ann) } },
                     name = "Update obsolete label syntax in whole project"

idea/src/org/jetbrains/kotlin/idea/quickfix/WholeProjectModalAction.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.idea.quickfix
 
 import com.intellij.codeInsight.intention.IntentionAction
-import com.intellij.openapi.command.CommandProcessor
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.progress.ProcessCanceledException
@@ -25,7 +24,6 @@ import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.progress.Task
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.util.ui.UIUtil
 import org.jetbrains.kotlin.idea.project.PluginJetFilesProvider
@@ -34,14 +32,13 @@ import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 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
+import java.util.*
 
-public abstract class JetWholeProjectModalAction<TData : Any>(val title: String) : IntentionAction {
+public abstract class WholeProjectModalAction<TData : Any>(val title: String) : IntentionAction {
-    private val LOG = Logger.getInstance(javaClass<JetWholeProjectModalAction<*>>());
+    private val LOG = Logger.getInstance(javaClass<WholeProjectModalAction<*>>());
 
     override final fun startInWriteAction() = false
 
@@ -101,8 +98,8 @@ public abstract class JetWholeProjectModalAction<TData : Any>(val title: String)
     protected abstract fun applyChangesForFile(project: Project, file: KtFile, data: TData)
 }
 
-public abstract class JetWholeProjectModalByCollectionAction<TTask : Any>(modalTitle: String)
+public abstract class WholeProjectModalByCollectionAction<TTask : Any>(modalTitle: String)
-: JetWholeProjectModalAction<Collection<TTask>>(modalTitle) {
+: WholeProjectModalAction<Collection<TTask>>(modalTitle) {
     override fun collectDataForFile(project: Project, file: KtFile): Collection<TTask>? {
         val accumulator = arrayListOf<TTask>()
         collectTasksForFile(project, file, accumulator)
@@ -112,12 +109,12 @@ public abstract class JetWholeProjectModalByCollectionAction<TTask : Any>(modalT
     abstract fun collectTasksForFile(project: Project, file: KtFile, accumulator: MutableCollection<TTask>)
 }
 
-internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private constructor(
+internal class WholeProjectForEachElementOfTypeFix<TTask : Any> private constructor(
         private val collectingVisitorFactory: (MutableCollection<TTask>) -> KtVisitorVoid,
         private val tasksProcessor: (Collection<TTask>) -> Unit,
         private val name: String,
         private val familyName: String = name
-) : JetWholeProjectModalByCollectionAction<TTask>("Applying '$name'") {
+) : WholeProjectModalByCollectionAction<TTask>("Applying '$name'") {
 
     override fun getFamilyName() = familyName
     override fun getText() = name
@@ -152,7 +149,7 @@ internal class JetWholeProjectForEachElementOfTypeFix<TTask : Any> private const
                 noinline tasksFactory: (TElement) -> Collection<TTask>,
                 noinline tasksProcessor: (Collection<TTask>) -> Unit,
                 name: String
-        ) = JetWholeProjectForEachElementOfTypeFix(
+        ) = WholeProjectForEachElementOfTypeFix(
                 collectingVisitorFactory = { accumulator -> flatMapDescendantsOfTypeVisitor(accumulator, tasksFactory) },
                 tasksProcessor = tasksProcessor,
                 name = name,

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt

@@ -162,7 +162,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
 
     private fun computeTypeCandidates(
             typeInfo: TypeInfo,
-            substitutions: List<JetTypeSubstitution>,
+            substitutions: List<KotlinTypeSubstitution>,
             scope: HierarchicalScope): List<TypeCandidate> {
         if (!typeInfo.substitutionsAllowed) return computeTypeCandidates(typeInfo)
         return typeCandidates.getOrPut(typeInfo) {
@@ -226,7 +226,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
         val typeParameterNameMap: Map<TypeParameterDescriptor, String>
         val receiverTypeCandidate: TypeCandidate?
         val mandatoryTypeParametersAsCandidates: List<TypeCandidate>
-        val substitutions: List<JetTypeSubstitution>
+        val substitutions: List<KotlinTypeSubstitution>
         var finished: Boolean = false
 
         init {
@@ -312,7 +312,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) {
                 fakeFunction = null
                 mandatoryTypeParametersAsCandidates = Collections.emptyList()
             }
-            substitutions = substitutionMap.map { JetTypeSubstitution(it.key, it.value) }
+            substitutions = substitutionMap.map { KotlinTypeSubstitution(it.key, it.value) }
 
             callableInfo.parameterInfos.forEach {
                 computeTypeCandidates(it.typeInfo, substitutions, scope)

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt

@@ -232,9 +232,9 @@ private fun KtNamedDeclaration.guessType(context: BindingContext): Array<KotlinT
 /**
  * Encapsulates a single type substitution of a <code>KotlinType</code> by another <code>KotlinType</code>.
  */
-internal class JetTypeSubstitution(public val forType: KotlinType, public val byType: KotlinType)
+internal class KotlinTypeSubstitution(public val forType: KotlinType, public val byType: KotlinType)
 
-internal fun KotlinType.substitute(substitution: JetTypeSubstitution, variance: Variance): KotlinType {
+internal fun KotlinType.substitute(substitution: KotlinTypeSubstitution, variance: Variance): KotlinType {
     val nullable = isMarkedNullable()
     val currentType = makeNotNullable()
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByNamedArgumentActionFactory.kt

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
@@ -58,7 +58,7 @@ public object CreateParameterByNamedArgumentActionFactory: CreateParameterFromUs
         } ?: anyType
         if (paramType.hasTypeParametersToAdd(functionDescriptor, context)) return null
 
-        val parameterInfo = JetParameterInfo(
+        val parameterInfo = KotlinParameterInfo(
                 callableDescriptor = functionDescriptor,
                 name = name,
                 type = paramType,

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt

@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.getExpressionForTypeGuess
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.getTypeParameters
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.*
@@ -68,7 +68,7 @@ object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<KtSim
             }
         }
 
-        var valOrVar: JetValVar = JetValVar.None
+        var valOrVar: KotlinValVar = KotlinValVar.None
 
         fun chooseFunction(): PsiElement? {
             if (varExpected) return null
@@ -76,7 +76,7 @@ object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<KtSim
         }
 
         fun chooseContainingClass(it: PsiElement): KtClass? {
-            valOrVar = if (varExpected) JetValVar.Var else JetValVar.Val
+            valOrVar = if (varExpected) KotlinValVar.Var else KotlinValVar.Val
             return it.parents.firstIsInstanceOrNull<KtClassOrObject>() as? KtClass
         }
 
@@ -120,10 +120,10 @@ object CreateParameterByRefActionFactory : CreateParameterFromUsageFactory<KtSim
 
         return CreateParameterData(
                 context,
-                JetParameterInfo(callableDescriptor = functionDescriptor,
+                KotlinParameterInfo(callableDescriptor = functionDescriptor,
-                                 name = element.getReferencedName(),
+                                    name = element.getReferencedName(),
-                                 type = paramType,
+                                    type = paramType,
-                                 valOrVar = valOrVar),
+                                    valOrVar = valOrVar),
                 element
         )
     }

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFactory.kt

@@ -19,13 +19,13 @@ package org.jetbrains.kotlin.idea.quickfix.createFromUsage.createVariable
 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.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.resolve.BindingContext
 
 data class CreateParameterData<E : KtElement>(
         val context: BindingContext,
-        val parameterInfo: JetParameterInfo,
+        val parameterInfo: KotlinParameterInfo,
         val originalExpression: E
 )
 

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterFromUsageFix.kt

@@ -36,20 +36,20 @@ import org.jetbrains.kotlin.resolve.source.getPsi
 
 public open class CreateParameterFromUsageFix<E : KtElement>(
         val functionDescriptor: FunctionDescriptor,
-        val parameterInfo: JetParameterInfo,
+        val parameterInfo: KotlinParameterInfo,
         val defaultValueContext: E
 ) : CreateFromUsageFixBase<E>(defaultValueContext) {
     override fun getText(): String {
         return with(parameterInfo) {
-            if (valOrVar != JetValVar.None) "Create property '$name' as constructor parameter" else "Create parameter '$name'"
+            if (valOrVar != KotlinValVar.None) "Create property '$name' as constructor parameter" else "Create parameter '$name'"
         }
     }
 
     override fun startInWriteAction() = false
 
     override fun invoke(project: Project, editor: Editor?, file: KtFile) {
-        val config = object : JetChangeSignatureConfiguration {
+        val config = object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 return originalDescriptor.modify { it.addParameter(parameterInfo) }
             }
 
@@ -90,11 +90,11 @@ public open class CreateParameterFromUsageFix<E : KtElement>(
             val paramType = info.returnTypeInfo.getPossibleTypes(builder).firstOrNull() ?: return null
             if (paramType.hasTypeParametersToAdd(constructorDescriptor, builder.currentFileContext)) return null
 
-            val paramInfo = JetParameterInfo(
+            val paramInfo = KotlinParameterInfo(
                     callableDescriptor = constructorDescriptor,
                     name = info.name,
                     type = paramType,
-                    valOrVar = if (info.writable) JetValVar.Var else JetValVar.Val
+                    valOrVar = if (info.writable) KotlinValVar.Var else KotlinValVar.Val
             )
 
             return CreateParameterFromUsageFix(constructorDescriptor, paramInfo, element)

idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringBundle.java

@@ -25,13 +25,13 @@ import java.lang.ref.Reference;
 import java.lang.ref.SoftReference;
 import java.util.ResourceBundle;
 
-public class JetRefactoringBundle {
+public class KotlinRefactoringBundle {
     private static Reference<ResourceBundle> ourBundle;
 
     @NonNls
-    private static final String BUNDLE = "org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle";
+    private static final String BUNDLE = "org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle";
 
-    private JetRefactoringBundle() {
+    private KotlinRefactoringBundle() {
     }
 
     @NotNull

idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringSupportProvider.kt

@@ -21,7 +21,7 @@ import com.intellij.openapi.util.Condition
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiNameIdentifierOwner
 import com.intellij.refactoring.RefactoringActionHandler
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureHandler
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ExtractKotlinFunctionHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.KotlinIntroduceLambdaParameterHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceParameter.KotlinIntroduceParameterHandler
@@ -72,7 +72,7 @@ public class KotlinRefactoringSupportProvider : RefactoringSupportProvider() {
         return false
     }
 
-    override fun getChangeSignatureHandler() = JetChangeSignatureHandler()
+    override fun getChangeSignatureHandler() = KotlinChangeSignatureHandler()
 
     override fun getPullUpHandler() = KotlinPullUpHandler()
 

idea/src/org/jetbrains/kotlin/idea/refactoring/KotlinRefactoringUtil.java

@@ -65,9 +65,8 @@ import java.awt.*;
 import java.util.*;
 import java.util.List;
 
-public class JetRefactoringUtil {
+public class KotlinRefactoringUtil {
-
+    private KotlinRefactoringUtil() {
-    private JetRefactoringUtil() {
     }
 
     @NotNull
@@ -422,7 +421,8 @@ public class JetRefactoringUtil {
             @NotNull final SelectExpressionCallback callback) throws IntroduceRefactoringException {
         List<KtExpression> expressions = getSmartSelectSuggestions(file, offset);
         if (expressions.size() == 0) {
-            if (failOnEmptySuggestion) throw new IntroduceRefactoringException(JetRefactoringBundle.message("cannot.refactor.not.expression"));
+            if (failOnEmptySuggestion) throw new IntroduceRefactoringException(
+                    KotlinRefactoringBundle.message("cannot.refactor.not.expression"));
             return;
         }
 
@@ -466,7 +466,7 @@ public class JetRefactoringUtil {
         });
 
         JBPopupFactory.getInstance().createListPopupBuilder(list).
-                setTitle(JetRefactoringBundle.message("expressions.title")).setMovable(false).setResizable(false).
+                setTitle(KotlinRefactoringBundle.message("expressions.title")).setMovable(false).setResizable(false).
                 setRequestFocus(true).setItemChoosenCallback(new Runnable() {
             @Override
             public void run() {
@@ -494,7 +494,7 @@ public class JetRefactoringUtil {
             //todo: if it's infix expression => add (), then commit document then return new created expression
 
             if (failOnNoExpression) {
-                throw new IntroduceRefactoringException(JetRefactoringBundle.message("cannot.refactor.not.expression"));
+                throw new IntroduceRefactoringException(KotlinRefactoringBundle.message("cannot.refactor.not.expression"));
             }
             return null;
         }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeInfo.kt

@@ -38,8 +38,8 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
 import org.jetbrains.kotlin.idea.core.refactoring.j2k
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor.Kind
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallerUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -54,14 +54,14 @@ import org.jetbrains.kotlin.utils.keysToMap
 import org.jetbrains.kotlin.utils.removeLast
 import java.util.*
 
-public open class JetChangeInfo(
+public open class KotlinChangeInfo(
-        val methodDescriptor: JetMethodDescriptor,
+        val methodDescriptor: KotlinMethodDescriptor,
         private var name: String = methodDescriptor.getName(),
         val newReturnType: KotlinType? = methodDescriptor.baseDescriptor.getReturnType(),
         var newReturnTypeText: String = methodDescriptor.renderOriginalReturnType(),
         var newVisibility: Visibility = methodDescriptor.getVisibility(),
-        parameterInfos: List<JetParameterInfo> = methodDescriptor.getParameters(),
+        parameterInfos: List<KotlinParameterInfo> = methodDescriptor.getParameters(),
-        receiver: JetParameterInfo? = methodDescriptor.receiver,
+        receiver: KotlinParameterInfo? = methodDescriptor.receiver,
         val context: PsiElement,
         primaryPropagationTargets: Collection<PsiElement> = emptyList()
 ) : ChangeInfo, UserDataHolder by UserDataHolderBase() {
@@ -75,8 +75,8 @@ public open class JetChangeInfo(
         }
     }
 
-    var receiverParameterInfo: JetParameterInfo? = receiver
+    var receiverParameterInfo: KotlinParameterInfo? = receiver
-        set(value: JetParameterInfo?) {
+        set(value: KotlinParameterInfo?) {
             if (value != null && value !in newParameters) {
                 newParameters.add(value)
             }
@@ -120,7 +120,7 @@ public open class JetChangeInfo(
 
     public fun getNewParametersCount(): Int = newParameters.size()
 
-    override fun getNewParameters(): Array<JetParameterInfo> = newParameters.toTypedArray()
+    override fun getNewParameters(): Array<KotlinParameterInfo> = newParameters.toTypedArray()
 
     fun getToBeRemoved(): BooleanArray {
         return BooleanArray(originalParameters.size).apply {
@@ -134,17 +134,17 @@ public open class JetChangeInfo(
 
     fun getNonReceiverParametersCount(): Int = newParameters.size() - (if (receiverParameterInfo != null) 1 else 0)
 
-    fun getNonReceiverParameters(): List<JetParameterInfo> {
+    fun getNonReceiverParameters(): List<KotlinParameterInfo> {
         methodDescriptor.baseDeclaration.let { if (it is KtProperty || it is KtParameter) return emptyList() }
         return receiverParameterInfo?.let { receiver -> newParameters.filter { it != receiver } } ?: newParameters
     }
 
-    public fun setNewParameter(index: Int, parameterInfo: JetParameterInfo) {
+    public fun setNewParameter(index: Int, parameterInfo: KotlinParameterInfo) {
         newParameters.set(index, parameterInfo)
     }
 
     @JvmOverloads
-    public fun addParameter(parameterInfo: JetParameterInfo, atIndex: Int = -1) {
+    public fun addParameter(parameterInfo: KotlinParameterInfo, atIndex: Int = -1) {
         if (atIndex >= 0) {
             newParameters.add(atIndex, parameterInfo)
         }
@@ -165,7 +165,7 @@ public open class JetChangeInfo(
         receiverParameterInfo = null
     }
 
-    public fun hasParameter(parameterInfo: JetParameterInfo): Boolean =
+    public fun hasParameter(parameterInfo: KotlinParameterInfo): Boolean =
             parameterInfo in newParameters
 
     override fun isGenerateDelegate(): Boolean = false
@@ -226,7 +226,7 @@ public open class JetChangeInfo(
         this.primaryPropagationTargets = primaryPropagationTargets
     }
 
-    public fun getNewSignature(inheritedCallable: JetCallableDefinitionUsage<PsiElement>): String {
+    public fun getNewSignature(inheritedCallable: KotlinCallableDefinitionUsage<PsiElement>): String {
         val buffer = StringBuilder()
 
         val defaultVisibility = if (kind.isConstructor) Visibilities.PUBLIC else Visibilities.DEFAULT_VISIBILITY
@@ -267,12 +267,12 @@ public open class JetChangeInfo(
                && getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedCallableDescriptor)
     }
 
-    public fun getNewParametersSignature(inheritedCallable: JetCallableDefinitionUsage<*>): String {
+    public fun getNewParametersSignature(inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         return "(" + getNewParametersSignatureWithoutParentheses(inheritedCallable) + ")"
     }
 
     public fun getNewParametersSignatureWithoutParentheses(
-            inheritedCallable: JetCallableDefinitionUsage<*>
+            inheritedCallable: KotlinCallableDefinitionUsage<*>
     ): String {
         val signatureParameters = getNonReceiverParameters()
 
@@ -286,14 +286,14 @@ public open class JetChangeInfo(
                 .joinToString(separator = ", ")
     }
 
-    public fun renderReceiverType(inheritedCallable: JetCallableDefinitionUsage<*>): String? {
+    public fun renderReceiverType(inheritedCallable: KotlinCallableDefinitionUsage<*>): String? {
         val receiverTypeText = receiverParameterInfo?.currentTypeText ?: return null
         val typeSubstitutor = inheritedCallable.typeSubstitutor ?: return receiverTypeText
         val currentBaseFunction = inheritedCallable.baseFunction.currentCallableDescriptor ?: return receiverTypeText
         return currentBaseFunction.extensionReceiverParameter!!.type.renderTypeWithSubstitution(typeSubstitutor, receiverTypeText, false)
     }
 
-    public fun renderReturnType(inheritedCallable: JetCallableDefinitionUsage<*>): String {
+    public fun renderReturnType(inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         val typeSubstitutor = inheritedCallable.typeSubstitutor ?: return newReturnTypeText
         val currentBaseFunction = inheritedCallable.baseFunction.currentCallableDescriptor ?: return newReturnTypeText
         return currentBaseFunction.getReturnType()!!.renderTypeWithSubstitution(typeSubstitutor, newReturnTypeText, false)
@@ -396,7 +396,7 @@ public open class JetChangeInfo(
         fun getJavaParameterInfos(
                 originalPsiMethod: PsiMethod,
                 currentPsiMethod: PsiMethod,
-                newParameterList: List<JetParameterInfo>
+                newParameterList: List<KotlinParameterInfo>
         ): MutableList<ParameterInfoImpl> {
             val defaultValuesToSkip = newParameterList.size - currentPsiMethod.parameterList.parametersCount
             val defaultValuesToRetain = newParameterList.count { it.defaultValueForParameter != null } - defaultValuesToSkip
@@ -495,17 +495,17 @@ public open class JetChangeInfo(
     }
 }
 
-public val JetChangeInfo.originalBaseFunctionDescriptor: CallableDescriptor
+public val KotlinChangeInfo.originalBaseFunctionDescriptor: CallableDescriptor
     get() = methodDescriptor.baseDescriptor
 
-public val JetChangeInfo.kind: Kind get() = methodDescriptor.kind
+public val KotlinChangeInfo.kind: Kind get() = methodDescriptor.kind
 
-public val JetChangeInfo.oldName: String?
+public val KotlinChangeInfo.oldName: String?
     get() = (methodDescriptor.getMethod() as? KtFunction)?.getName()
 
-public fun JetChangeInfo.getAffectedCallables(): Collection<UsageInfo> = methodDescriptor.affectedCallables + propagationTargetUsageInfos
+public fun KotlinChangeInfo.getAffectedCallables(): Collection<UsageInfo> = methodDescriptor.affectedCallables + propagationTargetUsageInfos
 
-public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMethodDescriptor): JetChangeInfo {
+public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: KotlinMethodDescriptor): KotlinChangeInfo {
     val method = getMethod() as PsiMethod
 
     val functionDescriptor = method.getJavaMethodDescriptor()!!
@@ -531,11 +531,11 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMeth
                     else -> null
                 }
 
-        with(JetParameterInfo(callableDescriptor = functionDescriptor,
+        with(KotlinParameterInfo(callableDescriptor = functionDescriptor,
-                              originalIndex = oldIndex,
+                                 originalIndex = oldIndex,
-                              name = info.getName(),
+                                 name = info.getName(),
-                              type = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType,
+                                 type = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType,
-                              defaultValueForCall = defaultValueExpr)) {
+                                 defaultValueForCall = defaultValueExpr)) {
             currentTypeText = IdeDescriptorRenderers.SOURCE_CODE_FOR_TYPE_ARGUMENTS.renderType(currentType)
             this
         }
@@ -544,12 +544,12 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: JetMeth
     val returnType = functionDescriptor.getReturnType()
     val returnTypeText = if (returnType != null) IdeDescriptorRenderers.SOURCE_CODE.renderType(returnType) else ""
 
-    return JetChangeInfo(originalChangeSignatureDescriptor,
+    return KotlinChangeInfo(originalChangeSignatureDescriptor,
-                         getNewName(),
+                            getNewName(),
-                         returnType,
+                            returnType,
-                         returnTypeText,
+                            returnTypeText,
-                         functionDescriptor.getVisibility(),
+                            functionDescriptor.getVisibility(),
-                         newParameters,
+                            newParameters,
-                         null,
+                            null,
-                         method)
+                            method)
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignature.kt

@@ -41,54 +41,54 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.refactoring.createJavaMethod
 import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.ui.JetChangeSignatureDialog
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.ui.KotlinChangeSignatureDialog
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.OverrideResolver
 
-public interface JetChangeSignatureConfiguration {
+public interface KotlinChangeSignatureConfiguration {
-    fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor = originalDescriptor
+    fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor = originalDescriptor
     fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean = false
     fun forcePerformForSelectedFunctionOnly(): Boolean = false
 
-    object Empty: JetChangeSignatureConfiguration
+    object Empty: KotlinChangeSignatureConfiguration
 }
 
-fun JetMethodDescriptor.modify(action: (JetMutableMethodDescriptor) -> Unit): JetMethodDescriptor {
+fun KotlinMethodDescriptor.modify(action: (KotlinMutableMethodDescriptor) -> Unit): KotlinMethodDescriptor {
-    val newDescriptor = JetMutableMethodDescriptor(this)
+    val newDescriptor = KotlinMutableMethodDescriptor(this)
     action(newDescriptor)
     return newDescriptor
 }
 
 public fun runChangeSignature(project: Project,
                               callableDescriptor: CallableDescriptor,
-                              configuration: JetChangeSignatureConfiguration,
+                              configuration: KotlinChangeSignatureConfiguration,
                               defaultValueContext: PsiElement,
                               commandName: String? = null): Boolean {
-    return JetChangeSignature(project, callableDescriptor, configuration, defaultValueContext, commandName).run()
+    return KotlinChangeSignature(project, callableDescriptor, configuration, defaultValueContext, commandName).run()
 }
 
-public class JetChangeSignature(project: Project,
+public class KotlinChangeSignature(project: Project,
-                                callableDescriptor: CallableDescriptor,
+                                   callableDescriptor: CallableDescriptor,
-                                val configuration: JetChangeSignatureConfiguration,
+                                   val configuration: KotlinChangeSignatureConfiguration,
-                                val defaultValueContext: PsiElement,
+                                   val defaultValueContext: PsiElement,
-                                commandName: String?): CallableRefactoring<CallableDescriptor>(project,
+                                   commandName: String?): CallableRefactoring<CallableDescriptor>(project,
                                                                                                callableDescriptor,
                                                                                                commandName ?: ChangeSignatureHandler.REFACTORING_NAME) {
 
-    private val LOG = Logger.getInstance(javaClass<JetChangeSignature>())
+    private val LOG = Logger.getInstance(javaClass<KotlinChangeSignature>())
 
     override fun forcePerformForSelectedFunctionOnly() = configuration.forcePerformForSelectedFunctionOnly()
 
-    private fun runSilentRefactoring(descriptor: JetMethodDescriptor) {
+    private fun runSilentRefactoring(descriptor: KotlinMethodDescriptor) {
         val baseDeclaration = descriptor.baseDeclaration
         val processor = when (baseDeclaration) {
             is KtFunction, is KtClass -> {
-                JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(project, commandName, descriptor, defaultValueContext)
+                KotlinChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(project, commandName, descriptor, defaultValueContext)
             }
             is KtProperty, is KtParameter -> {
-                JetChangePropertySignatureDialog.createProcessorForSilentRefactoring(project, commandName, descriptor)
+                KotlinChangePropertySignatureDialog.createProcessorForSilentRefactoring(project, commandName, descriptor)
             }
             is PsiMethod -> {
                 if (baseDeclaration.getLanguage() != JavaLanguage.INSTANCE) {
@@ -103,14 +103,14 @@ public class JetChangeSignature(project: Project,
         processor.run()
     }
 
-    private fun runInteractiveRefactoring(descriptor: JetMethodDescriptor) {
+    private fun runInteractiveRefactoring(descriptor: KotlinMethodDescriptor) {
         val baseDeclaration = descriptor.baseDeclaration
         val dialog = when (baseDeclaration) {
-            is KtFunction, is KtClass -> JetChangeSignatureDialog(project, descriptor, defaultValueContext, commandName)
+            is KtFunction, is KtClass -> KotlinChangeSignatureDialog(project, descriptor, defaultValueContext, commandName)
-            is KtProperty, is KtParameter -> JetChangePropertySignatureDialog(project, descriptor, commandName)
+            is KtProperty, is KtParameter -> KotlinChangePropertySignatureDialog(project, descriptor, commandName)
             is PsiMethod -> {
                 // No changes are made from Kotlin side: just run foreign refactoring
-                if (descriptor is JetChangeSignatureData) {
+                if (descriptor is KotlinChangeSignatureData) {
                     ChangeSignatureUtil.invokeChangeSignatureOn(baseDeclaration, project)
                     return
                 }
@@ -135,12 +135,12 @@ public class JetChangeSignature(project: Project,
         dialog.show()
     }
 
-    private fun getPreviewInfoForJavaMethod(descriptor: JetMethodDescriptor): Pair<PsiMethod, JavaChangeInfo> {
+    private fun getPreviewInfoForJavaMethod(descriptor: KotlinMethodDescriptor): Pair<PsiMethod, JavaChangeInfo> {
         val originalMethod = descriptor.baseDeclaration as PsiMethod
         val contextFile = defaultValueContext.getContainingFile() as KtFile
 
         // Generate new Java method signature from the Kotlin point of view
-        val ktChangeInfo = JetChangeInfo(methodDescriptor = descriptor, context = defaultValueContext)
+        val ktChangeInfo = KotlinChangeInfo(methodDescriptor = descriptor, context = defaultValueContext)
         val ktSignature = ktChangeInfo.getNewSignature(descriptor.originalPrimaryCallable)
         val dummyFileText = with(StringBuilder()) {
             contextFile.getPackageDirective()?.let { append(it.getText()).append("\n") }
@@ -189,7 +189,7 @@ public class JetChangeSignature(project: Project,
         }
     }
 
-    fun adjustDescriptor(descriptorsForSignatureChange: Collection<CallableDescriptor>): JetMethodDescriptor? {
+    fun adjustDescriptor(descriptorsForSignatureChange: Collection<CallableDescriptor>): KotlinMethodDescriptor? {
         val baseDescriptor = preferContainedInClass(descriptorsForSignatureChange)
         val functionDeclaration = DescriptorToSourceUtilsIde.getAnyDeclaration(project, baseDescriptor)
         if (functionDeclaration == null) {
@@ -201,7 +201,7 @@ public class JetChangeSignature(project: Project,
             return null
         }
 
-        val originalDescriptor = JetChangeSignatureData(baseDescriptor, functionDeclaration, descriptorsForSignatureChange)
+        val originalDescriptor = KotlinChangeSignatureData(baseDescriptor, functionDeclaration, descriptorsForSignatureChange)
         return configuration.configure(originalDescriptor)
     }
 
@@ -221,21 +221,21 @@ public class JetChangeSignature(project: Project,
 public fun createChangeInfo(
         project: Project,
         callableDescriptor: CallableDescriptor,
-        configuration: JetChangeSignatureConfiguration,
+        configuration: KotlinChangeSignatureConfiguration,
         defaultValueContext: PsiElement
-): JetChangeInfo? {
+): KotlinChangeInfo? {
-    val jetChangeSignature = JetChangeSignature(project, callableDescriptor, configuration, defaultValueContext, null)
+    val jetChangeSignature = KotlinChangeSignature(project, callableDescriptor, configuration, defaultValueContext, null)
     val declarations = if (callableDescriptor is CallableMemberDescriptor) {
         OverrideResolver.getDeepestSuperDeclarations(callableDescriptor)
     } else listOf(callableDescriptor)
 
     val adjustedDescriptor = jetChangeSignature.adjustDescriptor(declarations) ?: return null
 
-    val processor = JetChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(
+    val processor = KotlinChangeSignatureDialog.createRefactoringProcessorForSilentChangeSignature(
             project,
             ChangeSignatureHandler.REFACTORING_NAME,
             adjustedDescriptor,
             defaultValueContext
-    ) as JetChangeSignatureProcessor
+    ) as KotlinChangeSignatureProcessor
     return processor.getChangeInfo()
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureData.kt

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.util.getResolutionScope
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.incremental.components.NoLookupLocation
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
@@ -44,13 +44,13 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.scopes.utils.findVariable
 import java.util.*
 
-public class JetChangeSignatureData(
+public class KotlinChangeSignatureData(
         override val baseDescriptor: CallableDescriptor,
         override val baseDeclaration: PsiElement,
         private val descriptorsForSignatureChange: Collection<CallableDescriptor>
-) : JetMethodDescriptor {
+) : KotlinMethodDescriptor {
-    private val parameters: List<JetParameterInfo>
+    private val parameters: List<KotlinParameterInfo>
-    override val receiver: JetParameterInfo?
+    override val receiver: KotlinParameterInfo?
 
     init {
         receiver = createReceiverInfoIfNeeded()
@@ -63,7 +63,7 @@ public class JetChangeSignatureData(
         parameters = baseDescriptor.getValueParameters()
                 .mapTo(receiver?.let{ arrayListOf(it) } ?: arrayListOf()) { parameterDescriptor ->
                     val jetParameter = valueParameters?.get(parameterDescriptor.index)
-                    JetParameterInfo(
+                    KotlinParameterInfo(
                             callableDescriptor = baseDescriptor,
                             originalIndex = parameterDescriptor.index,
                             name = parameterDescriptor.getName().asString(),
@@ -75,7 +75,7 @@ public class JetChangeSignatureData(
                 }
     }
 
-    private fun createReceiverInfoIfNeeded(): JetParameterInfo? {
+    private fun createReceiverInfoIfNeeded(): KotlinParameterInfo? {
         val callable = baseDeclaration as? KtCallableDeclaration ?: return null
         val bodyScope = (callable as? KtFunction)?.bodyExpression?.let { it.getResolutionScope(it.analyze(), it.getResolutionFacade()) }
         val paramNames = baseDescriptor.valueParameters.map { it.name.asString() }
@@ -86,21 +86,21 @@ public class JetChangeSignatureData(
         } ?: CollectingNameValidator(paramNames)
         val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null
         val receiverName = KotlinNameSuggester.suggestNamesByType(receiverType, validator, "receiver").first()
-        return JetParameterInfo(callableDescriptor = baseDescriptor, name = receiverName, type = receiverType)
+        return KotlinParameterInfo(callableDescriptor = baseDescriptor, name = receiverName, type = receiverType)
     }
 
-    override val original: JetMethodDescriptor
+    override val original: KotlinMethodDescriptor
         get() = this
 
-    override val primaryCallables: Collection<JetCallableDefinitionUsage<PsiElement>> by lazy {
+    override val primaryCallables: Collection<KotlinCallableDefinitionUsage<PsiElement>> by lazy {
         descriptorsForSignatureChange.map {
             val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(baseDeclaration.getProject(), it)
             assert(declaration != null) { "No declaration found for " + baseDescriptor }
-            JetCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
+            KotlinCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
         }
     }
 
-    override val originalPrimaryCallable: JetCallableDefinitionUsage<PsiElement> by lazy {
+    override val originalPrimaryCallable: KotlinCallableDefinitionUsage<PsiElement> by lazy {
         primaryCallables.first { it.declaration == baseDeclaration }
     }
 
@@ -115,7 +115,7 @@ public class JetChangeSignatureData(
                             if (overridingMethod is KtLightMethod) {
                                 val overridingDeclaration = overridingMethod.namedUnwrappedElement as KtNamedDeclaration
                                 val overridingDescriptor = overridingDeclaration.resolveToDescriptor() as CallableDescriptor
-                                JetCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
+                                KotlinCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
                             }
                             else OverriderUsageInfo(overridingMethod, baseMethod, true, true, true)
                         }.filterNotNullTo(HashSet<UsageInfo>())
@@ -123,7 +123,7 @@ public class JetChangeSignatureData(
         }
     }
 
-    override fun getParameters(): List<JetParameterInfo> {
+    override fun getParameters(): List<KotlinParameterInfo> {
         return parameters
     }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureHandler.kt

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZE
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.load.java.descriptors.JavaCallableMemberDescriptor
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.calls.tasks.isDynamic
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
-public class JetChangeSignatureHandler : ChangeSignatureHandler {
+public class KotlinChangeSignatureHandler : ChangeSignatureHandler {
 
     override fun findTargetMember(file: PsiFile, editor: Editor) =
             file.findElementAt(editor.getCaretModel().getOffset())?.let { findTargetMember(it) }
@@ -72,7 +72,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
     }
 
     override fun getTargetNotFoundMessage() =
-            JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name")
+            KotlinRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name")
 
     companion object {
         public fun findTargetForRefactoring(element: PsiElement): PsiElement? {
@@ -149,7 +149,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
                 return
             }
 
-            runChangeSignature(project, callableDescriptor, JetChangeSignatureConfiguration.Empty, context, null)
+            runChangeSignature(project, callableDescriptor, KotlinChangeSignatureConfiguration.Empty, context, null)
         }
 
         private fun getDescriptor(bindingContext: BindingContext, element: PsiElement): DeclarationDescriptor? {
@@ -168,13 +168,13 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
             return when (descriptor) {
                 is FunctionDescriptor -> {
                     if (descriptor.getValueParameters().any { it.varargElementType != null }) {
-                        val message = JetRefactoringBundle.message("error.cant.refactor.vararg.functions")
+                        val message = KotlinRefactoringBundle.message("error.cant.refactor.vararg.functions")
                         CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
                         return null
                     }
 
                     if (descriptor.getKind() === SYNTHESIZED) {
-                        val message = JetRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.getName())
+                        val message = KotlinRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.getName())
                         CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
                         return null
                     }
@@ -185,7 +185,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
                 is PropertyDescriptor, is ValueParameterDescriptor -> descriptor as CallableDescriptor
 
                 else -> {
-                    val message = RefactoringBundle.getCannotRefactorMessage(JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name"))
+                    val message = RefactoringBundle.getCannotRefactorMessage(KotlinRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name"))
                     CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
                     null
                 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureProcessor.kt

@@ -30,19 +30,19 @@ import com.intellij.refactoring.rename.UnresolvableCollisionUsageInfo
 import com.intellij.usageView.UsageInfo
 import com.intellij.usageView.UsageViewDescriptor
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetUsageInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinUsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinWrapperForJavaUsageInfos
 import java.util.*
 
-public class JetChangeSignatureProcessor(project: Project,
+public class KotlinChangeSignatureProcessor(project: Project,
-                                         changeInfo: JetChangeInfo,
+                                            changeInfo: KotlinChangeInfo,
-                                         private val commandName: String) : ChangeSignatureProcessorBase(project, changeInfo) {
+                                            private val commandName: String) : ChangeSignatureProcessorBase(project, changeInfo) {
     override fun createUsageViewDescriptor(usages: Array<UsageInfo>): UsageViewDescriptor {
         val subject = if (getChangeInfo().kind.isConstructor) "constructor" else "function"
-        return JetUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject))
+        return KotlinUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject))
     }
 
-    override fun getChangeInfo() = super.getChangeInfo() as JetChangeInfo
+    override fun getChangeInfo() = super.getChangeInfo() as KotlinChangeInfo
 
     override fun findUsages(): Array<UsageInfo> {
         val allUsages = ArrayList<UsageInfo>()
@@ -52,7 +52,7 @@ public class JetChangeSignatureProcessor(project: Project,
                 KotlinWrapperForJavaUsageInfos(it, javaProcessor.findUsages(it), getChangeInfo().getMethod())
             }
         }
-        super.findUsages().filterTo(allUsages) { it is JetUsageInfo<*> || it is UnresolvableCollisionUsageInfo }
+        super.findUsages().filterTo(allUsages) { it is KotlinUsageInfo<*> || it is UnresolvableCollisionUsageInfo }
 
         return allUsages.toTypedArray()
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureUsageProcessor.kt

@@ -80,23 +80,23 @@ import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import java.util.*
 
-class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
+class KotlinChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     // This is special 'PsiElement' whose purpose is to wrap JetMethodDescriptor so that it can be kept in the usage list
     private class OriginalJavaMethodDescriptorWrapper(element: PsiElement) : UsageInfo(element) {
-        internal var originalJavaMethodDescriptor: JetMethodDescriptor? = null
+        internal var originalJavaMethodDescriptor: KotlinMethodDescriptor? = null
     }
 
-    private class DummyJetChangeInfo(
+    private class DummyKotlinChangeInfo(
             method: PsiElement,
-            methodDescriptor: JetMethodDescriptor
+            methodDescriptor: KotlinMethodDescriptor
-    ) : JetChangeInfo(methodDescriptor = methodDescriptor,
+    ) : KotlinChangeInfo(methodDescriptor = methodDescriptor,
-                      name = "",
+                         name = "",
-                      newReturnType = null,
+                         newReturnType = null,
-                      newReturnTypeText = "",
+                         newReturnTypeText = "",
-                      newVisibility = Visibilities.DEFAULT_VISIBILITY,
+                         newVisibility = Visibilities.DEFAULT_VISIBILITY,
-                      parameterInfos = emptyList<JetParameterInfo>(),
+                         parameterInfos = emptyList<KotlinParameterInfo>(),
-                      receiver = null,
+                         receiver = null,
-                      context = method)
+                         context = method)
 
     // It's here to prevent O(usage_count^2) performance
     private var initializedOriginalDescriptor: Boolean = false
@@ -108,7 +108,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
         result.add(OriginalJavaMethodDescriptorWrapper(info.method))
 
-        if (info is JetChangeInfo) {
+        if (info is KotlinChangeInfo) {
             findAllMethodUsages(info, result)
         }
         else {
@@ -123,10 +123,10 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
         return result.toTypedArray()
     }
 
-    private fun findAllMethodUsages(changeInfo: JetChangeInfo, result: MutableSet<UsageInfo>) {
+    private fun findAllMethodUsages(changeInfo: KotlinChangeInfo, result: MutableSet<UsageInfo>) {
         loop@ for (functionUsageInfo in changeInfo.getAffectedCallables()) {
             when (functionUsageInfo) {
-                is JetCallableDefinitionUsage<*> -> findOneMethodUsages(functionUsageInfo, changeInfo, result)
+                is KotlinCallableDefinitionUsage<*> -> findOneMethodUsages(functionUsageInfo, changeInfo, result)
                 is KotlinCallerUsage -> findCallerUsages(functionUsageInfo, changeInfo, result)
                 else -> {
                     result.add(functionUsageInfo)
@@ -143,7 +143,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
                             KotlinCallerCallUsage(callElement)
                         }
                         else {
-                            JetFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
+                            KotlinFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
                         }
                         result.add(usage)
                     }
@@ -152,7 +152,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
         }
     }
 
-    private fun findCallerUsages(callerUsage: KotlinCallerUsage, changeInfo: JetChangeInfo, result: MutableSet<UsageInfo>) {
+    private fun findCallerUsages(callerUsage: KotlinCallerUsage, changeInfo: KotlinChangeInfo, result: MutableSet<UsageInfo>) {
         result.add(callerUsage)
 
         val element = callerUsage.element ?: return
@@ -191,7 +191,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
                         }
 
                         if (receiver is ThisReceiver) {
-                            result.add(JetImplicitThisUsage(callElement, receiver.declarationDescriptor))
+                            result.add(KotlinImplicitThisUsage(callElement, receiver.declarationDescriptor))
                         }
                         else if (!receiver.exists()) {
                             result.add(
@@ -222,8 +222,8 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     }
 
     private fun findOneMethodUsages(
-            functionUsageInfo: JetCallableDefinitionUsage<*>,
+            functionUsageInfo: KotlinCallableDefinitionUsage<*>,
-            changeInfo: JetChangeInfo,
+            changeInfo: KotlinChangeInfo,
             result: MutableSet<UsageInfo>
     ) {
         val isInherited = functionUsageInfo.isInherited
@@ -244,17 +244,17 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
                 when {
                     parent is KtCallExpression ->
-                        result.add(JetFunctionCallUsage(parent, functionUsageInfo))
+                        result.add(KotlinFunctionCallUsage(parent, functionUsageInfo))
 
                     parent is KtUserType && parent.parent is KtTypeReference -> {
                         parent = parent.parent.parent
 
                         if (parent is KtConstructorCalleeExpression && parent.parent is KtDelegatorToSuperCall)
-                            result.add(JetFunctionCallUsage(parent.parent as KtDelegatorToSuperCall, functionUsageInfo))
+                            result.add(KotlinFunctionCallUsage(parent.parent as KtDelegatorToSuperCall, functionUsageInfo))
                     }
 
                     element is KtSimpleNameExpression && (functionPsi is KtProperty || functionPsi is KtParameter) ->
-                        result.add(JetPropertyCallUsage(element))
+                        result.add(KotlinPropertyCallUsage(element))
                 }
             }
         }
@@ -280,7 +280,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
                         // Usages in named arguments of the calls usage will be changed when the function call is changed
                         if ((element is KtSimpleNameExpression || element is KDocName) && element.parent !is KtValueArgumentName) {
-                            result.add(JetParameterUsage(element as KtElement, parameterInfo, functionUsageInfo))
+                            result.add(KotlinParameterUsage(element as KtElement, parameterInfo, functionUsageInfo))
                         }
                     }
                 }
@@ -294,21 +294,21 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
         if (functionPsi is KtClass && functionPsi.isEnum()) {
             for (declaration in functionPsi.declarations) {
                 if (declaration is KtEnumEntry && declaration.getDelegationSpecifiers().isEmpty()) {
-                    result.add(JetEnumEntryWithoutSuperCallUsage(declaration))
+                    result.add(KotlinEnumEntryWithoutSuperCallUsage(declaration))
                 }
             }
         }
 
         functionPsi.processDelegationCallConstructorUsages(functionPsi.useScope) {
             when (it) {
-                is KtConstructorDelegationCall -> result.add(JetConstructorDelegationCallUsage(it, changeInfo))
+                is KtConstructorDelegationCall -> result.add(KotlinConstructorDelegationCallUsage(it, changeInfo))
-                is KtDelegatorToSuperCall -> result.add(JetFunctionCallUsage(it, functionUsageInfo))
+                is KtDelegatorToSuperCall -> result.add(KotlinFunctionCallUsage(it, functionUsageInfo))
             }
             true
         }
     }
 
-    private fun processInternalReferences(functionUsageInfo: JetCallableDefinitionUsage<*>, visitor: KtTreeVisitor<BindingContext>) {
+    private fun processInternalReferences(functionUsageInfo: KotlinCallableDefinitionUsage<*>, visitor: KtTreeVisitor<BindingContext>) {
         val ktFunction = functionUsageInfo.declaration as KtFunction
 
         val body = ktFunction.bodyExpression
@@ -321,9 +321,9 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     }
 
     private fun findOriginalReceiversUsages(
-            functionUsageInfo: JetCallableDefinitionUsage<*>,
+            functionUsageInfo: KotlinCallableDefinitionUsage<*>,
             result: MutableSet<UsageInfo>,
-            changeInfo: JetChangeInfo
+            changeInfo: KotlinChangeInfo
     ) {
         val originalReceiverInfo = changeInfo.methodDescriptor.receiver
         val callableDescriptor = functionUsageInfo.originalCallableDescriptor
@@ -338,12 +338,12 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
                         if (receiverDescriptor === callableDescriptor.extensionReceiverParameter) {
                             assert(originalReceiverInfo != null) { "No original receiver info provided: " + functionUsageInfo.declaration.text }
-                            result.add(JetParameterUsage(expression, originalReceiverInfo!!, functionUsageInfo))
+                            result.add(KotlinParameterUsage(expression, originalReceiverInfo!!, functionUsageInfo))
                         }
                         else {
                             val targetDescriptor = receiverDescriptor.type.constructor.declarationDescriptor
                             assert(targetDescriptor != null) { "Receiver type has no descriptor: " + functionUsageInfo.declaration.text }
-                            result.add(JetNonQualifiedOuterThisUsage(expression.parent as KtThisExpression, targetDescriptor!!))
+                            result.add(KotlinNonQualifiedOuterThisUsage(expression.parent as KtThisExpression, targetDescriptor!!))
                         }
                     }
 
@@ -353,10 +353,10 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
                         val targetDescriptor = receiverValue.declarationDescriptor
                         if (compareDescriptors(callElement.project, targetDescriptor, callableDescriptor)) {
                             assert(originalReceiverInfo != null) { "No original receiver info provided: " + functionUsageInfo.declaration.text }
-                            result.add(JetImplicitThisToParameterUsage(callElement, originalReceiverInfo!!, functionUsageInfo))
+                            result.add(KotlinImplicitThisToParameterUsage(callElement, originalReceiverInfo!!, functionUsageInfo))
                         }
                         else {
-                            result.add(JetImplicitThisUsage(callElement, targetDescriptor))
+                            result.add(KotlinImplicitThisUsage(callElement, targetDescriptor))
                         }
                     }
 
@@ -454,7 +454,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
             result: MutableSet<UsageInfo>,
             function: KtNamedFunction,
             functionDescriptor: FunctionDescriptor) {
-        val functionInfoForParameters = JetCallableDefinitionUsage<PsiElement>(function, functionDescriptor, null, null)
+        val functionInfoForParameters = KotlinCallableDefinitionUsage<PsiElement>(function, functionDescriptor, null, null)
         val oldParameters = function.valueParameters
         val parameters = changeInfo.newParameters
         for ((paramIndex, parameterInfo) in parameters.withIndex()) {
@@ -472,12 +472,12 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
                 result.add(
                         object : JavaMethodDeferredKotlinUsage<KtElement>(element as KtElement) {
-                            override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtElement> {
+                            override fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<KtElement> {
                                 return object : JavaMethodKotlinUsageWithDelegate<KtElement>(element as KtElement, javaMethodChangeInfo) {
-                                    override val delegateUsage: JetUsageInfo<KtElement>
+                                    override val delegateUsage: KotlinUsageInfo<KtElement>
-                                        get() = JetParameterUsage(element as KtElement,
+                                        get() = KotlinParameterUsage(element as KtElement,
-                                                                  this.javaMethodChangeInfo.newParameters[paramIndex],
+                                                                     this.javaMethodChangeInfo.newParameters[paramIndex],
-                                                                  functionInfoForParameters)
+                                                                     functionInfoForParameters)
                                 }
                             }
                         }
@@ -497,7 +497,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
             refUsages.set(adjustedUsages.toTypedArray())
         }
 
-        if (info !is JetChangeInfo) return result
+        if (info !is KotlinChangeInfo) return result
 
         val parameterNames = HashSet<String>()
         val function = info.method
@@ -546,7 +546,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
             }
 
             if (parametersScope != null) {
-                if (kind === JetMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR && valOrVar !== JetValVar.None) {
+                if (kind === KotlinMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR && valOrVar !== KotlinValVar.None) {
                     for (property in parametersScope.getVariablesFromImplicitReceivers(Name.identifier(parameterName))) {
                         val propertyDeclaration = DescriptorToSourceUtils.descriptorToDeclaration(property) ?: continue
                         if (propertyDeclaration.parent !is KtParameterList) {
@@ -584,7 +584,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
     private fun findParameterDuplicationInCaller(
             result: MultiMap<PsiElement, String>,
-            changeInfo: JetChangeInfo,
+            changeInfo: KotlinChangeInfo,
             caller: KtNamedDeclaration,
             callerDescriptor: DeclarationDescriptor) {
         val valueParameters = caller.getValueParameters()
@@ -603,11 +603,11 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     private fun findThisLabelConflicts(
             refUsages: Ref<Array<UsageInfo>>,
             result: MultiMap<PsiElement, String>,
-            changeInfo: JetChangeInfo,
+            changeInfo: KotlinChangeInfo,
             callable: KtCallableDeclaration) {
         val psiFactory = KtPsiFactory(callable.project)
         for (usageInfo in refUsages.get()) {
-            if (usageInfo !is JetParameterUsage) continue
+            if (usageInfo !is KotlinParameterUsage) continue
 
             val newExprText = usageInfo.getReplacementText(changeInfo)
             if (!newExprText.startsWith("this")) continue
@@ -643,12 +643,12 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     private fun findInternalExplicitReceiverConflicts(
             usages: Array<UsageInfo>,
             result: MultiMap<PsiElement, String>,
-            originalReceiverInfo: JetParameterInfo?
+            originalReceiverInfo: KotlinParameterInfo?
     ) {
         if (originalReceiverInfo != null) return
 
         for (usageInfo in usages) {
-            if (!(usageInfo is JetFunctionCallUsage || usageInfo is JetPropertyCallUsage)) continue
+            if (!(usageInfo is KotlinFunctionCallUsage || usageInfo is KotlinPropertyCallUsage)) continue
 
             val callElement = usageInfo.element as? KtElement ?: continue
 
@@ -663,7 +663,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
     private fun findReceiverIntroducingConflicts(
             result: MultiMap<PsiElement, String>,
             callable: PsiElement,
-            newReceiverInfo: JetParameterInfo?) {
+            newReceiverInfo: KotlinParameterInfo?) {
         if (newReceiverInfo != null && (callable is KtNamedFunction) && callable.bodyExpression != null) {
             val noReceiverRefToContext = KotlinFileReferencesResolver.resolve(callable, true, true).filter {
                 val resolvedCall = it.key.getResolvedCall(it.value)
@@ -701,7 +701,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
     private fun createReplacementUsage(
             originalUsageInfo: UsageInfo,
-            javaMethodChangeInfo: JetChangeInfo,
+            javaMethodChangeInfo: KotlinChangeInfo,
             allUsages: Array<UsageInfo>
     ): UsageInfo? {
         if (originalUsageInfo is JavaMethodDeferredKotlinUsage<*>) return originalUsageInfo.resolve(javaMethodChangeInfo)
@@ -782,7 +782,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
         val isJavaMethodUsage = isJavaMethodUsage(usageInfo)
 
         if (usageInfo is KotlinWrapperForJavaUsageInfos) {
-            val javaChangeInfos = (changeInfo as JetChangeInfo).getOrCreateJavaChangeInfos()
+            val javaChangeInfos = (changeInfo as KotlinChangeInfo).getOrCreateJavaChangeInfos()
             assert(javaChangeInfos != null) { "JavaChangeInfo not found: " + method.text }
 
             javaChangeInfos!!.firstOrNull {
@@ -795,7 +795,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
                 for (usage in javaUsageInfos) {
                     if (isOverriderOrCaller(usage) && beforeMethodChange) continue
                     for (processor in processors) {
-                        if (processor is JetChangeSignatureUsageProcessor) continue
+                        if (processor is KotlinChangeSignatureUsageProcessor) continue
                         if (isOverriderOrCaller(usage)) {
                             processor.processUsage(javaChangeInfo, usage, true, javaUsageInfos)
                         }
@@ -819,11 +819,11 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
             val methodDescriptor = method.getJavaMethodDescriptor()
             assert(methodDescriptor != null)
-            descriptorWrapper.originalJavaMethodDescriptor = JetChangeSignatureData(methodDescriptor!!, method, listOf(methodDescriptor))
+            descriptorWrapper.originalJavaMethodDescriptor = KotlinChangeSignatureData(methodDescriptor!!, method, listOf(methodDescriptor))
 
             // This change info is used as a placeholder before primary method update
             // It gets replaced with real change info afterwards
-            val dummyChangeInfo = DummyJetChangeInfo(changeInfo.method, descriptorWrapper.originalJavaMethodDescriptor!!)
+            val dummyChangeInfo = DummyKotlinChangeInfo(changeInfo.method, descriptorWrapper.originalJavaMethodDescriptor!!)
             for (i in usages.indices) {
                 val oldUsageInfo = usages[i]
                 if (!isJavaMethodUsage(oldUsageInfo)) continue
@@ -843,7 +843,7 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
 
         if (usageInfo is JavaMethodKotlinUsageWithDelegate<*>) {
             // Do not call getOriginalJavaMethodDescriptorWrapper() on each usage to avoid O(usage_count^2) performance
-            if (usageInfo.javaMethodChangeInfo is DummyJetChangeInfo) {
+            if (usageInfo.javaMethodChangeInfo is DummyKotlinChangeInfo) {
                 val descriptorWrapper = usages.firstIsInstanceOrNull<OriginalJavaMethodDescriptorWrapper>()
                 val methodDescriptor = (descriptorWrapper?.originalJavaMethodDescriptor) ?: return true
 
@@ -868,11 +868,11 @@ class JetChangeSignatureUsageProcessor : ChangeSignatureUsageProcessor {
         }
 
         @Suppress("UNCHECKED_CAST")
-        return (usageInfo as? JetUsageInfo<PsiElement>)?.processUsage(changeInfo as JetChangeInfo, element, usages) ?: false
+        return (usageInfo as? KotlinUsageInfo<PsiElement>)?.processUsage(changeInfo as KotlinChangeInfo, element, usages) ?: false
     }
 
     override fun processPrimaryMethod(changeInfo: ChangeInfo): Boolean {
-        if (changeInfo !is JetChangeInfo) return false
+        if (changeInfo !is KotlinChangeInfo) return false
 
         for (primaryFunction in changeInfo.methodDescriptor.primaryCallables) {
             primaryFunction.processUsage(changeInfo, primaryFunction.declaration, UsageInfo.EMPTY_ARRAY)

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinMethodDescriptor.kt

@@ -22,10 +22,10 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.descriptors.ConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 
-public interface JetMethodDescriptor : MethodDescriptor<JetParameterInfo, Visibility> {
+public interface KotlinMethodDescriptor : MethodDescriptor<KotlinParameterInfo, Visibility> {
     enum class Kind(val isConstructor: Boolean) {
         FUNCTION(false),
         PRIMARY_CONSTRUCTOR(true),
@@ -41,20 +41,20 @@ public interface JetMethodDescriptor : MethodDescriptor<JetParameterInfo, Visibi
         }
     }
 
-    val original: JetMethodDescriptor
+    val original: KotlinMethodDescriptor
 
     val baseDeclaration: PsiElement
     val baseDescriptor: CallableDescriptor
 
-    val originalPrimaryCallable: JetCallableDefinitionUsage<PsiElement>
+    val originalPrimaryCallable: KotlinCallableDefinitionUsage<PsiElement>
-    val primaryCallables: Collection<JetCallableDefinitionUsage<PsiElement>>
+    val primaryCallables: Collection<KotlinCallableDefinitionUsage<PsiElement>>
     val affectedCallables: Collection<UsageInfo>
 
-    val receiver: JetParameterInfo?
+    val receiver: KotlinParameterInfo?
 }
 
-fun JetMethodDescriptor.renderOriginalReturnType(): String =
+fun KotlinMethodDescriptor.renderOriginalReturnType(): String =
         baseDescriptor.getReturnType()?.let { IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(it) } ?: ""
 
-fun JetMethodDescriptor.renderOriginalReceiverType(): String? =
+fun KotlinMethodDescriptor.renderOriginalReceiverType(): String? =
         baseDescriptor.getExtensionReceiverParameter()?.getType()?.let { IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(it) }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinMutableMethodDescriptor.kt

@@ -18,18 +18,18 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 
 import org.jetbrains.kotlin.descriptors.Visibility
 
-public class JetMutableMethodDescriptor(override val original: JetMethodDescriptor): JetMethodDescriptor by original {
+public class KotlinMutableMethodDescriptor(override val original: KotlinMethodDescriptor): KotlinMethodDescriptor by original {
-    private val parameters: MutableList<JetParameterInfo> = original.getParameters()
+    private val parameters: MutableList<KotlinParameterInfo> = original.getParameters()
 
-    override var receiver: JetParameterInfo? = original.receiver
+    override var receiver: KotlinParameterInfo? = original.receiver
-        set(value: JetParameterInfo?) {
+        set(value: KotlinParameterInfo?) {
             if (value != null && value !in parameters) {
                 parameters.add(value)
             }
             field = value
         }
 
-    public fun addParameter(parameter: JetParameterInfo) {
+    public fun addParameter(parameter: KotlinParameterInfo) {
         parameters.add(parameter)
     }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinParameterInfo.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
 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.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
@@ -36,14 +36,14 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ThisReceiver
 import org.jetbrains.kotlin.types.KotlinType
 import java.util.*
 
-public class JetParameterInfo @JvmOverloads constructor (
+public class KotlinParameterInfo @JvmOverloads constructor (
         val callableDescriptor: CallableDescriptor,
         val originalIndex: Int = -1,
         private var name: String,
         type: KotlinType? = null,
         var defaultValueForParameter: KtExpression? = null,
         var defaultValueForCall: KtExpression? = null,
-        var valOrVar: JetValVar = JetValVar.None,
+        var valOrVar: KotlinValVar = KotlinValVar.None,
         val modifierList: KtModifierList? = null
 ): ParameterInfo {
     val originalType: KotlinType? = type
@@ -150,14 +150,14 @@ public class JetParameterInfo @JvmOverloads constructor (
         throw UnsupportedOperationException()
     }
 
-    public fun renderType(parameterIndex: Int, inheritedCallable: JetCallableDefinitionUsage<*>): String {
+    public fun renderType(parameterIndex: Int, inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         val typeSubstitutor = inheritedCallable.typeSubstitutor ?: return currentTypeText
         val currentBaseFunction = inheritedCallable.baseFunction.currentCallableDescriptor ?: return currentTypeText
         val parameterType = currentBaseFunction.getValueParameters().get(parameterIndex).getType()
         return parameterType.renderTypeWithSubstitution(typeSubstitutor, currentTypeText, true)
     }
 
-    public fun getInheritedName(inheritedCallable: JetCallableDefinitionUsage<*>): String {
+    public fun getInheritedName(inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         if (!inheritedCallable.isInherited) return name
 
         val baseFunction = inheritedCallable.baseFunction
@@ -178,7 +178,7 @@ public class JetParameterInfo @JvmOverloads constructor (
         }
     }
 
-    public fun requiresExplicitType(inheritedCallable: JetCallableDefinitionUsage<*>): Boolean {
+    public fun requiresExplicitType(inheritedCallable: KotlinCallableDefinitionUsage<*>): Boolean {
         val inheritedFunctionDescriptor = inheritedCallable.originalCallableDescriptor
         if (inheritedFunctionDescriptor !is AnonymousFunctionDescriptor) return true
 
@@ -189,14 +189,14 @@ public class JetParameterInfo @JvmOverloads constructor (
         return parameter.getTypeReference() != null
     }
 
-    public fun getDeclarationSignature(parameterIndex: Int, inheritedCallable: JetCallableDefinitionUsage<*>): String {
+    public fun getDeclarationSignature(parameterIndex: Int, inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         val buffer = StringBuilder()
 
         if (modifierList != null) {
             buffer.append(modifierList.getText()).append(' ')
         }
 
-        if (valOrVar != JetValVar.None) {
+        if (valOrVar != KotlinValVar.None) {
             buffer.append(valOrVar).append(' ')
         }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinUsagesViewDescriptor.kt

@@ -21,7 +21,7 @@ import com.intellij.refactoring.RefactoringBundle
 import com.intellij.usageView.UsageViewBundle
 import com.intellij.usageView.UsageViewDescriptor
 
-public class JetUsagesViewDescriptor(private val element: PsiElement, private val elementsHeader: String) : UsageViewDescriptor {
+public class KotlinUsagesViewDescriptor(private val element: PsiElement, private val elementsHeader: String) : UsageViewDescriptor {
     override fun getElements(): Array<PsiElement> = arrayOf(element)
 
     override fun getProcessedElementsHeader(): String = elementsHeader

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinValVar.kt

@@ -20,7 +20,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtPsiFactory
 
-public enum class JetValVar(val keywordName: String) {
+public enum class KotlinValVar(val keywordName: String) {
     None("none") {
         override fun createKeyword(factory: KtPsiFactory) = null
     },
@@ -36,11 +36,11 @@ public enum class JetValVar(val keywordName: String) {
     abstract fun createKeyword(factory: KtPsiFactory): PsiElement?
 }
 
-fun PsiElement?.toValVar(): JetValVar {
+fun PsiElement?.toValVar(): KotlinValVar {
     return when {
-        this == null -> JetValVar.None
+        this == null -> KotlinValVar.None
-        getNode().getElementType() == KtTokens.VAL_KEYWORD -> JetValVar.Val
+        getNode().getElementType() == KtTokens.VAL_KEYWORD -> KotlinValVar.Val
-        getNode().getElementType() == KtTokens.VAR_KEYWORD -> JetValVar.Var
+        getNode().getElementType() == KtTokens.VAR_KEYWORD -> KotlinValVar.Var
         else -> throw IllegalArgumentException("Unknown val/var token: " + getText())
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt

@@ -22,7 +22,7 @@ import com.intellij.refactoring.changeSignature.OverriderUsageInfo
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.DeferredJavaMethodKotlinCallerUsage
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JavaMethodKotlinUsageWithDelegate
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallerUsage
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.psi.*
@@ -65,8 +65,8 @@ public fun KtElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Bool
 }
 
 fun getCallableSubstitutor(
-        baseFunction: JetCallableDefinitionUsage<*>,
+        baseFunction: KotlinCallableDefinitionUsage<*>,
-        derivedCallable: JetCallableDefinitionUsage<*>
+        derivedCallable: KotlinCallableDefinitionUsage<*>
 ): TypeSubstitutor? {
     val currentBaseFunction = baseFunction.currentCallableDescriptor ?: return null
     val currentDerivedFunction = derivedCallable.currentCallableDescriptor ?: return null

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinCallableParameterTableModel.java

@@ -23,32 +23,32 @@ import com.intellij.refactoring.changeSignature.ParameterTableModelBase;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import com.intellij.util.ui.ColumnInfo;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar;
 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>> {
+public abstract class KotlinCallableParameterTableModel extends ParameterTableModelBase<KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>> {
     private final Project project;
-    private final JetMethodDescriptor methodDescriptor;
+    private final KotlinMethodDescriptor methodDescriptor;
 
-    protected JetCallableParameterTableModel(JetMethodDescriptor methodDescriptor, PsiElement context, ColumnInfo... columnInfos) {
+    protected KotlinCallableParameterTableModel(KotlinMethodDescriptor methodDescriptor, PsiElement context, ColumnInfo... columnInfos) {
         super(context, context, columnInfos);
         this.methodDescriptor = methodDescriptor;
         project = context.getProject();
     }
 
     @Nullable
-    public JetParameterInfo getReceiver() {
+    public KotlinParameterInfo getReceiver() {
         return null;
     }
 
     @Override
-    protected ParameterTableModelItemBase<JetParameterInfo> createRowItem(@Nullable JetParameterInfo parameterInfo) {
+    protected ParameterTableModelItemBase<KotlinParameterInfo> createRowItem(@Nullable KotlinParameterInfo parameterInfo) {
         if (parameterInfo == null) {
-            parameterInfo = new JetParameterInfo(methodDescriptor.getBaseDescriptor(), -1, "", null, null, null, JetValVar.None, null);
+            parameterInfo = new KotlinParameterInfo(methodDescriptor.getBaseDescriptor(), -1, "", null, null, null, KotlinValVar.None, null);
         }
         KtPsiFactory psiFactory = KtPsiFactoryKt.KtPsiFactory(project);
         PsiCodeFragment paramTypeCodeFragment = psiFactory.createTypeCodeFragment(parameterInfo.getTypeText(), myTypeContext);
@@ -57,7 +57,7 @@ public abstract class JetCallableParameterTableModel extends ParameterTableModel
                 defaultValueForCall != null ? defaultValueForCall.getText() : "",
                 myDefaultValueContext
         );
-        return new ParameterTableModelItemBase<JetParameterInfo>(parameterInfo, paramTypeCodeFragment, defaultValueCodeFragment) {
+        return new ParameterTableModelItemBase<KotlinParameterInfo>(parameterInfo, paramTypeCodeFragment, defaultValueCodeFragment) {
             @Override
             public boolean isEllipsisType() {
                 return false;

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinChangePropertySignatureDialog.kt

@@ -41,9 +41,9 @@ import javax.swing.JComponent
 import javax.swing.JLabel
 import kotlin.properties.Delegates
 
-public class JetChangePropertySignatureDialog(
+public class KotlinChangePropertySignatureDialog(
         project: Project,
-        private val methodDescriptor: JetMethodDescriptor,
+        private val methodDescriptor: KotlinMethodDescriptor,
         private val commandName: String?
 ): RefactoringDialog(project, true) {
     private val visibilityCombo = JComboBox(
@@ -98,7 +98,7 @@ public class JetChangePropertySignatureDialog(
                 receiverTypeCheckBox.addActionListener { updateReceiverUI() }
                 receiverTypeCheckBox.setSelected(methodDescriptor.receiver != null)
                 addComponent(receiverTypeCheckBox)
-                this@JetChangePropertySignatureDialog.receiverTypeCheckBox = receiverTypeCheckBox
+                this@KotlinChangePropertySignatureDialog.receiverTypeCheckBox = receiverTypeCheckBox
 
                 val receiverTypeCodeFragment = psiFactory.createTypeCodeFragment(methodDescriptor.renderOriginalReceiverType() ?: "",
                                                                                  methodDescriptor.baseDeclaration)
@@ -144,34 +144,34 @@ public class JetChangePropertySignatureDialog(
         val originalDescriptor = methodDescriptor.original
 
         val receiver = if (receiverTypeCheckBox?.isSelected() ?: false) {
-            originalDescriptor.receiver ?: JetParameterInfo(callableDescriptor = originalDescriptor.baseDescriptor,
+            originalDescriptor.receiver ?: KotlinParameterInfo(callableDescriptor = originalDescriptor.baseDescriptor,
-                                                            name = "receiver",
+                                                               name = "receiver",
-                                                            defaultValueForCall = getDefaultReceiverValue())
+                                                               defaultValueForCall = getDefaultReceiverValue())
         } else null
         receiver?.currentTypeText = receiverTypeField.getText()
-        val changeInfo = JetChangeInfo(originalDescriptor,
+        val changeInfo = KotlinChangeInfo(originalDescriptor,
-                                       nameField.getText(),
+                                          nameField.getText(),
-                                       null,
+                                          null,
-                                       returnTypeField.getText(),
+                                          returnTypeField.getText(),
-                                       visibilityCombo.getSelectedItem() as Visibility,
+                                          visibilityCombo.getSelectedItem() as Visibility,
-                                       emptyList(),
+                                          emptyList(),
-                                       receiver,
+                                          receiver,
-                                       originalDescriptor.getMethod())
+                                          originalDescriptor.getMethod())
 
-        invokeRefactoring(JetChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle()))
+        invokeRefactoring(KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle()))
     }
 
     companion object {
         fun createProcessorForSilentRefactoring(
                 project: Project,
                 commandName: String,
-                descriptor: JetMethodDescriptor
+                descriptor: KotlinMethodDescriptor
         ): BaseRefactoringProcessor {
             val originalDescriptor = descriptor.original
-            val changeInfo = JetChangeInfo(methodDescriptor = originalDescriptor, context = originalDescriptor.getMethod())
+            val changeInfo = KotlinChangeInfo(methodDescriptor = originalDescriptor, context = originalDescriptor.getMethod())
             changeInfo.setNewName(descriptor.getName())
             changeInfo.receiverParameterInfo = descriptor.receiver
-            return JetChangeSignatureProcessor(project, changeInfo, commandName)
+            return KotlinChangeSignatureProcessor(project, changeInfo, commandName)
         }
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinChangeSignatureDialog.kt

@@ -45,9 +45,9 @@ import com.intellij.util.ui.table.JBTableRowEditor
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor.Kind
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor.Kind
 import org.jetbrains.kotlin.psi.KtExpressionCodeFragment
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.KtTypeCodeFragment
@@ -60,35 +60,35 @@ import java.awt.event.ItemListener
 import java.util.*
 import javax.swing.*
 
-public class JetChangeSignatureDialog(
+public class KotlinChangeSignatureDialog(
         project: Project,
-        methodDescriptor: JetMethodDescriptor,
+        methodDescriptor: KotlinMethodDescriptor,
         context: PsiElement,
         private val commandName: String?
 ) : ChangeSignatureDialogBase<
-        JetParameterInfo,
+        KotlinParameterInfo,
         PsiElement,
         Visibility,
-        JetMethodDescriptor,
+        KotlinMethodDescriptor,
-        ParameterTableModelItemBase<JetParameterInfo>,
+        ParameterTableModelItemBase<KotlinParameterInfo>,
-        JetCallableParameterTableModel>(project, methodDescriptor, false, context) {
+        KotlinCallableParameterTableModel>(project, methodDescriptor, false, context) {
     override fun getFileType() = KotlinFileType.INSTANCE
 
-    override fun createParametersInfoModel(descriptor: JetMethodDescriptor) = createParametersInfoModel(descriptor, myDefaultValueContext)
+    override fun createParametersInfoModel(descriptor: KotlinMethodDescriptor) = createParametersInfoModel(descriptor, myDefaultValueContext)
 
     override fun createReturnTypeCodeFragment() = createReturnTypeCodeFragment(myProject, myMethod)
 
-    private val parametersTableModel: JetCallableParameterTableModel get() = super.myParametersTableModel
+    private val parametersTableModel: KotlinCallableParameterTableModel get() = super.myParametersTableModel
     
-    override fun getRowPresentation(item: ParameterTableModelItemBase<JetParameterInfo>, selected: Boolean, focused: Boolean): JComponent? {
+    override fun getRowPresentation(item: ParameterTableModelItemBase<KotlinParameterInfo>, selected: Boolean, focused: Boolean): JComponent? {
         val panel = JPanel(BorderLayout())
 
         val valOrVar: String
         if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) {
             valOrVar = when (item.parameter.valOrVar) {
-                JetValVar.None -> "    "
+                KotlinValVar.None -> "    "
-                JetValVar.Val -> "val "
+                KotlinValVar.Val -> "val "
-                JetValVar.Var -> "var "
+                KotlinValVar.Var -> "var "
             }
         }
         else {
@@ -127,12 +127,12 @@ public class JetChangeSignatureDialog(
         return panel
     }
 
-    private fun getPresentationName(item: ParameterTableModelItemBase<JetParameterInfo>): String {
+    private fun getPresentationName(item: ParameterTableModelItemBase<KotlinParameterInfo>): String {
         val parameter = item.parameter
         return if (parameter == parametersTableModel.getReceiver()) "<receiver>" else parameter.getName()
     }
 
-    private fun getColumnTextMaxLength(nameFunction: Function1<ParameterTableModelItemBase<JetParameterInfo>, String?>) =
+    private fun getColumnTextMaxLength(nameFunction: Function1<ParameterTableModelItemBase<KotlinParameterInfo>, String?>) =
             parametersTableModel.getItems().map { nameFunction(it)?.length() ?: 0 }.max() ?: 0
 
     private fun getParamNamesMaxLength() = getColumnTextMaxLength { getPresentationName(it) }
@@ -143,7 +143,7 @@ public class JetChangeSignatureDialog(
 
     override fun isListTableViewSupported() = true
 
-    override fun isEmptyRow(row: ParameterTableModelItemBase<JetParameterInfo>): Boolean {
+    override fun isEmptyRow(row: ParameterTableModelItemBase<KotlinParameterInfo>): Boolean {
         if (!row.parameter.getName().isNullOrEmpty()) return false
         if (!row.parameter.getTypeText().isNullOrEmpty()) return false
         return true
@@ -156,7 +156,7 @@ public class JetChangeSignatureDialog(
     override fun mayPropagateParameters() =
             getParameters().any { it.isNewParameter && it != parametersTableModel.getReceiver() }
 
-    override fun getTableEditor(table: JTable, item: ParameterTableModelItemBase<JetParameterInfo>): JBTableRowEditor? {
+    override fun getTableEditor(table: JTable, item: ParameterTableModelItemBase<KotlinParameterInfo>): JBTableRowEditor? {
         return object : JBTableRowEditor() {
             private val components = ArrayList<JComponent>()
             private val nameEditor = EditorTextField(item.parameter.getName(), getProject(), getFileType())
@@ -178,23 +178,23 @@ public class JetChangeSignatureDialog(
                     val component: JComponent
                     val columnFinal = column
 
-                    if (JetCallableParameterTableModel.isTypeColumn(columnInfo)) {
+                    if (KotlinCallableParameterTableModel.isTypeColumn(columnInfo)) {
                         val document = PsiDocumentManager.getInstance(getProject()).getDocument(item.typeCodeFragment)
                         editor = EditorTextField(document, getProject(), getFileType())
                         component = editor
                     }
-                    else if (JetCallableParameterTableModel.isNameColumn(columnInfo)) {
+                    else if (KotlinCallableParameterTableModel.isNameColumn(columnInfo)) {
                         editor = nameEditor
                         component = editor
                         updateNameEditor()
                     }
-                    else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo) && isDefaultColumnEnabled()) {
+                    else if (KotlinCallableParameterTableModel.isDefaultValueColumn(columnInfo) && isDefaultColumnEnabled()) {
                         val document = PsiDocumentManager.getInstance(getProject()).getDocument(item.defaultValueCodeFragment)
                         editor = EditorTextField(document, getProject(), getFileType())
                         component = editor
                     }
-                    else if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo)) {
+                    else if (KotlinPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo)) {
-                        val comboBox = JComboBox(JetValVar.values())
+                        val comboBox = JComboBox(KotlinValVar.values())
                         comboBox.setSelectedItem(item.parameter.valOrVar)
                         comboBox.addItemListener(object : ItemListener {
                             override fun itemStateChanged(e: ItemEvent) {
@@ -205,12 +205,12 @@ public class JetChangeSignatureDialog(
                         component = comboBox
                         editor = null
                     }
-                    else if (JetFunctionParameterTableModel.isReceiverColumn(columnInfo)) {
+                    else if (KotlinFunctionParameterTableModel.isReceiverColumn(columnInfo)) {
                         val checkBox = JCheckBox()
                         checkBox.setSelected(parametersTableModel.getReceiver() == item.parameter)
                         checkBox.addItemListener {
                             val newReceiver = if (it.getStateChange() == ItemEvent.SELECTED) item.parameter else null
-                            (parametersTableModel as JetFunctionParameterTableModel).setReceiver(newReceiver)
+                            (parametersTableModel as KotlinFunctionParameterTableModel).setReceiver(newReceiver)
                             updateSignature()
                             updateNameEditor()
                         }
@@ -247,13 +247,13 @@ public class JetChangeSignatureDialog(
                     override fun getValueAt(column: Int): Any? {
                         val columnInfo = parametersTableModel.getColumnInfos()[column]
 
-                        if (JetPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
+                        if (KotlinPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
                             return (components.get(column) as @Suppress("NO_TYPE_ARGUMENTS_ON_RHS") JComboBox).getSelectedItem()
-                        else if (JetCallableParameterTableModel.isTypeColumn(columnInfo))
+                        else if (KotlinCallableParameterTableModel.isTypeColumn(columnInfo))
                             return item.typeCodeFragment
-                        else if (JetCallableParameterTableModel.isNameColumn(columnInfo))
+                        else if (KotlinCallableParameterTableModel.isNameColumn(columnInfo))
                             return (components.get(column) as EditorTextField).getText()
-                        else if (JetCallableParameterTableModel.isDefaultValueColumn(columnInfo))
+                        else if (KotlinCallableParameterTableModel.isDefaultValueColumn(columnInfo))
                             return item.defaultValueCodeFragment
                         else
                             return null
@@ -332,11 +332,11 @@ public class JetChangeSignatureDialog(
         if (myNamePanel.isVisible()
             && myMethod.canChangeName()
             && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(getMethodName())) {
-            throw ConfigurationException(JetRefactoringBundle.message("function.name.is.invalid"))
+            throw ConfigurationException(KotlinRefactoringBundle.message("function.name.is.invalid"))
         }
 
         if (myMethod.canChangeReturnType() === MethodDescriptor.ReadWriteOption.ReadWrite && !hasTypeReference(myReturnTypeCodeFragment)) {
-            throw ConfigurationException(JetRefactoringBundle.message("return.type.is.invalid"))
+            throw ConfigurationException(KotlinRefactoringBundle.message("return.type.is.invalid"))
         }
 
         val parameterInfos = parametersTableModel.getItems()
@@ -346,11 +346,11 @@ public class JetChangeSignatureDialog(
 
             if (item.parameter != parametersTableModel.getReceiver()
                 && !JavaPsiFacade.getInstance(myProject).getNameHelper().isIdentifier(parameterName)) {
-                throw ConfigurationException(JetRefactoringBundle.message("parameter.name.is.invalid", parameterName))
+                throw ConfigurationException(KotlinRefactoringBundle.message("parameter.name.is.invalid", parameterName))
             }
 
             if (!hasTypeReference(item.typeCodeFragment)) {
-                throw ConfigurationException(JetRefactoringBundle.message("parameter.type.is.invalid", item.typeCodeFragment.getText()))
+                throw ConfigurationException(KotlinRefactoringBundle.message("parameter.type.is.invalid", item.typeCodeFragment.getText()))
             }
         }
     }
@@ -363,10 +363,10 @@ public class JetChangeSignatureDialog(
                                             getMethodName(),
                                             myDefaultValueContext)
         changeInfo.primaryPropagationTargets = myMethodsToPropagateParameters ?: emptyList();
-        return JetChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle())
+        return KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle())
     }
 
-    public fun getMethodDescriptor(): JetMethodDescriptor = myMethod
+    public fun getMethodDescriptor(): KotlinMethodDescriptor = myMethod
 
     override fun getSelectedIdx(): Int {
         return myMethod.getParameters().withIndex().firstOrNull { it.value.isNewParameter }?.index
@@ -374,20 +374,20 @@ public class JetChangeSignatureDialog(
     }
 
     companion object {
-        private fun createParametersInfoModel(descriptor: JetMethodDescriptor, defaultValueContext: PsiElement): JetCallableParameterTableModel {
+        private fun createParametersInfoModel(descriptor: KotlinMethodDescriptor, defaultValueContext: PsiElement): KotlinCallableParameterTableModel {
             return when (descriptor.kind) {
-                JetMethodDescriptor.Kind.FUNCTION -> JetFunctionParameterTableModel(descriptor, defaultValueContext)
+                KotlinMethodDescriptor.Kind.FUNCTION -> KotlinFunctionParameterTableModel(descriptor, defaultValueContext)
-                JetMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR -> JetPrimaryConstructorParameterTableModel(descriptor, defaultValueContext)
+                KotlinMethodDescriptor.Kind.PRIMARY_CONSTRUCTOR -> KotlinPrimaryConstructorParameterTableModel(descriptor, defaultValueContext)
-                JetMethodDescriptor.Kind.SECONDARY_CONSTRUCTOR -> JetSecondaryConstructorParameterTableModel(descriptor, defaultValueContext)
+                KotlinMethodDescriptor.Kind.SECONDARY_CONSTRUCTOR -> KotlinSecondaryConstructorParameterTableModel(descriptor, defaultValueContext)
             }
         }
 
-        private fun createReturnTypeCodeFragment(project: Project, method: JetMethodDescriptor) =
+        private fun createReturnTypeCodeFragment(project: Project, method: KotlinMethodDescriptor) =
                 KtPsiFactory(project).createTypeCodeFragment(method.renderOriginalReturnType(), method.baseDeclaration)
 
         public fun createRefactoringProcessorForSilentChangeSignature(project: Project,
                                                                       commandName: String,
-                                                                      method: JetMethodDescriptor,
+                                                                      method: KotlinMethodDescriptor,
                                                                       defaultValueContext: PsiElement): BaseRefactoringProcessor {
             val parameterTableModel = createParametersInfoModel(method, defaultValueContext)
             parameterTableModel.setParameterInfos(method.getParameters())
@@ -397,15 +397,15 @@ public class JetChangeSignatureDialog(
                                                 method.getVisibility(),
                                                 method.getName(),
                                                 defaultValueContext)
-            return JetChangeSignatureProcessor(project, changeInfo, commandName)
+            return KotlinChangeSignatureProcessor(project, changeInfo, commandName)
         }
 
-        private fun evaluateChangeInfo(parametersModel: JetCallableParameterTableModel,
+        private fun evaluateChangeInfo(parametersModel: KotlinCallableParameterTableModel,
                                        returnTypeCodeFragment: PsiCodeFragment?,
-                                       methodDescriptor: JetMethodDescriptor,
+                                       methodDescriptor: KotlinMethodDescriptor,
                                        visibility: Visibility?,
                                        methodName: String,
-                                       defaultValueContext: PsiElement): JetChangeInfo {
+                                       defaultValueContext: PsiElement): KotlinChangeInfo {
             val parameters = parametersModel.getItems().map { parameter ->
                 val parameterInfo = parameter.parameter
 
@@ -422,14 +422,14 @@ public class JetChangeSignatureDialog(
             val returnTypeText = if (returnTypeCodeFragment != null) returnTypeCodeFragment.getText().trim() else ""
             //TODO return the actual type
             val returnType = if (hasTypeReference(returnTypeCodeFragment)) methodDescriptor.baseDescriptor.builtIns.anyType else null
-            return JetChangeInfo(methodDescriptor.original,
+            return KotlinChangeInfo(methodDescriptor.original,
-                                 methodName,
+                                    methodName,
-                                 returnType,
+                                    returnType,
-                                 returnTypeText,
+                                    returnTypeText,
                                  visibility ?: Visibilities.DEFAULT_VISIBILITY,
-                                 parameters,
+                                    parameters,
-                                 parametersModel.getReceiver(),
+                                    parametersModel.getReceiver(),
-                                 defaultValueContext)
+                                    defaultValueContext)
         }
 
         private fun hasTypeReference(codeFragment: PsiCodeFragment?): Boolean

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinFunctionParameterTableModel.java

@@ -24,20 +24,20 @@ import com.intellij.ui.BooleanTableCellRenderer;
 import com.intellij.util.ui.ColumnInfo;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinFileType;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo;
 
 import javax.swing.table.TableCellEditor;
 import javax.swing.table.TableCellRenderer;
 
-public class JetFunctionParameterTableModel extends JetCallableParameterTableModel {
+public class KotlinFunctionParameterTableModel extends KotlinCallableParameterTableModel {
-    public JetFunctionParameterTableModel(JetMethodDescriptor methodDescriptor, PsiElement context) {
+    public KotlinFunctionParameterTableModel(KotlinMethodDescriptor methodDescriptor, PsiElement context) {
         super(methodDescriptor,
               context,
               new NameColumn(context.getProject()),
               new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
-              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(),
+              new DefaultValueColumn<KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>>(context.getProject(),
-                                                                                                      KotlinFileType.INSTANCE),
+                                                                                                            KotlinFileType.INSTANCE),
               new ReceiverColumn(context.getProject(), methodDescriptor));
     }
 
@@ -51,11 +51,11 @@ public class JetFunctionParameterTableModel extends JetCallableParameterTableMod
 
     @Override
     @Nullable
-    public JetParameterInfo getReceiver() {
+    public KotlinParameterInfo getReceiver() {
         return ((ReceiverColumn)getColumnInfos()[getColumnCount() - 1]).receiver;
     }
 
-    public void setReceiver(@Nullable JetParameterInfo receiver) {
+    public void setReceiver(@Nullable KotlinParameterInfo receiver) {
         ((ReceiverColumn)getColumnInfos()[getColumnCount() - 1]).receiver = receiver;
     }
 
@@ -63,13 +63,13 @@ public class JetFunctionParameterTableModel extends JetCallableParameterTableMod
         return column instanceof ReceiverColumn;
     }
 
-    protected static class ReceiverColumn<TableItem extends ParameterTableModelItemBase<JetParameterInfo>>
+    protected static class ReceiverColumn<TableItem extends ParameterTableModelItemBase<KotlinParameterInfo>>
-            extends ColumnInfoBase<JetParameterInfo, TableItem, Boolean> {
+            extends ColumnInfoBase<KotlinParameterInfo, TableItem, Boolean> {
         private final Project project;
         @Nullable
-        private JetParameterInfo receiver;
+        private KotlinParameterInfo receiver;
 
-        public ReceiverColumn(Project project, @Nullable JetMethodDescriptor methodDescriptor) {
+        public ReceiverColumn(Project project, @Nullable KotlinMethodDescriptor methodDescriptor) {
             super("Receiver:");
             this.project = project;
             this.receiver = methodDescriptor != null ? methodDescriptor.getReceiver() : null;

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinPrimaryConstructorParameterTableModel.java

@@ -22,56 +22,56 @@ import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import com.intellij.util.ui.ColumnInfo;
 import org.jdesktop.swingx.autocomplete.ComboBoxCellEditor;
 import org.jetbrains.kotlin.idea.KotlinFileType;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar;
 
 import javax.swing.*;
 import javax.swing.table.TableCellEditor;
 import javax.swing.table.TableCellRenderer;
 
-public class JetPrimaryConstructorParameterTableModel extends JetCallableParameterTableModel {
+public class KotlinPrimaryConstructorParameterTableModel extends KotlinCallableParameterTableModel {
-    public JetPrimaryConstructorParameterTableModel(JetMethodDescriptor methodDescriptor, PsiElement context) {
+    public KotlinPrimaryConstructorParameterTableModel(KotlinMethodDescriptor methodDescriptor, PsiElement context) {
         super(methodDescriptor,
               context,
               new ValVarColumn(),
               new NameColumn(context.getProject()),
               new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
-              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
+              new DefaultValueColumn<KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
     }
 
     public static boolean isValVarColumn(ColumnInfo column) {
         return column instanceof ValVarColumn;
     }
 
-    protected static class ValVarColumn extends ColumnInfoBase<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>, JetValVar> {
+    protected static class ValVarColumn extends ColumnInfoBase<KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>, KotlinValVar> {
         public ValVarColumn() {
-            super(JetRefactoringBundle.message("column.name.val.var"));
+            super(KotlinRefactoringBundle.message("column.name.val.var"));
         }
 
         @Override
-        public boolean isCellEditable(ParameterTableModelItemBase<JetParameterInfo> item) {
+        public boolean isCellEditable(ParameterTableModelItemBase<KotlinParameterInfo> item) {
             return !item.isEllipsisType() && item.parameter.isNewParameter();
         }
 
         @Override
-        public JetValVar valueOf(ParameterTableModelItemBase<JetParameterInfo> item) {
+        public KotlinValVar valueOf(ParameterTableModelItemBase<KotlinParameterInfo> item) {
             return item.parameter.getValOrVar();
         }
 
         @Override
-        public void setValue(ParameterTableModelItemBase<JetParameterInfo> item, JetValVar value) {
+        public void setValue(ParameterTableModelItemBase<KotlinParameterInfo> item, KotlinValVar value) {
             item.parameter.setValOrVar(value);
         }
 
         @Override
-        public TableCellRenderer doCreateRenderer(ParameterTableModelItemBase<JetParameterInfo> item) {
+        public TableCellRenderer doCreateRenderer(ParameterTableModelItemBase<KotlinParameterInfo> item) {
-            return new ComboBoxTableRenderer<JetValVar>(JetValVar.values());
+            return new ComboBoxTableRenderer<KotlinValVar>(KotlinValVar.values());
         }
 
         @Override
-        public TableCellEditor doCreateEditor(ParameterTableModelItemBase<JetParameterInfo> item) {
+        public TableCellEditor doCreateEditor(ParameterTableModelItemBase<KotlinParameterInfo> item) {
             return new ComboBoxCellEditor(new JComboBox());
         }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/KotlinSecondaryConstructorParameterTableModel.java

@@ -19,15 +19,15 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui;
 import com.intellij.psi.PsiElement;
 import com.intellij.refactoring.changeSignature.ParameterTableModelItemBase;
 import org.jetbrains.kotlin.idea.KotlinFileType;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor;
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo;
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo;
 
-public class JetSecondaryConstructorParameterTableModel extends JetCallableParameterTableModel {
+public class KotlinSecondaryConstructorParameterTableModel extends KotlinCallableParameterTableModel {
-    public JetSecondaryConstructorParameterTableModel(JetMethodDescriptor methodDescriptor, PsiElement context) {
+    public KotlinSecondaryConstructorParameterTableModel(KotlinMethodDescriptor methodDescriptor, PsiElement context) {
         super(methodDescriptor,
               context,
               new NameColumn(context.getProject()),
               new TypeColumn(context.getProject(), KotlinFileType.INSTANCE),
-              new DefaultValueColumn<JetParameterInfo, ParameterTableModelItemBase<JetParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
+              new DefaultValueColumn<KotlinParameterInfo, ParameterTableModelItemBase<KotlinParameterInfo>>(context.getProject(), KotlinFileType.INSTANCE));
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodDeferredKotlinUsage.kt

@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 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.idea.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
 import org.jetbrains.kotlin.psi.KtFunction
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.types.KotlinType
 
 public abstract class JavaMethodDeferredKotlinUsage<T : PsiElement>(element: T) : UsageInfo(element) {
-    abstract fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<T>
+    abstract fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<T>
 }
 
 public class DeferredJavaMethodOverrideOrSAMUsage(
@@ -34,9 +34,9 @@ public class DeferredJavaMethodOverrideOrSAMUsage(
         val functionDescriptor: FunctionDescriptor,
         val samCallType: KotlinType?
 ) : JavaMethodDeferredKotlinUsage<KtFunction>(function) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtFunction> {
+    override fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<KtFunction> {
         return object : JavaMethodKotlinUsageWithDelegate<KtFunction>(function, javaMethodChangeInfo) {
-            override val delegateUsage = JetCallableDefinitionUsage(function, functionDescriptor, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable, samCallType)
+            override val delegateUsage = KotlinCallableDefinitionUsage(function, functionDescriptor, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable, samCallType)
         }
     }
 }
@@ -44,7 +44,7 @@ public class DeferredJavaMethodOverrideOrSAMUsage(
 public class DeferredJavaMethodKotlinCallerUsage(
         val declaration: KtNamedDeclaration
 ) : JavaMethodDeferredKotlinUsage<KtNamedDeclaration>(declaration) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtNamedDeclaration> {
+    override fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<KtNamedDeclaration> {
         return object : JavaMethodKotlinUsageWithDelegate<KtNamedDeclaration>(declaration, javaMethodChangeInfo) {
             override val delegateUsage = KotlinCallerUsage(declaration)
         }
@@ -54,9 +54,9 @@ public class DeferredJavaMethodKotlinCallerUsage(
 public class JavaConstructorDeferredUsageInDelegationCall(
         val delegationCall: KtConstructorDelegationCall
 ) : JavaMethodDeferredKotlinUsage<KtConstructorDelegationCall>(delegationCall) {
-    override fun resolve(javaMethodChangeInfo: JetChangeInfo): JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall> {
+    override fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall> {
         return object : JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
-            override val delegateUsage = JetConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
+            override val delegateUsage = KotlinConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
         }
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JavaMethodKotlinUsageWithDelegate.kt

@@ -18,27 +18,27 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
 import com.intellij.psi.PsiElement
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.psi.KtCallElement
 import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
 
 public abstract class JavaMethodKotlinUsageWithDelegate<T: PsiElement>(
         val psiElement: T,
-        var javaMethodChangeInfo: JetChangeInfo): UsageInfo(psiElement) {
+        var javaMethodChangeInfo: KotlinChangeInfo): UsageInfo(psiElement) {
-    abstract val delegateUsage: JetUsageInfo<T>
+    abstract val delegateUsage: KotlinUsageInfo<T>
 
     fun processUsage(allUsages: Array<UsageInfo>): Boolean = delegateUsage.processUsage(javaMethodChangeInfo, psiElement, allUsages)
 }
 
 public class JavaMethodKotlinCallUsage(
         callElement: KtCallElement,
-        javaMethodChangeInfo: JetChangeInfo,
+        javaMethodChangeInfo: KotlinChangeInfo,
         propagationCall: Boolean
 ): JavaMethodKotlinUsageWithDelegate<KtCallElement>(callElement, javaMethodChangeInfo) {
     @Suppress("UNCHECKED_CAST")
     override val delegateUsage = when {
         propagationCall -> KotlinCallerCallUsage(psiElement)
-        psiElement is KtConstructorDelegationCall -> JetConstructorDelegationCallUsage(psiElement, javaMethodChangeInfo)
+        psiElement is KtConstructorDelegationCall -> KotlinConstructorDelegationCallUsage(psiElement, javaMethodChangeInfo)
-        else -> JetFunctionCallUsage(psiElement, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable)
+        else -> KotlinFunctionCallUsage(psiElement, javaMethodChangeInfo.methodDescriptor.originalPrimaryCallable)
-    } as JetUsageInfo<KtCallElement>
+    } as KotlinUsageInfo<KtCallElement>
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallableDefinitionUsage.kt

@@ -30,9 +30,9 @@ import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorIfAbse
 import org.jetbrains.kotlin.idea.core.refactoring.replaceListPsiAndKeepDelimiters
 import org.jetbrains.kotlin.idea.core.setVisibility
 import org.jetbrains.kotlin.idea.core.toKeywordToken
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.getCallableSubstitutor
 import org.jetbrains.kotlin.idea.util.ShortenReferences
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
@@ -48,13 +48,13 @@ import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.substitutions.getTypeSubstitutor
 import org.jetbrains.kotlin.utils.sure
 
-class JetCallableDefinitionUsage<T : PsiElement>(
+class KotlinCallableDefinitionUsage<T : PsiElement>(
         function: T,
         val originalCallableDescriptor: CallableDescriptor,
-        baseFunction: JetCallableDefinitionUsage<PsiElement>?,
+        baseFunction: KotlinCallableDefinitionUsage<PsiElement>?,
         private val samCallType: KotlinType?
-) : JetUsageInfo<T>(function) {
+) : KotlinUsageInfo<T>(function) {
-    val baseFunction: JetCallableDefinitionUsage<*> = baseFunction ?: this
+    val baseFunction: KotlinCallableDefinitionUsage<*> = baseFunction ?: this
 
     val hasExpectedType: Boolean = checkIfHasExpectedType(originalCallableDescriptor, isInherited)
 
@@ -98,7 +98,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
     val isInherited: Boolean
         get() = baseFunction !== this
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
         if (element !is KtNamedDeclaration) return true
 
         val psiFactory = KtPsiFactory(element.project)
@@ -142,7 +142,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
         return true
     }
 
-    protected fun changeReturnTypeIfNeeded(changeInfo: JetChangeInfo, element: PsiElement) {
+    protected fun changeReturnTypeIfNeeded(changeInfo: KotlinChangeInfo, element: PsiElement) {
         if (element !is KtCallableDeclaration) return
         if (element is KtConstructor<*>) return
 
@@ -166,7 +166,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
     }
 
     private fun processParameterListWithStructuralChanges(
-            changeInfo: JetChangeInfo,
+            changeInfo: KotlinChangeInfo,
             element: PsiElement,
             originalParameterList: KtParameterList?,
             psiFactory: KtPsiFactory) {
@@ -224,7 +224,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
         newParameterList.addToShorteningWaitSet(Options.DEFAULT)
     }
 
-    private fun changeVisibility(changeInfo: JetChangeInfo, element: PsiElement) {
+    private fun changeVisibility(changeInfo: KotlinChangeInfo, element: PsiElement) {
         val newVisibilityToken = changeInfo.newVisibility.toKeywordToken()
         when (element) {
             is KtCallableDeclaration -> element.setVisibility(newVisibilityToken)
@@ -233,7 +233,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
         }
     }
 
-    private fun changeParameter(parameterIndex: Int, parameter: KtParameter, parameterInfo: JetParameterInfo) {
+    private fun changeParameter(parameterIndex: Int, parameter: KtParameter, parameterInfo: KotlinParameterInfo) {
         val valOrVarKeyword = parameter.valOrVarKeyword
         val valOrVar = parameterInfo.valOrVar
 
@@ -247,7 +247,7 @@ class JetCallableDefinitionUsage<T : PsiElement>(
                 valOrVarKeyword.delete()
             }
         }
-        else if (valOrVar != JetValVar.None && newKeyword != null) {
+        else if (valOrVar != KotlinValVar.None && newKeyword != null) {
             val firstChild = parameter.firstChild
             parameter.addBefore(newKeyword, firstChild)
             parameter.addBefore(psiFactory.createWhiteSpace(), firstChild)

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinCallerUsages.kt

@@ -19,16 +19,16 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorParameterListIfAbsent
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBody
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
 
-public class KotlinCallerUsage(element: KtNamedDeclaration): JetUsageInfo<KtNamedDeclaration>(element) {
+public class KotlinCallerUsage(element: KtNamedDeclaration): KotlinUsageInfo<KtNamedDeclaration>(element) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
         // Do not process function twice
-        if (changeInfo.getAffectedCallables().any { it is JetCallableDefinitionUsage<*> && it.getElement() == element }) return true
+        if (changeInfo.getAffectedCallables().any { it is KotlinCallableDefinitionUsage<*> && it.getElement() == element }) return true
 
         val parameterList = when (element) {
             is KtFunction -> element.getValueParameterList()
@@ -50,8 +50,8 @@ public class KotlinCallerUsage(element: KtNamedDeclaration): JetUsageInfo<KtName
     }
 }
 
-public class KotlinCallerCallUsage(element: KtCallElement): JetUsageInfo<KtCallElement>(element) {
+public class KotlinCallerCallUsage(element: KtCallElement): KotlinUsageInfo<KtCallElement>(element) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
         val argumentList = element.getValueArgumentList() ?: return true
         val psiFactory = KtPsiFactory(getProject())
         val isNamedCall = argumentList.getArguments().any { it.getArgumentName() != null }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinConstructorDelegationCallUsage.kt

@@ -17,18 +17,18 @@
 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.KotlinChangeInfo
 import org.jetbrains.kotlin.psi.KtConstructorDelegationCall
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.KtSecondaryConstructor
 
-public class JetConstructorDelegationCallUsage(
+public class KotlinConstructorDelegationCallUsage(
         call: KtConstructorDelegationCall,
-        changeInfo: JetChangeInfo
+        changeInfo: KotlinChangeInfo
-) : JetUsageInfo<KtConstructorDelegationCall>(call) {
+) : KotlinUsageInfo<KtConstructorDelegationCall>(call) {
-    val delegate = JetFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryCallable)
+    val delegate = KotlinFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryCallable)
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
         val isThisCall = element.isCallToThis()
 
         var elementToWorkWith = element

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinEnumEntryWithoutSuperCallUsage.kt

@@ -17,14 +17,11 @@
 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.KotlinChangeInfo
-import org.jetbrains.kotlin.psi.KtDelegatorToSuperCall
+import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.psi.KtEnumEntry
-import org.jetbrains.kotlin.psi.KtInitializerList
-import org.jetbrains.kotlin.psi.KtPsiFactory
 
-public class JetEnumEntryWithoutSuperCallUsage(enumEntry: KtEnumEntry) : JetUsageInfo<KtEnumEntry>(enumEntry) {
+public class KotlinEnumEntryWithoutSuperCallUsage(enumEntry: KtEnumEntry) : KotlinUsageInfo<KtEnumEntry>(enumEntry) {
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
         if (changeInfo.newParameters.size() > 0) {
             val psiFactory = KtPsiFactory(element)
 
@@ -33,7 +30,7 @@ public class JetEnumEntryWithoutSuperCallUsage(enumEntry: KtEnumEntry) : JetUsag
                     element.nameIdentifier
             ) as KtInitializerList).initializers[0] as KtDelegatorToSuperCall
 
-            return JetFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryCallable)
+            return KotlinFunctionCallUsage(delegatorToSuperCall, changeInfo.methodDescriptor.originalPrimaryCallable)
                     .processUsage(changeInfo, delegatorToSuperCall, allUsages)
         }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinFunctionCallUsage.kt

@@ -27,8 +27,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.core.moveFunctionLiteralOutsideParentheses
 import org.jetbrains.kotlin.idea.core.refactoring.replaceListPsiAndKeepDelimiters
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBody
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.createNameCounterpartMap
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinIntroduceVariableHandler
@@ -53,14 +53,14 @@ import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.utils.sure
 import java.util.*
 
-class JetFunctionCallUsage(
+class KotlinFunctionCallUsage(
         element: KtCallElement,
-        private val callee: JetCallableDefinitionUsage<*>
+        private val callee: KotlinCallableDefinitionUsage<*>
-) : JetUsageInfo<KtCallElement>(element) {
+) : KotlinUsageInfo<KtCallElement>(element) {
     private val context = element.analyze(BodyResolveMode.FULL)
     private val resolvedCall = element.getResolvedCall(context)
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
         if (shouldSkipUsage(element)) return true
 
         changeNameIfNeeded(changeInfo, element)
@@ -106,7 +106,7 @@ class JetFunctionCallUsage(
             return resolvedCall?.resultingDescriptor is JavaMethodDescriptor
         }
 
-    protected fun changeNameIfNeeded(changeInfo: JetChangeInfo, element: KtCallElement) {
+    protected fun changeNameIfNeeded(changeInfo: KotlinChangeInfo, element: KtCallElement) {
         if (!changeInfo.isNameChanged) return
 
         val callee = element.calleeExpression
@@ -238,7 +238,7 @@ class JetFunctionCallUsage(
     }
 
     class ArgumentInfo(
-            val parameter: JetParameterInfo,
+            val parameter: KotlinParameterInfo,
             val parameterIndex: Int,
             val resolvedArgument: ResolvedValueArgument?,
             val receiverValue: ReceiverValue?
@@ -252,7 +252,7 @@ class JetFunctionCallUsage(
         var name: String? = null
             private set
 
-        fun makeNamed(callee: JetCallableDefinitionUsage<*>) {
+        fun makeNamed(callee: KotlinCallableDefinitionUsage<*>) {
             name = parameter.getInheritedName(callee)
         }
 
@@ -290,7 +290,7 @@ class JetFunctionCallUsage(
         }
     }
 
-    private fun updateArgumentsAndReceiver(changeInfo: JetChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>) {
+    private fun updateArgumentsAndReceiver(changeInfo: KotlinChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>) {
         if (isPropertyJavaUsage) return updateJavaPropertyCall(changeInfo, element)
 
         val fullCallElement = element.getQualifiedExpressionForSelector() ?: element
@@ -439,7 +439,7 @@ class JetFunctionCallUsage(
         }
     }
 
-    private fun changeArgumentNames(changeInfo: JetChangeInfo, element: KtCallElement) {
+    private fun changeArgumentNames(changeInfo: KotlinChangeInfo, element: KtCallElement) {
         for (argument in element.valueArguments) {
             val argumentName = argument.getArgumentName()
             val argumentNameExpression = argumentName?.referenceExpression ?: continue
@@ -450,7 +450,7 @@ class JetFunctionCallUsage(
         }
     }
 
-    private fun changeArgumentName(argumentNameExpression: KtSimpleNameExpression?, parameterInfo: JetParameterInfo) {
+    private fun changeArgumentName(argumentNameExpression: KtSimpleNameExpression?, parameterInfo: KotlinParameterInfo) {
         val identifier = argumentNameExpression?.getIdentifier() ?: return
         val newName = parameterInfo.getInheritedName(callee)
         identifier.replace(KtPsiFactory(project).createIdentifier(newName))
@@ -471,7 +471,7 @@ class JetFunctionCallUsage(
 
         private val SHORTEN_ARGUMENTS_OPTIONS = ShortenReferences.Options(true, true)
 
-        private fun updateJavaPropertyCall(changeInfo: JetChangeInfo, element: KtCallElement) {
+        private fun updateJavaPropertyCall(changeInfo: KotlinChangeInfo, element: KtCallElement) {
             val newReceiverInfo = changeInfo.receiverParameterInfo
             val originalReceiverInfo = changeInfo.methodDescriptor.receiver
             if (newReceiverInfo == originalReceiverInfo) return

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinImplicitThisToParameterUsage.kt

@@ -17,8 +17,8 @@
 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.KotlinChangeInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.KtQualifiedExpression
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -26,14 +26,14 @@ 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: KtElement): JetUsageInfo<KtElement>(callElement) {
+public abstract class KotlinImplicitReceiverUsage(callElement: KtElement): KotlinUsageInfo<KtElement>(callElement) {
     protected abstract fun getNewReceiverText(): String
 
     protected open fun processReplacedElement(element: KtElement) {
 
     }
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtElement, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtElement, allUsages: Array<out UsageInfo>): Boolean {
         val newQualifiedCall = KtPsiFactory(element.getProject()).createExpression(
                 "${getNewReceiverText()}.${element.getText()}"
         ) as KtQualifiedExpression
@@ -42,11 +42,11 @@ public abstract class JetImplicitReceiverUsage(callElement: KtElement): JetUsage
     }
 }
 
-public class JetImplicitThisToParameterUsage(
+public class KotlinImplicitThisToParameterUsage(
         callElement: KtElement,
-        val parameterInfo: JetParameterInfo,
+        val parameterInfo: KotlinParameterInfo,
-        val containingCallable: JetCallableDefinitionUsage<*>
+        val containingCallable: KotlinCallableDefinitionUsage<*>
-): JetImplicitReceiverUsage(callElement) {
+): KotlinImplicitReceiverUsage(callElement) {
     override fun getNewReceiverText(): String = parameterInfo.getInheritedName(containingCallable)
 
     override fun processReplacedElement(element: KtElement) {
@@ -54,10 +54,10 @@ public class JetImplicitThisToParameterUsage(
     }
 }
 
-public class JetImplicitThisUsage(
+public class KotlinImplicitThisUsage(
         callElement: KtElement,
         val targetDescriptor: DeclarationDescriptor
-): JetImplicitReceiverUsage(callElement) {
+): KotlinImplicitReceiverUsage(callElement) {
     override fun getNewReceiverText(): String {
         val name = targetDescriptor.getName()
         return if (name.isSpecial()) "this" else "this@${name.asString()}"

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinParameterUsage.kt

@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 import com.intellij.usageView.UsageInfo
 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.KotlinChangeInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
@@ -30,14 +30,14 @@ 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 : KtElement>(element: T) : JetUsageInfo<T>(element) {
+public abstract class KotlinExplicitReferenceUsage<T : KtElement>(element: T) : KotlinUsageInfo<T>(element) {
-    abstract fun getReplacementText(changeInfo: JetChangeInfo): String
+    abstract fun getReplacementText(changeInfo: KotlinChangeInfo): String
 
     protected open fun processReplacedElement(element: KtElement) {
 
     }
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
         val newElement = KtPsiFactory(element.getProject()).createExpression(getReplacementText(changeInfo))
         val elementToReplace = (element.getParent() as? KtThisExpression) ?: element
         processReplacedElement(elementToReplace.replace(newElement) as KtElement)
@@ -45,18 +45,18 @@ public abstract class JetExplicitReferenceUsage<T : KtElement>(element: T) : Jet
     }
 }
 
-public class JetParameterUsage(
+public class KotlinParameterUsage(
         element: KtElement,
-        private val parameterInfo: JetParameterInfo,
+        private val parameterInfo: KotlinParameterInfo,
-        val containingCallable: JetCallableDefinitionUsage<*>
+        val containingCallable: KotlinCallableDefinitionUsage<*>
-) : JetExplicitReferenceUsage<KtElement>(element) {
+) : KotlinExplicitReferenceUsage<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))
     }
 
-    override fun getReplacementText(changeInfo: JetChangeInfo): String {
+    override fun getReplacementText(changeInfo: KotlinChangeInfo): String {
         if (changeInfo.receiverParameterInfo != parameterInfo) return parameterInfo.getInheritedName(containingCallable)
 
         val newName = changeInfo.getNewName()
@@ -66,13 +66,13 @@ public class JetParameterUsage(
     }
 }
 
-public class JetNonQualifiedOuterThisUsage(
+public class KotlinNonQualifiedOuterThisUsage(
         element: KtThisExpression,
         val targetDescriptor: DeclarationDescriptor
-) : JetExplicitReferenceUsage<KtThisExpression>(element) {
+) : KotlinExplicitReferenceUsage<KtThisExpression>(element) {
     override fun processReplacedElement(element: KtElement) {
         element.addToShorteningWaitSet(Options(removeThisLabels = true))
     }
 
-    override fun getReplacementText(changeInfo: JetChangeInfo): String = "this@${targetDescriptor.getName().asString()}"
+    override fun getReplacementText(changeInfo: KotlinChangeInfo): String = "this@${targetDescriptor.getName().asString()}"
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinPropertyCallUsage.kt

@@ -18,7 +18,7 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 
 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.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.idea.references.mainReference
 import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.KtQualifiedExpression
@@ -28,22 +28,22 @@ 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: KtSimpleNameExpression): JetUsageInfo<KtSimpleNameExpression>(element) {
+public class KotlinPropertyCallUsage(element: KtSimpleNameExpression): KotlinUsageInfo<KtSimpleNameExpression>(element) {
     private val resolvedCall = element.getResolvedCall(element.analyze())
 
-    override fun processUsage(changeInfo: JetChangeInfo, element: KtSimpleNameExpression, allUsages: Array<out UsageInfo>): Boolean {
+    override fun processUsage(changeInfo: KotlinChangeInfo, element: KtSimpleNameExpression, allUsages: Array<out UsageInfo>): Boolean {
         updateName(changeInfo, element)
         updateReceiver(changeInfo, element)
         return true
     }
 
-    private fun updateName(changeInfo: JetChangeInfo, element: KtSimpleNameExpression) {
+    private fun updateName(changeInfo: KotlinChangeInfo, element: KtSimpleNameExpression) {
         if (changeInfo.isNameChanged()) {
             element.mainReference.handleElementRename(changeInfo.getNewName())
         }
     }
 
-    private fun updateReceiver(changeInfo: JetChangeInfo, element: KtSimpleNameExpression) {
+    private fun updateReceiver(changeInfo: KotlinChangeInfo, element: KtSimpleNameExpression) {
         val newReceiver = changeInfo.receiverParameterInfo
         val oldReceiver = changeInfo.methodDescriptor.receiver
         if (newReceiver == oldReceiver) return

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/KotlinUsageInfo.kt

@@ -19,14 +19,14 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature.usages
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiReference
 import com.intellij.usageView.UsageInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
 
-public abstract class JetUsageInfo<T : PsiElement> : UsageInfo {
+public abstract class KotlinUsageInfo<T : PsiElement> : UsageInfo {
     public constructor(element: T) : super(element)
     public constructor(reference: PsiReference) : super(reference)
 
     @Suppress("UNCHECKED_CAST")
     override fun getElement() = super.getElement() as T?
 
-    public abstract fun processUsage(changeInfo: JetChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean
+    public abstract fun processUsage(changeInfo: KotlinChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ExtractKotlinFunctionHandler.kt

@@ -23,7 +23,7 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.psi.PsiElement
 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.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinExtractFunctionDialog
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtBlockExpression
@@ -83,4 +83,4 @@ public class ExtractKotlinFunctionHandler(
     }
 }
 
-val EXTRACT_FUNCTION: String = JetRefactoringBundle.message("extract.function")
+val EXTRACT_FUNCTION: String = KotlinRefactoringBundle.message("extract.function")

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/KotlinExtractFunctionDialog.java

@@ -32,7 +32,7 @@ import org.jetbrains.annotations.Nullable;
 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.KotlinRefactoringBundle;
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.lexer.KtTokens;
@@ -78,7 +78,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
         this.onAccept = onAccept;
 
         setModal(true);
-        setTitle(JetRefactoringBundle.message("extract.function"));
+        setTitle(KotlinRefactoringBundle.message("extract.function"));
         init();
         update();
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.replaced
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.AnalysisResult.ErrorMessage
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.AnalysisResult.Status
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.ExpressionValue
@@ -457,7 +457,7 @@ class AnalysisResult (
         }
 
         fun renderMessage(): String {
-            val message = JetRefactoringBundle.message(
+            val message = KotlinRefactoringBundle.message(
                     when (this) {
                         NO_EXPRESSION -> "cannot.refactor.no.expression"
                         NO_CONTAINER -> "cannot.refactor.no.container"

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/duplicateUtil.kt

@@ -24,7 +24,7 @@ import com.intellij.openapi.editor.Editor
 import java.util.ArrayList
 import com.intellij.openapi.editor.markup.RangeHighlighter
 import com.intellij.openapi.editor.ScrollType
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import com.intellij.openapi.application.ApplicationNamesInfo
 import com.intellij.openapi.editor.colors.EditorColorsManager
 import com.intellij.openapi.editor.colors.EditorColors
@@ -79,7 +79,7 @@ public fun processDuplicates(
     else
         Messages.showYesNoDialog(
                 project,
-                JetRefactoringBundle.message(
+                KotlinRefactoringBundle.message(
                         "0.has.detected.1.code.fragments.in.this.file.that.can.be.replaced.with.a.call.to.extracted.declaration",
                         ApplicationNamesInfo.getInstance().getProductName(),
                         duplicateReplacers.size()

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt

@@ -46,7 +46,7 @@ import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator
 import org.jetbrains.kotlin.idea.core.compareDescriptors
 import org.jetbrains.kotlin.idea.core.refactoring.createTempCopy
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.AnalysisResult.ErrorMessage
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.AnalysisResult.Status
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.OutputValue.*
@@ -986,7 +986,7 @@ internal fun KtNamedDeclaration.getGeneratedBody() =
 
 fun ExtractableCodeDescriptor.validate(): ExtractableCodeDescriptorWithConflicts {
     fun getDeclarationMessage(declaration: PsiNamedElement, messageKey: String, capitalize: Boolean = true): String {
-        val message = JetRefactoringBundle.message(messageKey, RefactoringUIUtil.getDescription(declaration, true))
+        val message = KotlinRefactoringBundle.message(messageKey, RefactoringUIUtil.getDescription(declaration, true))
         return if (capitalize) message.capitalize() else message
     }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt

@@ -29,7 +29,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.ui.JBColor
 import com.intellij.ui.NonFocusableCheckBox
 import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorParameterListIfAbsent
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetValVar
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinValVar
 import org.jetbrains.kotlin.idea.refactoring.introduce.AbstractKotlinInplaceIntroducer
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
@@ -135,7 +135,7 @@ public class KotlinInplaceParameterIntroducer(
                         val parameterName = currentName ?: parameter.getName()
                         val parameterType = currentType ?: parameter.getTypeReference()!!.getText()
                         descriptor = descriptor.copy(newParameterName = parameterName!!, newParameterTypeText = parameterType)
-                        val modifier = if (valVar != JetValVar.None) "${valVar.keywordName} " else ""
+                        val modifier = if (valVar != KotlinValVar.None) "${valVar.keywordName} " else ""
                         val defaultValue = if (withDefaultValue) " = ${newArgumentValue.getText()}" else ""
 
                         "$modifier$parameterName: $parameterType$defaultValue"

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt

@@ -39,7 +39,7 @@ import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator
 import org.jetbrains.kotlin.idea.util.getResolutionScope
 import org.jetbrains.kotlin.idea.core.moveInsideParenthesesAndReplaceWith
 import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.refactoring.introduce.KotlinIntroduceHandlerBase
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -80,7 +80,7 @@ public data class IntroduceParameterDescriptor(
 ) {
     val originalOccurrence: KotlinPsiRange
         get() = occurrencesToReplace.first { it.getTextRange().intersects(originalRange.getTextRange()) }
-    val valVar: JetValVar
+    val valVar: KotlinValVar
 
     init {
         valVar = if (callable is KtClass) {
@@ -98,9 +98,9 @@ public data class IntroduceParameterDescriptor(
             }
             if (occurrencesToReplace.all {
                 PsiTreeUtil.findCommonParent(it.elements)?.parentsWithSelf?.any(modifierIsUnnecessary) ?: false
-            }) JetValVar.None else JetValVar.Val
+            }) KotlinValVar.None else KotlinValVar.Val
         }
-        else JetValVar.None
+        else KotlinValVar.None
     }
 }
 
@@ -123,8 +123,8 @@ fun getParametersToRemove(
 
 fun IntroduceParameterDescriptor.performRefactoring() {
     runWriteAction {
-        val config = object : JetChangeSignatureConfiguration {
+        val config = object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 return originalDescriptor.modify { methodDescriptor ->
                     if (!withDefaultValue) {
                         val parameters = callable.getValueParameters()
@@ -139,11 +139,11 @@ fun IntroduceParameterDescriptor.performRefactoring() {
                                 .forEach { methodDescriptor.removeParameter(it) }
                     }
 
-                    val parameterInfo = JetParameterInfo(callableDescriptor = callableDescriptor,
+                    val parameterInfo = KotlinParameterInfo(callableDescriptor = callableDescriptor,
-                                                         name = newParameterName,
+                                                            name = newParameterName,
-                                                         defaultValueForCall = if (withDefaultValue) null else newArgumentValue,
+                                                            defaultValueForCall = if (withDefaultValue) null else newArgumentValue,
-                                                         defaultValueForParameter = if (withDefaultValue) newArgumentValue else null,
+                                                            defaultValueForParameter = if (withDefaultValue) newArgumentValue else null,
-                                                         valOrVar = valVar)
+                                                            valOrVar = valVar)
                     parameterInfo.currentTypeText = newParameterTypeText
                     methodDescriptor.addParameter(parameterInfo)
                 }
@@ -214,7 +214,7 @@ public open class KotlinIntroduceParameterHandler(
         }
 
         if (expressionType.isUnit() || expressionType.isNothing()) {
-            val message = JetRefactoringBundle.message(
+            val message = KotlinRefactoringBundle.message(
                     "cannot.introduce.parameter.of.0.type",
                     IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(expressionType)
             )

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterMethodUsageProcessor.kt

@@ -31,14 +31,14 @@ 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
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureData
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureData
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetParameterInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.originalBaseFunctionDescriptor
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetCallableDefinitionUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetConstructorDelegationCallUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinConstructorDelegationCallUsage
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetFunctionCallUsage
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinFunctionCallUsage
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.JetUsageInfo
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinUsageInfo
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
 import org.jetbrains.kotlin.idea.search.declarationsSearch.searchOverriders
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
@@ -56,23 +56,23 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
 
     }
 
-    private fun createChangeInfo(data: IntroduceParameterData, method: PsiElement): JetChangeInfo? {
+    private fun createChangeInfo(data: IntroduceParameterData, method: PsiElement): KotlinChangeInfo? {
         val psiMethodDescriptor = when (method) {
             is KtFunction -> method.resolveToDescriptor() as? FunctionDescriptor
             is PsiMethod -> method.getJavaMethodDescriptor()
             else -> null
         } ?: return null
-        val changeSignatureData = JetChangeSignatureData(psiMethodDescriptor, method, Collections.singletonList(psiMethodDescriptor))
+        val changeSignatureData = KotlinChangeSignatureData(psiMethodDescriptor, method, Collections.singletonList(psiMethodDescriptor))
-        val changeInfo = JetChangeInfo(methodDescriptor = changeSignatureData, context = method)
+        val changeInfo = KotlinChangeInfo(methodDescriptor = changeSignatureData, context = method)
 
         data.getParametersToRemove().toNativeArray().sortedDescending().forEach { changeInfo.removeParameter(it) }
 
         // Temporarily assume that the new parameter is of Any type. Actual type is substituted during the signature update phase
         val defaultValueForCall = (data.getParameterInitializer().getExpression()!! as? PsiExpression)?.let { it.j2k() }
-        changeInfo.addParameter(JetParameterInfo(callableDescriptor = psiMethodDescriptor,
+        changeInfo.addParameter(KotlinParameterInfo(callableDescriptor = psiMethodDescriptor,
-                                                 name = data.getParameterName(),
+                                                    name = data.getParameterName(),
-                                                 type = psiMethodDescriptor.builtIns.anyType,
+                                                    type = psiMethodDescriptor.builtIns.anyType,
-                                                 defaultValueForCall = defaultValueForCall))
+                                                    defaultValueForCall = defaultValueForCall))
         return changeInfo
     }
 
@@ -92,7 +92,7 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
                 .map { it.unwrapped }
                 .filterIsInstance<KtFunction>()
         return (kotlinFunctions + element).all {
-            JetCallableDefinitionUsage(it, changeInfo.originalBaseFunctionDescriptor, null, null).processUsage(changeInfo, it, usages)
+            KotlinCallableDefinitionUsage(it, changeInfo.originalBaseFunctionDescriptor, null, null).processUsage(changeInfo, it, usages)
         }
     }
 
@@ -103,10 +103,10 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
         val callElement = refElement.getParentOfTypeAndBranch<KtCallElement>(true) { getCalleeExpression() } ?: return true
         val delegateUsage = if (callElement is KtConstructorDelegationCall) {
             @Suppress("CAST_NEVER_SUCCEEDS")
-            (JetConstructorDelegationCallUsage(callElement, changeInfo) as JetUsageInfo<KtCallElement>)
+            (KotlinConstructorDelegationCallUsage(callElement, changeInfo) as KotlinUsageInfo<KtCallElement>)
         }
         else {
-            JetFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
+            KotlinFunctionCallUsage(callElement, changeInfo.methodDescriptor.originalPrimaryCallable)
         }
         return delegateUsage.processUsage(changeInfo, callElement, usages)
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinIntroducePropertyHandler.kt

@@ -114,4 +114,4 @@ public class KotlinIntroducePropertyHandler(
     }
 }
 
-val INTRODUCE_PROPERTY: String = JetRefactoringBundle.message("introduce.property")
+val INTRODUCE_PROPERTY: String = KotlinRefactoringBundle.message("introduce.property")

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceUtil.kt

@@ -25,8 +25,8 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.util.PsiTreeUtil
 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.KotlinRefactoringBundle
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.psiUtil.collectDescendantsOfType
 import org.jetbrains.kotlin.psi.psiUtil.findDescendantOfType
@@ -37,7 +37,7 @@ fun showErrorHint(project: Project, editor: Editor, message: String, title: Stri
 }
 
 fun showErrorHintByKey(project: Project, editor: Editor, messageKey: String, title: String) {
-    showErrorHint(project, editor, JetRefactoringBundle.message(messageKey), title)
+    showErrorHint(project, editor, KotlinRefactoringBundle.message(messageKey), title)
 }
 
 fun selectElementsWithTargetSibling(
@@ -113,7 +113,7 @@ fun selectElementsWithTargetParent(
     }
 
     fun selectSingleExpression() {
-        JetRefactoringUtil.selectExpression(editor, file, false) { expr ->
+        KotlinRefactoringUtil.selectExpression(editor, file, false) { expr ->
             if (expr != null) {
                 selectTargetContainer(listOf(expr))
             }

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinIntroduceVariableHandler.java

@@ -45,8 +45,8 @@ import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator;
 import org.jetbrains.kotlin.idea.core.PsiModificationUtilsKt;
 import org.jetbrains.kotlin.idea.intentions.ConvertToBlockBodyIntention;
 import org.jetbrains.kotlin.idea.intentions.RemoveCurlyBracesFromTemplateIntention;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.idea.refactoring.introduce.IntroduceUtilKt;
 import org.jetbrains.kotlin.idea.refactoring.introduce.KotlinIntroduceHandlerBase;
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade;
@@ -76,20 +76,20 @@ import java.util.List;
 
 public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
 
-    public static final String INTRODUCE_VARIABLE = JetRefactoringBundle.message("introduce.variable");
+    public static final String INTRODUCE_VARIABLE = KotlinRefactoringBundle.message("introduce.variable");
 
     @Override
     public void invoke(@NotNull final Project project, @NotNull final Editor editor, @NotNull PsiFile file, DataContext dataContext) {
-        JetRefactoringUtil.SelectExpressionCallback callback = new JetRefactoringUtil.SelectExpressionCallback() {
+        KotlinRefactoringUtil.SelectExpressionCallback callback = new KotlinRefactoringUtil.SelectExpressionCallback() {
             @Override
             public void run(@Nullable KtExpression expression) {
                 doRefactoring(project, editor, expression, null, null);
             }
         };
         try {
-            JetRefactoringUtil.selectExpression(editor, file, callback);
+            KotlinRefactoringUtil.selectExpression(editor, file, callback);
         }
-        catch (JetRefactoringUtil.IntroduceRefactoringException e) {
+        catch (KotlinRefactoringUtil.IntroduceRefactoringException e) {
             showErrorHint(project, editor, e.getMessage());
         }
     }
@@ -103,7 +103,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
             @Nullable final Function1<KtProperty, Unit> onNonInteractiveFinish
     ) {
         if (_expression == null) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.expression"));
             return;
         }
         if (_expression.getParent() instanceof KtParenthesizedExpression) {
@@ -114,18 +114,18 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         if (expression.getParent() instanceof KtQualifiedExpression) {
             KtQualifiedExpression qualifiedExpression = (KtQualifiedExpression)expression.getParent();
             if (qualifiedExpression.getReceiverExpression() != expression) {
-                showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
+                showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.expression"));
                 return;
             }
         }
         else if (expression instanceof KtStatementExpression) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.expression"));
             return;
         }
         else if (expression.getParent() instanceof KtOperationExpression) {
             KtOperationExpression operationExpression = (KtOperationExpression)expression.getParent();
             if (operationExpression.getOperationReference() == expression) {
-                showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.expression"));
+                showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.expression"));
                 return;
             }
         }
@@ -133,7 +133,7 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         //noinspection unchecked
         if (PsiTreeUtil.getNonStrictParentOfType(expression,
                                                  KtTypeReference.class, KtConstructorCalleeExpression.class, KtSuperExpression.class) != null) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.container"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.container"));
             return;
         }
 
@@ -153,17 +153,17 @@ public class KotlinIntroduceVariableHandler extends KotlinIntroduceHandlerBase {
         }
 
         if (expressionType == null && bindingContext.get(BindingContext.QUALIFIER, expression) != null) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.package.expression"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.package.expression"));
             return;
         }
         if (expressionType != null && KotlinBuiltIns.isUnit(expressionType)) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.expression.has.unit.type"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.expression.has.unit.type"));
             return;
         }
         final PsiElement container = getContainer(expression);
         PsiElement occurrenceContainer = getOccurrenceContainer(expression);
         if (container == null) {
-            showErrorHint(project, editor, JetRefactoringBundle.message("cannot.refactor.no.container"));
+            showErrorHint(project, editor, KotlinRefactoringBundle.message("cannot.refactor.no.container"));
             return;
         }
         final boolean isInplaceAvailableOnDataContext =

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt

@@ -74,7 +74,7 @@ public class MoveKotlinFileHandler : MoveFileHandler() {
         val moveTarget = when (newPackageName) {
             UNKNOWN_PACKAGE_FQ_NAME -> EmptyKotlinMoveTarget
 
-            else -> DeferredJetFileKotlinMoveTarget(project, newPackageName.toSafe()) {
+            else -> KotlinMoveTargetForDeferredFile(project, newPackageName.toSafe()) {
                 MoveFilesOrDirectoriesUtil.doMoveFile(psiFile, newParent)
                 newParent?.findFile(psiFile.name) as? KtFile
             }

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/KotlinMoveTarget.kt

@@ -41,7 +41,7 @@ public object EmptyKotlinMoveTarget: KotlinMoveTarget {
     override fun verify(file: PsiFile) = null
 }
 
-public class JetFileKotlinMoveTarget(val targetFile: KtFile): KotlinMoveTarget {
+public class KotlinMoveTargetForExistingFile(val targetFile: KtFile): KotlinMoveTarget {
     override val packageWrapper: PackageWrapper? = targetFile.getPackageFqName().asString().let { packageName ->
         PackageWrapper(PsiManager.getInstance(targetFile.getProject()), packageName)
     }
@@ -54,7 +54,7 @@ public class JetFileKotlinMoveTarget(val targetFile: KtFile): KotlinMoveTarget {
     override fun verify(file: PsiFile): String? = null
 }
 
-public class DeferredJetFileKotlinMoveTarget(
+public class KotlinMoveTargetForDeferredFile(
         project: Project,
         private val packageFqName: FqName,
         private val createFile: (KtFile) -> KtFile?): KotlinMoveTarget {

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveDeclarationToSeparateFileIntention.kt

@@ -85,7 +85,7 @@ public class MoveDeclarationToSeparateFileIntention :
             }
             return
         }
-        val moveTarget = DeferredJetFileKotlinMoveTarget(project, packageName) {
+        val moveTarget = KotlinMoveTargetForDeferredFile(project, packageName) {
             createKotlinFile(targetFileName, directory, packageName.asString())
         }
         val moveOptions = MoveKotlinTopLevelDeclarationsOptions(

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt

@@ -48,7 +48,7 @@ import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
 import org.jetbrains.kotlin.idea.core.deleteSingle
 import org.jetbrains.kotlin.idea.core.getPackage
 import org.jetbrains.kotlin.idea.core.refactoring.getUsageContext
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
 import org.jetbrains.kotlin.idea.refactoring.move.*
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
@@ -92,7 +92,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
         val options: MoveKotlinTopLevelDeclarationsOptions,
         val mover: Mover = Mover.Default) : BaseRefactoringProcessor(project) {
     companion object {
-        private val REFACTORING_NAME: String = JetRefactoringBundle.message("refactoring.move.top.level.declarations")
+        private val REFACTORING_NAME: String = KotlinRefactoringBundle.message("refactoring.move.top.level.declarations")
     }
 
     private var nonCodeUsages: Array<NonCodeUsageInfo>? = null
@@ -172,7 +172,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
 
                 conflicts.putValue(
                         declaration,
-                        JetRefactoringBundle.message(
+                        KotlinRefactoringBundle.message(
                                 "package.private.0.will.no.longer.be.accessible.from.1",
                                 RefactoringUIUtil.getDescription(declaration, true),
                                 RefactoringUIUtil.getDescription(container, true)
@@ -210,7 +210,7 @@ public class MoveKotlinTopLevelDeclarationsProcessor(
 
                     conflicts.putValue(
                             declaration,
-                            JetRefactoringBundle.message(
+                            KotlinRefactoringBundle.message(
                                     "0.uses.package.private.1",
                                     RefactoringUIUtil.getDescription(declaration, true),
                                     RefactoringUIUtil.getDescription(refTarget, true)

idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/ui/MoveKotlinTopLevelDeclarationsDialog.java

@@ -64,7 +64,7 @@ import org.jetbrains.annotations.Nullable;
 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;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberSelectionPanel;
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberSelectionTable;
@@ -341,7 +341,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                 .withRoots(ProjectRootManager.getInstance(myProject).getContentRoots())
                 .withTreeRootVisible(true);
 
-        String title = JetRefactoringBundle.message("refactoring.move.top.level.declaration.file.title");
+        String title = KotlinRefactoringBundle.message("refactoring.move.top.level.declaration.file.title");
         fileChooser.addBrowseFolderListener(title, null, myProject, descriptor, TextComponentAccessor.TEXT_FIELD_WHOLE_TEXT);
 
         String initialTargetPath =
@@ -532,7 +532,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                 if (ret != Messages.YES) return null;
             }
 
-            return new DeferredJetFileKotlinMoveTarget(
+            return new KotlinMoveTargetForDeferredFile(
                     myProject,
                     new FqName(getTargetPackage()),
                     new Function1<KtFile, KtFile>() {
@@ -556,7 +556,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
                 return null;
             }
 
-            return new JetFileKotlinMoveTarget(jetFile);
+            return new KotlinMoveTargetForExistingFile(jetFile);
         }
 
         File targetDir = targetFile.getParentFile();
@@ -569,7 +569,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
             return null;
         }
 
-        return new DeferredJetFileKotlinMoveTarget(
+        return new KotlinMoveTargetForDeferredFile(
                 myProject,
                 new FqName(psiPackage.getQualifiedName()),
                 new Function1<KtFile, KtFile>() {
@@ -594,7 +594,7 @@ public class MoveKotlinTopLevelDeclarationsDialog extends RefactoringDialog {
         else {
             PsiFile targetFile = JetRefactoringUtilKt.toPsiFile(new File(getTargetFilePath()), myProject);
             if (!(targetFile == null || targetFile instanceof KtFile)) {
-                return JetRefactoringBundle.message("refactoring.move.non.kotlin.file");
+                return KotlinRefactoringBundle.message("refactoring.move.non.kotlin.file");
             }
         }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinParameterProcessor.kt

@@ -22,8 +22,8 @@ import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetChangeSignatureConfiguration
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureConfiguration
-import org.jetbrains.kotlin.idea.refactoring.changeSignature.JetMethodDescriptor
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.runChangeSignature
 import org.jetbrains.kotlin.psi.KtNamedFunction
@@ -49,8 +49,8 @@ public class RenameKotlinParameterProcessor : RenameKotlinPsiProcessor() {
             overriddenParameter -> OverrideResolver.shouldReportParameterNameOverrideWarning(parameterDescriptor, overriddenParameter)
         }
 
-        val changeSignatureConfiguration = object : JetChangeSignatureConfiguration {
+        val changeSignatureConfiguration = object : KotlinChangeSignatureConfiguration {
-            override fun configure(originalDescriptor: JetMethodDescriptor): JetMethodDescriptor {
+            override fun configure(originalDescriptor: KotlinMethodDescriptor): KotlinMethodDescriptor {
                 val paramInfoIndex = if (functionDescriptor.getExtensionReceiverParameter() != null) paramIndex + 1 else paramIndex
                 return originalDescriptor.modify { it.renameParameter(paramInfoIndex, newName) }
             }

idea/src/org/jetbrains/kotlin/idea/refactoring/rename/renameUtil.kt

@@ -17,16 +17,16 @@
 package org.jetbrains.kotlin.idea.refactoring.rename
 
 import com.intellij.psi.PsiElement
-import com.intellij.usageView.UsageInfo
-import java.util.ArrayList
-import com.intellij.refactoring.util.MoveRenameUsageInfo
 import com.intellij.refactoring.rename.UnresolvableCollisionUsageInfo
+import com.intellij.refactoring.util.MoveRenameUsageInfo
+import com.intellij.usageView.UsageInfo
 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.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.references.AbstractJetReference
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
+import java.util.*
 
 fun checkConflictsAndReplaceUsageInfos(result: MutableList<UsageInfo>) {
     val usagesToAdd = ArrayList<UsageInfo>()
@@ -52,7 +52,7 @@ class UnresolvableConventionViolationUsageInfo(
         element: PsiElement,
         referencedElement: PsiElement
 ) : UnresolvableCollisionUsageInfo(element, referencedElement) {
-    override fun getDescription(): String = JetRefactoringBundle.message("naming.convention.will.be.violated.after.rename")
+    override fun getDescription(): String = KotlinRefactoringBundle.message("naming.convention.will.be.violated.after.rename")
 }
 
 fun dropOverrideKeywordIfNecessary(element: KtNamedDeclaration) {

idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinOverridingDialog.java

@@ -37,7 +37,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
 import org.jetbrains.kotlin.idea.KotlinBundle;
 import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils;
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil;
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
 import org.jetbrains.kotlin.psi.KtElement;
 import org.jetbrains.kotlin.psi.KtNamedFunction;
@@ -110,7 +110,7 @@ class KotlinOverridingDialog extends DialogWrapper {
 
         assert element instanceof PsiMethod
                 : "Method accepts only kotlin functions/properties and java methods, but '" + element.getText() + "' was found";
-        return JetRefactoringUtil.formatPsiMethod((PsiMethod) element, true, false);
+        return KotlinRefactoringUtil.formatPsiMethod((PsiMethod) element, true, false);
     }
 
     @Override

idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt

@@ -38,7 +38,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.idea.KotlinBundle
 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.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.search.usagesSearch.processDelegationCallConstructorUsages
 import org.jetbrains.kotlin.lexer.KtTokens
@@ -236,10 +236,10 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
                     .mapTo(ArrayList<String>()) { overridenDescriptor ->
                         KotlinBundle.message(
                                 "x.implements.y",
-                                JetRefactoringUtil.formatFunction(declarationDescriptor, true),
+                                KotlinRefactoringUtil.formatFunction(declarationDescriptor, true),
-                                JetRefactoringUtil.formatClass(declarationDescriptor.getContainingDeclaration(), true),
+                                KotlinRefactoringUtil.formatClass(declarationDescriptor.getContainingDeclaration(), true),
-                                JetRefactoringUtil.formatFunction(overridenDescriptor, true),
+                                KotlinRefactoringUtil.formatFunction(overridenDescriptor, true),
-                                JetRefactoringUtil.formatClass(overridenDescriptor.getContainingDeclaration(), true)
+                                KotlinRefactoringUtil.formatClass(overridenDescriptor.getContainingDeclaration(), true)
                         )
                     }
         }
@@ -308,18 +308,18 @@ public class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         when (element) {
             is KtParameter ->
                 return element.toPsiParameters().flatMap { psiParameter ->
-                    JetRefactoringUtil.checkParametersInMethodHierarchy(psiParameter) ?: emptyList()
+                    KotlinRefactoringUtil.checkParametersInMethodHierarchy(psiParameter) ?: emptyList()
                 }.ifEmpty { listOf(element) }
 
             is PsiParameter ->
-                return JetRefactoringUtil.checkParametersInMethodHierarchy(element)
+                return KotlinRefactoringUtil.checkParametersInMethodHierarchy(element)
         }
 
         if (ApplicationManager.getApplication()!!.isUnitTestMode()) return Collections.singletonList(element)
 
         return when (element) {
             is KtNamedFunction, is KtProperty ->
-                JetRefactoringUtil.checkSuperMethods(
+                KotlinRefactoringUtil.checkSuperMethods(
                         element as KtDeclaration, allElementsToDelete, "super.methods.delete.with.usage.search"
                 )
 

idea/tests/org/jetbrains/kotlin/idea/AbstractExpressionSelectionTest.java

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea;
 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.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -31,7 +31,7 @@ public abstract class AbstractExpressionSelectionTest extends LightCodeInsightTe
         final String expectedExpression = KotlinTestUtils.getLastCommentInFile((KtFile) getFile());
 
         try {
-            JetRefactoringUtil.selectExpression(getEditor(), getFile(), new JetRefactoringUtil.SelectExpressionCallback() {
+            KotlinRefactoringUtil.selectExpression(getEditor(), getFile(), new KotlinRefactoringUtil.SelectExpressionCallback() {
                 @Override
                 public void run(@Nullable KtExpression expression) {
                     assertNotNull("Selected expression mustn't be null", expression);
@@ -39,7 +39,7 @@ public abstract class AbstractExpressionSelectionTest extends LightCodeInsightTe
                 }
             });
         }
-        catch (JetRefactoringUtil.IntroduceRefactoringException e) {
+        catch (KotlinRefactoringUtil.IntroduceRefactoringException e) {
             assertEquals(expectedExpression, "");
         }
     }

idea/tests/org/jetbrains/kotlin/idea/AbstractSmartSelectionTest.java

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea;
 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.idea.refactoring.KotlinRefactoringUtil;
 import org.jetbrains.kotlin.psi.KtExpression;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -33,7 +33,7 @@ public abstract class AbstractSmartSelectionTest extends LightCodeInsightTestCas
         configureByFile(path);
         String expectedResultText = KotlinTestUtils.getLastCommentInFile((KtFile) getFile());
 
-        List<KtExpression> expressions = JetRefactoringUtil.getSmartSelectSuggestions(
+        List<KtExpression> expressions = KotlinRefactoringUtil.getSmartSelectSuggestions(
                 getFile(), getEditor().getCaretModel().getOffset());
 
         List<String> textualExpressions = new ArrayList<String>();

idea/tests/org/jetbrains/kotlin/idea/refactoring/changeSignature/KotlinChangeSignatureTest.kt

@@ -59,7 +59,7 @@ import org.jetbrains.kotlin.utils.sure
 import java.io.File
 import java.util.*
 
-class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
+class KotlinChangeSignatureTest : KotlinCodeInsightTestCase() {
     companion object {
         private val BUILT_INS = JvmPlatform.builtIns
         private val EXTENSIONS = arrayOf(".kt", ".java")
@@ -112,25 +112,25 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         setActiveEditor(editors!![0])
     }
 
-    private fun createChangeInfo(): JetChangeInfo {
+    private fun createChangeInfo(): KotlinChangeInfo {
         configureFiles()
 
-        val element = (JetChangeSignatureHandler().findTargetMember(file, editor) as KtElement?).sure { "Target element is null" }
+        val element = (KotlinChangeSignatureHandler().findTargetMember(file, editor) as KtElement?).sure { "Target element is null" }
         val context = file.findElementAt(editor.caretModel.offset).sure { "Context element is null" }
         val bindingContext = element.analyze(BodyResolveMode.FULL)
-        val callableDescriptor = JetChangeSignatureHandler
+        val callableDescriptor = KotlinChangeSignatureHandler
                 .findDescriptor(element, project, editor, bindingContext)
                 .sure { "Target descriptor is null" }
-        return createChangeInfo(project, callableDescriptor, JetChangeSignatureConfiguration.Empty, context)!!
+        return createChangeInfo(project, callableDescriptor, KotlinChangeSignatureConfiguration.Empty, context)!!
     }
 
-    private fun doTest(configure: JetChangeInfo.() -> Unit = {}) {
+    private fun doTest(configure: KotlinChangeInfo.() -> Unit = {}) {
-        JetChangeSignatureProcessor(project, createChangeInfo().apply { configure() }, "Change signature").run()
+        KotlinChangeSignatureProcessor(project, createChangeInfo().apply { configure() }, "Change signature").run()
 
         compareEditorsWithExpectedData()
     }
 
-    private fun doTestConflict(configure: JetChangeInfo.() -> Unit = {}) {
+    private fun doTestConflict(configure: KotlinChangeInfo.() -> Unit = {}) {
         try {
             doTest(configure)
             TestCase.fail("No conflicts found")
@@ -147,7 +147,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         }
     }
 
-    private fun doTestUnmodifiable(configure: JetChangeInfo.() -> Unit = {}) {
+    private fun doTestUnmodifiable(configure: KotlinChangeInfo.() -> Unit = {}) {
         try {
             doTest(configure)
             TestCase.fail("No conflicts found")
@@ -243,7 +243,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         }
     }
 
-    private fun JetChangeInfo.swapParameters(i: Int, j: Int) {
+    private fun KotlinChangeInfo.swapParameters(i: Int, j: Int) {
         val newParameters = newParameters
         val temp = newParameters[i]
         setNewParameter(i, newParameters[j])
@@ -254,7 +254,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testBadSelection() {
         configureByFile(getTestName(false) + "Before.kt")
-        TestCase.assertNull(JetChangeSignatureHandler().findTargetMember(file, editor))
+        TestCase.assertNull(KotlinChangeSignatureHandler().findTargetMember(file, editor))
     }
 
     fun testSynthesized() = doTestConflict()
@@ -274,12 +274,12 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
     fun testAddConstructorVisibility() = doTest {
         newVisibility = Visibilities.PROTECTED
 
-        val newParameter = JetParameterInfo(
+        val newParameter = KotlinParameterInfo(
                 callableDescriptor = originalBaseFunctionDescriptor,
                 name = "x",
                 type = BUILT_INS.anyType,
                 defaultValueForCall = KtPsiFactory(project).createExpression("12"),
-                valOrVar = JetValVar.Val
+                valOrVar = KotlinValVar.Val
         )
         addParameter(newParameter)
     }
@@ -287,9 +287,9 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
     fun testConstructor() = doTest {
         newVisibility = Visibilities.PUBLIC
 
-        newParameters[0].valOrVar = JetValVar.Var
+        newParameters[0].valOrVar = KotlinValVar.Var
-        newParameters[1].valOrVar = JetValVar.None
+        newParameters[1].valOrVar = KotlinValVar.None
-        newParameters[2].valOrVar = JetValVar.Val
+        newParameters[2].valOrVar = KotlinValVar.Val
 
         newParameters[0].name = "_x1"
         newParameters[1].name = "_x2"
@@ -301,9 +301,9 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
     fun testGenericConstructor() = doTest {
         newVisibility = Visibilities.PUBLIC
 
-        newParameters[0].valOrVar = JetValVar.Var
+        newParameters[0].valOrVar = KotlinValVar.Var
-        newParameters[1].valOrVar = JetValVar.None
+        newParameters[1].valOrVar = KotlinValVar.None
-        newParameters[2].valOrVar = JetValVar.Val
+        newParameters[2].valOrVar = KotlinValVar.Val
 
         newParameters[0].name = "_x1"
         newParameters[1].name = "_x2"
@@ -342,7 +342,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
     fun testExpressionFunction() = doTest {
         newParameters[0].name = "x1"
 
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "y1", BUILT_INS.intType))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "y1", BUILT_INS.intType))
     }
 
     fun testFunctionsAddRemoveArguments() = doTest {
@@ -352,16 +352,16 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         val newParameters = newParameters
         setNewParameter(2, newParameters[1])
         setNewParameter(1, newParameters[0])
-        setNewParameter(0, JetParameterInfo(originalBaseFunctionDescriptor, -1, "x0", BUILT_INS.nullableAnyType, null, defaultValueForCall))
+        setNewParameter(0, KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "x0", BUILT_INS.nullableAnyType, null, defaultValueForCall))
     }
 
     fun testFakeOverride() = doTest {
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "i", BUILT_INS.intType))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "i", BUILT_INS.intType))
     }
 
     fun testFunctionLiteral() = doTest {
         newParameters[1].name = "y1"
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "x", BUILT_INS.anyType))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "x", BUILT_INS.anyType))
 
         newReturnTypeText = "Int"
     }
@@ -393,12 +393,12 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
     fun testNoDefaultValuesInOverrides() = doTest { swapParameters(0, 1) }
 
     fun testOverridesInEnumEntries() = doTest {
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType))
     }
 
     fun testEnumEntriesWithoutSuperCalls() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
     }
 
     fun testParameterChangeInOverrides() = doTest {
@@ -408,15 +408,15 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testConstructorJavaUsages() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"abc\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testFunctionJavaUsagesAndOverridesAddParam() = doTest {
         val psiFactory = KtPsiFactory(project)
         val defaultValueForCall1 = psiFactory.createExpression("\"abc\"")
         val defaultValueForCall2 = psiFactory.createExpression("\"def\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall1))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall1))
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "o", BUILT_INS.nullableAnyType, null, defaultValueForCall2))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "o", BUILT_INS.nullableAnyType, null, defaultValueForCall2))
     }
 
     fun testFunctionJavaUsagesAndOverridesChangeNullability() = doTest {
@@ -482,10 +482,10 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testFunctionRenameJavaUsages() = doTest { newName = "bar" }
 
-    fun testParameterModifiers() = doTest { addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType)) }
+    fun testParameterModifiers() = doTest { addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType)) }
 
     fun testFqNameShortening() = doTest {
-        val newParameter = JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.anyType).apply {
+        val newParameter = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.anyType).apply {
             currentTypeText = "kotlin.String"
         }
         addParameter(newParameter)
@@ -493,7 +493,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testObjectMember() = doTest { removeParameter(0) }
 
-    fun testParameterListAddParam() = doTest { addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "l", BUILT_INS.longType)) }
+    fun testParameterListAddParam() = doTest { addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "l", BUILT_INS.longType)) }
 
     fun testParameterListRemoveParam() = doTest { removeParameter(getNewParametersCount() - 1) }
 
@@ -501,25 +501,25 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testAddNewReceiver() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
                 .apply { currentTypeText = "X" }
     }
 
     fun testAddNewReceiverForMember() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
                 .apply { currentTypeText = "X" }
     }
 
     fun testAddNewReceiverForMemberConflict() = doTestConflict {
         val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
                 .apply { currentTypeText = "X" }
     }
 
     fun testAddNewReceiverConflict() = doTestConflict {
         val defaultValueForCall = KtPsiFactory(project).createExpression("X(0)")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "_", BUILT_INS.anyType, null, defaultValueForCall)
                 .apply { currentTypeText = "X" }
     }
 
@@ -572,36 +572,36 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testSecondaryConstructor() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testJavaConstructorInDelegationCall() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) }
 
     fun testPrimaryConstructorByThisRef() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testPrimaryConstructorBySuperRef() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testSecondaryConstructorByThisRef() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testSecondaryConstructorBySuperRef() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"foo\"")
-        addParameter(JetParameterInfo(methodDescriptor.baseDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(methodDescriptor.baseDescriptor, -1, "s", BUILT_INS.stringType, null, defaultValueForCall))
     }
 
     fun testJavaConstructorBySuperRef() = doJavaTest { newParameters.add(ParameterInfoImpl(-1, "s", stringPsiType, "\"foo\"")) }
 
     fun testNoConflictWithReceiverName() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("0")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "i", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "i", BUILT_INS.intType, null, defaultValueForCall))
     }
 
     fun testRemoveParameterBeforeLambda() = doTest { removeParameter(1) }
@@ -639,7 +639,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testPrimaryConstructorByRef() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
     }
 
     fun testReceiverToParameterExplicitReceiver() = doTest { receiverParameterInfo = null }
@@ -669,12 +669,12 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testAddPropertyReceiverConflict() = doTestConflict {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", BUILT_INS.stringType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", BUILT_INS.stringType, null, defaultValueForCall)
     }
 
     fun testAddPropertyReceiver() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("\"\"")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", BUILT_INS.stringType, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", BUILT_INS.stringType, null, defaultValueForCall)
     }
 
     fun testChangePropertyReceiver() = doTest { receiverParameterInfo!!.currentTypeText = "Int" }
@@ -683,7 +683,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testAddTopLevelPropertyReceiver() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("A()")
-        receiverParameterInfo = JetParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", null, null, defaultValueForCall)
+        receiverParameterInfo = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "receiver", null, null, defaultValueForCall)
                 .apply { currentTypeText = "test.A" }
     }
 
@@ -700,12 +700,12 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         val psiFactory = KtPsiFactory(project)
 
         val defaultValueForCall1 = psiFactory.createExpression("1")
-        val newParameter1 = JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", null, null, defaultValueForCall1)
+        val newParameter1 = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", null, null, defaultValueForCall1)
                 .apply { currentTypeText = "kotlin.Int" }
         addParameter(newParameter1)
 
         val defaultValueForCall2 = psiFactory.createExpression("\"abc\"")
-        val newParameter2 = JetParameterInfo(originalBaseFunctionDescriptor, -1, "s", null, null, defaultValueForCall2)
+        val newParameter2 = KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "s", null, null, defaultValueForCall2)
                 .apply { currentTypeText = "kotlin.String" }
         addParameter(newParameter2)
 
@@ -730,21 +730,21 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testPropagateWithParameterDuplication() = doTestConflict {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first())
     }
 
     fun testPropagateWithVariableDuplication() = doTestConflict {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first())
     }
 
     fun testPropagateWithThisQualificationInClassMember() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         val classA = KotlinFullClassNameIndex.getInstance().get("A", project, project.allScope()).first()
         val functionBar = classA.declarations.first { it is KtNamedFunction && it.name == "bar" }
@@ -753,7 +753,7 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testPropagateWithThisQualificationInExtension() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         primaryPropagationTargets = listOf(KotlinTopLevelFunctionFqnNameIndex.getInstance().get("bar", project, project.allScope()).first())
     }
@@ -765,14 +765,14 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     fun testPrimaryConstructorParameterPropagation() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!)
     }
 
     fun testSecondaryConstructorParameterPropagation() = doTest {
         val defaultValueForCall = KtPsiFactory(project).createExpression("1")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValueForCall))
 
         primaryPropagationTargets = findCallers(method.getRepresentativeLightMethod()!!)
     }
@@ -800,12 +800,12 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
 
     private fun doTestJvmOverloadedAddDefault(index: Int) = doTest {
         val defaultValue = KtPsiFactory(project).createExpression("2")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, defaultValue, defaultValue), index)
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, defaultValue, defaultValue), index)
     }
 
     private fun doTestJvmOverloadedAddNonDefault(index: Int) = doTest {
         val defaultValue = KtPsiFactory(project).createExpression("2")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValue), index)
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "n", BUILT_INS.intType, null, defaultValue), index)
     }
 
     fun testJvmOverloadedAddDefault1() = doTestJvmOverloadedAddDefault(0)
@@ -842,8 +842,8 @@ class JetChangeSignatureTest : KotlinCodeInsightTestCase() {
         val psiFactory = KtPsiFactory(project)
         val defaultValue1 = psiFactory.createExpression("4")
         val defaultValue2 = psiFactory.createExpression("5")
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "d", BUILT_INS.intType, null, defaultValue1), 2)
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "d", BUILT_INS.intType, null, defaultValue1), 2)
-        addParameter(JetParameterInfo(originalBaseFunctionDescriptor, -1, "e", BUILT_INS.intType, null, defaultValue2))
+        addParameter(KotlinParameterInfo(originalBaseFunctionDescriptor, -1, "e", BUILT_INS.intType, null, defaultValue2))
     }
 
     fun testRemoveParameterKeepFormat1() = doTest { removeParameter(0) }

idea/tests/org/jetbrains/kotlin/idea/refactoring/introduce/AbstractExtractionTest.kt

@@ -35,7 +35,7 @@ import com.intellij.refactoring.introduceParameter.Util
 import com.intellij.refactoring.util.occurrences.ExpressionOccurrenceManager
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtil
+import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.EXTRACT_FUNCTION
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ExtractKotlinFunctionHandler
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -108,7 +108,7 @@ public abstract class AbstractExtractionTest() : KotlinLightCodeInsightFixtureTe
             with (handler) {
                 val target = (file as KtFile).findElementByCommentPrefix("// TARGET:") as? KtNamedDeclaration
                 if (target != null) {
-                    JetRefactoringUtil.selectExpression(fixture.getEditor(), file, true) { expression ->
+                    KotlinRefactoringUtil.selectExpression(fixture.getEditor(), file, true) { expression ->
                         invoke(fixture.getProject(), fixture.getEditor(), expression!!, target)
                     }
                 }

idea/tests/org/jetbrains/kotlin/idea/refactoring/move/AbstractMoveTest.kt

@@ -42,8 +42,8 @@ import org.jetbrains.kotlin.idea.core.refactoring.toPsiDirectory
 import org.jetbrains.kotlin.idea.jsonUtils.getNullableString
 import org.jetbrains.kotlin.idea.jsonUtils.getString
 import org.jetbrains.kotlin.idea.refactoring.move.changePackage.KotlinChangePackageRefactoring
-import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.DeferredJetFileKotlinMoveTarget
+import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.KotlinMoveTargetForDeferredFile
-import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.JetFileKotlinMoveTarget
+import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.KotlinMoveTargetForExistingFile
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsOptions
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsProcessor
 import org.jetbrains.kotlin.idea.search.allScope
@@ -249,12 +249,12 @@ enum class MoveAction {
             val elementToMove = elementAtCaret!!.getNonStrictParentOfType<KtNamedDeclaration>()!!
 
             val moveTarget = config.getNullableString("targetPackage")?.let { packageName ->
-                DeferredJetFileKotlinMoveTarget(project, FqName(packageName)) {
+                KotlinMoveTargetForDeferredFile(project, FqName(packageName)) {
                     val moveDestination = MultipleRootsMoveDestination(PackageWrapper(mainFile.getManager(), packageName))
                     createKotlinFile(guessNewFileName(listOf(elementToMove))!!, moveDestination.getTargetDirectory(mainFile))
                 }
             } ?: config.getString("targetFile").let { filePath ->
-                JetFileKotlinMoveTarget(PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(filePath)!!) as KtFile)
+                KotlinMoveTargetForExistingFile(PsiManager.getInstance(project).findFile(rootDir.findFileByRelativePath(filePath)!!) as KtFile)
             }
 
             val options = MoveKotlinTopLevelDeclarationsOptions(listOf(elementToMove), moveTarget)

idea/tests/org/jetbrains/kotlin/idea/refactoring/nameSuggester/KotlinNameSuggesterTest.kt

@@ -20,7 +20,7 @@ import com.intellij.openapi.util.text.StringUtil
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 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.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
@@ -66,7 +66,7 @@ public class KotlinNameSuggesterTest : LightCodeInsightFixtureTestCase() {
         val file = myFixture.getFile() as KtFile
         val expectedResultText = KotlinTestUtils.getLastCommentInFile(file)
         try {
-            JetRefactoringUtil.selectExpression(myFixture.getEditor(), file, object : JetRefactoringUtil.SelectExpressionCallback {
+            KotlinRefactoringUtil.selectExpression(myFixture.getEditor(), file, object : KotlinRefactoringUtil.SelectExpressionCallback {
                 override fun run(expression: KtExpression?) {
                     val names = KotlinNameSuggester.suggestNamesByExpressionAndType(expression!!, expression.analyze(BodyResolveMode.PARTIAL), { true }, "value").sorted()
                     val result = StringUtil.join(names, "\n").trim()
@@ -74,7 +74,7 @@ public class KotlinNameSuggesterTest : LightCodeInsightFixtureTestCase() {
                 }
             })
         }
-        catch (e: JetRefactoringUtil.IntroduceRefactoringException) {
+        catch (e: KotlinRefactoringUtil.IntroduceRefactoringException) {
             throw AssertionError("Failed to find expression: " + e.getMessage())
         }
     }