Misc: Cleanup "org.jetbrains.kotlin.idea.refactoring" package

idea/src/META-INF/plugin.xml

@@ -100,7 +100,7 @@
       <add-to-group group-id="IntroduceActionsGroup" anchor="after" relative-to-action="ExtractMethod"/>
     </action>
 
-    <action id="IntroduceProperty" class="org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.IntroducePropertyAction"
+    <action id="IntroduceProperty" class="org.jetbrains.kotlin.idea.refactoring.introduce.introduceProperty.IntroducePropertyAction"
             text="P_roperty..." use-shortcut-of="IntroduceField">
       <add-to-group group-id="IntroduceActionsGroup" anchor="after" relative-to-action="IntroduceField"/>
     </action>

idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt

@@ -32,7 +32,7 @@ import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.openapi.vfs.VirtualFileVisitor
 import com.intellij.psi.PsiJavaFile
 import com.intellij.psi.PsiManager
-import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
+import org.jetbrains.kotlin.idea.refactoring.toPsiFile
 import org.jetbrains.kotlin.idea.j2k.IdeaJavaToKotlinServices
 import org.jetbrains.kotlin.idea.j2k.J2kPostProcessor
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand

idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateActionBase.kt

@@ -24,7 +24,7 @@ import com.intellij.openapi.actionSystem.Presentation
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiFile
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType

idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateEqualsAndHashcodeAction.kt

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.overrideImplement.OverrideMemberChooserObject
 import org.jetbrains.kotlin.idea.core.overrideImplement.generateMember
-import org.jetbrains.kotlin.idea.core.refactoring.quoteIfNeeded
+import org.jetbrains.kotlin.idea.refactoring.quoteIfNeeded
 import org.jetbrains.kotlin.idea.quickfix.insertMembersAfter
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.runWriteAction

idea/src/org/jetbrains/kotlin/idea/actions/generate/KotlinGenerateTestSupportActionBase.kt

@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.overrideImplement.OverrideMemberChooserObject.BodyType
 import org.jetbrains.kotlin.idea.core.overrideImplement.generateUnsupportedOrSuperCall
-import org.jetbrains.kotlin.idea.core.refactoring.j2k
+import org.jetbrains.kotlin.idea.refactoring.j2k
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.setupEditorSelection
 import org.jetbrains.kotlin.idea.quickfix.insertMember
 import org.jetbrains.kotlin.idea.testIntegration.findSuitableFrameworks

idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/AbstractKotlinUpDownMover.java

@@ -28,7 +28,7 @@ import com.intellij.psi.PsiFile;
 import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
+import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.psi.KtBlockExpression;
 import org.jetbrains.kotlin.psi.KtFile;
 import org.jetbrains.kotlin.psi.KtFunctionLiteral;

idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/KotlinExpressionMover.java

@@ -27,7 +27,7 @@ import com.intellij.psi.util.PsiTreeUtil;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
+import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.psi.psiUtil.PsiUtilsKt;

idea/src/org/jetbrains/kotlin/idea/debugger/KotlinFrameExtraVariablesProvider.kt

@@ -34,8 +34,8 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.getLineEndOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineEndOffset
-import org.jetbrains.kotlin.idea.core.refactoring.getLineStartOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineStartOffset
 import org.jetbrains.kotlin.idea.util.application.runReadAction
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext

idea/src/org/jetbrains/kotlin/idea/debugger/KotlinPositionManager.kt

@@ -53,7 +53,7 @@ import org.jetbrains.kotlin.fileClasses.internalNameWithoutInnerClasses
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeAndGetResult
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.getLineStartOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineStartOffset
 import org.jetbrains.kotlin.idea.debugger.breakpoints.getLambdasAtLineIfAny
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinCodeFragmentFactory
 import org.jetbrains.kotlin.idea.decompiler.classFile.KtClsFile

idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/breakpointTypeUtils.kt

@@ -31,9 +31,9 @@ import com.intellij.xdebugger.XSourcePosition
 import com.intellij.xdebugger.impl.XSourcePositionImpl
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.getLineEndOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineEndOffset
-import org.jetbrains.kotlin.idea.core.refactoring.getLineNumber
+import org.jetbrains.kotlin.idea.refactoring.getLineNumber
-import org.jetbrains.kotlin.idea.core.refactoring.getLineStartOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineStartOffset
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset
 import org.jetbrains.kotlin.psi.psiUtil.startOffset

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt

@@ -40,8 +40,8 @@ import org.jetbrains.eval4j.jdi.asValue
 import org.jetbrains.kotlin.asJava.KtLightClass
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.j2kText
+import org.jetbrains.kotlin.idea.refactoring.j2kText
-import org.jetbrains.kotlin.idea.core.refactoring.quoteIfNeeded
+import org.jetbrains.kotlin.idea.refactoring.quoteIfNeeded
 import org.jetbrains.kotlin.idea.debugger.KotlinEditorTextProvider
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.name.Name

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -56,7 +56,7 @@ import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheService
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaClassDescriptor
-import org.jetbrains.kotlin.idea.core.refactoring.quoteIfNeeded
+import org.jetbrains.kotlin.idea.refactoring.quoteIfNeeded
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinEvaluateExpressionCache.CompiledDataDescriptor
 import org.jetbrains.kotlin.idea.debugger.evaluate.KotlinEvaluateExpressionCache.ParametersDescriptor
 import org.jetbrains.kotlin.idea.debugger.evaluate.compilingEvaluator.loadClasses

idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinLambdaMethodFilter.kt

@@ -21,7 +21,7 @@ import com.intellij.debugger.engine.BreakpointStepMethodFilter
 import com.intellij.debugger.engine.DebugProcessImpl
 import com.intellij.util.Range
 import com.sun.jdi.Location
-import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine
+import org.jetbrains.kotlin.idea.refactoring.isMultiLine
 import org.jetbrains.kotlin.idea.debugger.isInsideInlineArgument
 import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtFunction

idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt

@@ -32,9 +32,9 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.getLineEndOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineEndOffset
-import org.jetbrains.kotlin.idea.core.refactoring.getLineNumber
+import org.jetbrains.kotlin.idea.refactoring.getLineNumber
-import org.jetbrains.kotlin.idea.core.refactoring.getLineStartOffset
+import org.jetbrains.kotlin.idea.refactoring.getLineStartOffset
 import org.jetbrains.kotlin.idea.util.DebuggerUtils
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.endOffset

idea/src/org/jetbrains/kotlin/idea/filters/KotlinExceptionFilter.kt

@@ -28,8 +28,8 @@ import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.codegen.inline.FileMapping
 import org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil
 import org.jetbrains.kotlin.codegen.inline.SMAPParser
-import org.jetbrains.kotlin.idea.core.refactoring.getLineCount
+import org.jetbrains.kotlin.idea.refactoring.getLineCount
-import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
+import org.jetbrains.kotlin.idea.refactoring.toPsiFile
 import org.jetbrains.kotlin.idea.util.DebuggerUtils
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.load.kotlin.JvmVirtualFileFinder

idea/src/org/jetbrains/kotlin/idea/inspections/InfixCallFix.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.DiagnosticWithParameters2
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.intentions.InfixCallToOrdinaryIntention
 import org.jetbrains.kotlin.idea.quickfix.CleanupFix
 import org.jetbrains.kotlin.idea.quickfix.KotlinQuickFixAction

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

@@ -31,8 +31,8 @@ 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.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
+import org.jetbrains.kotlin.idea.refactoring.checkConflictsInteractively
-import org.jetbrains.kotlin.idea.core.refactoring.reportDeclarationConflict
+import org.jetbrains.kotlin.idea.refactoring.reportDeclarationConflict
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
 import org.jetbrains.kotlin.idea.refactoring.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.getContainingScope

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

@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.asJava.namedUnwrappedElement
 import org.jetbrains.kotlin.descriptors.CallableDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
+import org.jetbrains.kotlin.idea.refactoring.checkConflictsInteractively
-import org.jetbrains.kotlin.idea.core.refactoring.reportDeclarationConflict
+import org.jetbrains.kotlin.idea.refactoring.reportDeclarationConflict
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
 import org.jetbrains.kotlin.idea.refactoring.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.getContainingScope

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.lexer.KtTokens.ABSTRACT_KEYWORD

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

@@ -31,7 +31,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 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.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeSignatureConfiguration
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.modify

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.appendElement
 import org.jetbrains.kotlin.idea.core.getOrCreateBody
-import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
+import org.jetbrains.kotlin.idea.refactoring.runRefactoringWithPostprocessing
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.util.application.runWriteAction
 import org.jetbrains.kotlin.psi.*

idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java

@@ -29,7 +29,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.idea.KotlinBundle;
 import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil;
-import org.jetbrains.kotlin.idea.core.refactoring.JetRefactoringUtilKt;
+import org.jetbrains.kotlin.idea.refactoring.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.idea.references.ReferenceUtilKt;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;

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

@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*
 import org.jetbrains.kotlin.descriptors.isOverridable
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.lexer.KtTokens.OPEN_KEYWORD
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.psi.KtDeclaration

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

@@ -30,7 +30,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.isVisible
-import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorParameterListIfAbsent
+import org.jetbrains.kotlin.idea.refactoring.createPrimaryConstructorParameterListIfAbsent
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences

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

@@ -47,8 +47,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.getJavaClassDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
 import org.jetbrains.kotlin.idea.core.CollectingNameValidator
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
-import org.jetbrains.kotlin.idea.core.refactoring.*
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind
+import org.jetbrains.kotlin.idea.refactoring.*
 import org.jetbrains.kotlin.idea.util.DialogWithEditor
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.ShortenReferences

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt

@@ -25,8 +25,8 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
-import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
+import org.jetbrains.kotlin.idea.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt

@@ -25,8 +25,8 @@ import com.intellij.psi.PsiFile
 import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
-import org.jetbrains.kotlin.idea.core.refactoring.chooseContainerElementIfNecessary
+import org.jetbrains.kotlin.idea.refactoring.chooseContainerElementIfNecessary
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.SecondaryConstructorInfo

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromSuperTypeCallActionFactory.kt

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.ParameterInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.SecondaryConstructorInfo

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateFunctionFromCallableReferenceActionFactory.kt

@@ -20,8 +20,8 @@ import com.intellij.util.SmartList
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
+import org.jetbrains.kotlin.idea.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.psi.KtCallableReferenceExpression
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFix.kt

@@ -27,8 +27,8 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiPackage
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
-import org.jetbrains.kotlin.idea.core.refactoring.getOrCreateKotlinFile
+import org.jetbrains.kotlin.idea.refactoring.getOrCreateKotlinFile
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.*
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.createClass.ClassKind.*

idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/createClassUtils.kt

@@ -25,7 +25,7 @@ import com.intellij.psi.PsiPackage
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.DelegatingIntentionAction
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.TypeInfo
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.containsStarProjections

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

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFullyAndGetResult
 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.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.guessTypes
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinTypeInfo

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.CreateFromUsageFixBase
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallableBuilderConfiguration
 import org.jetbrains.kotlin.idea.quickfix.createFromUsage.callableBuilder.CallablePlacement

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

@@ -27,7 +27,7 @@ import com.intellij.refactoring.RefactoringActionHandler
 import com.intellij.refactoring.RefactoringBundle
 import com.intellij.refactoring.lang.ElementsHandler
 import com.intellij.refactoring.util.CommonRefactoringUtil
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.psi.psiUtil.parentsWithSelf
@@ -98,6 +98,6 @@ public abstract class AbstractPullPushMembersHandler(
                 is KtClassOrObject -> it
                 else -> null
             } ?: return false
-        }.size() == 1
+        }.size == 1
     }
 }

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

@@ -33,7 +33,7 @@ import org.jetbrains.kotlin.idea.KotlinBundle
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.refactoring.canRefactor
 import org.jetbrains.kotlin.idea.util.getResolutionScope
 import org.jetbrains.kotlin.psi.KtBlockExpression
 import org.jetbrains.kotlin.psi.KtDeclarationWithBody
@@ -50,9 +50,9 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
         val project: Project,
         val callableDescriptor: T,
         val commandName: String) {
-    private val LOG = Logger.getInstance(javaClass<CallableRefactoring<*>>())
+    private val LOG = Logger.getInstance(CallableRefactoring::class.java)
 
-    private val kind = (callableDescriptor as? CallableMemberDescriptor)?.getKind() ?: CallableMemberDescriptor.Kind.DECLARATION
+    private val kind = (callableDescriptor as? CallableMemberDescriptor)?.kind ?: CallableMemberDescriptor.Kind.DECLARATION
 
     protected open fun forcePerformForSelectedFunctionOnly(): Boolean {
         return false
@@ -67,7 +67,7 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
                 OverrideResolver.getDirectlyOverriddenDeclarations(callableDescriptor as CallableMemberDescriptor)
             }
             else -> {
-                throw IllegalStateException("Unexpected callable kind: ${kind}")
+                throw IllegalStateException("Unexpected callable kind: $kind")
             }
         }
     }
@@ -76,11 +76,11 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
                                                callableFromEditor: CallableDescriptor,
                                                options: List<String>): Int {
         val superString = superCallables.map {
-            it.getContainingDeclaration().getName().asString()
+            it.containingDeclaration.name.asString()
         }.joinToString(prefix = "\n    ", separator = ",\n    ", postfix = ".\n\n")
         val message = KotlinBundle.message("x.overrides.y.in.class.list",
                                            DescriptorRenderer.COMPACT.render(callableFromEditor),
-                                           callableFromEditor.getContainingDeclaration().getName().asString(), superString,
+                                           callableFromEditor.containingDeclaration.name.asString(), superString,
                                            "refactor")
         val title = IdeBundle.message("title.warning")!!
         val icon = Messages.getQuestionIcon()
@@ -92,14 +92,14 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
             return true
         }
 
-        val unmodifiableFile = element.getContainingFile()?.getVirtualFile()?.getPresentableUrl()
+        val unmodifiableFile = element.containingFile?.virtualFile?.presentableUrl
         if (unmodifiableFile != null) {
             val message = RefactoringBundle.message("refactoring.cannot.be.performed") + "\n" +
                           IdeBundle.message("error.message.cannot.modify.file.0", unmodifiableFile)
             Messages.showErrorDialog(project, message, CommonBundle.getErrorTitle()!!)
         }
         else {
-            LOG.error("Could not find file for Psi element: " + element.getText())
+            LOG.error("Could not find file for Psi element: " + element.text)
         }
 
         return false
@@ -144,17 +144,17 @@ public abstract class CallableRefactoring<T: CallableDescriptor>(
         val deepestSuperDeclarations =
                 (callableDescriptor as? CallableMemberDescriptor)?.let { OverrideResolver.getDeepestSuperDeclarations(it) }
                 ?: Collections.singletonList(callableDescriptor)
-        if (ApplicationManager.getApplication()!!.isUnitTestMode()) {
+        if (ApplicationManager.getApplication()!!.isUnitTestMode) {
             performRefactoring(deepestSuperDeclarations)
             return true
         }
 
-        if (closestModifiableDescriptors.size() == 1 && deepestSuperDeclarations.subtract(closestModifiableDescriptors).isEmpty()) {
+        if (closestModifiableDescriptors.size == 1 && deepestSuperDeclarations.subtract(closestModifiableDescriptors).isEmpty()) {
             performRefactoring(closestModifiableDescriptors)
             return true
         }
 
-        val isSingleFunctionSelected = closestModifiableDescriptors.size() == 1
+        val isSingleFunctionSelected = closestModifiableDescriptors.size == 1
         val selectedFunction = if (isSingleFunctionSelected) closestModifiableDescriptors.first() else callableDescriptor
         val optionsForDialog = buildDialogOptions(isSingleFunctionSelected)
         val code = showSuperFunctionWarningDialog(deepestSuperDeclarations, selectedFunction, optionsForDialog)
@@ -184,16 +184,16 @@ fun getAffectedCallables(project: Project, descriptorsForChange: Collection<Call
 
 fun DeclarationDescriptor.getContainingScope(): LexicalScope? {
     val declaration = DescriptorToSourceUtils.descriptorToDeclaration(this)
-    val block = declaration?.getParent() as? KtBlockExpression
+    val block = declaration?.parent as? KtBlockExpression
     if (block != null) {
         val lastStatement = block.statements.last()
         val bindingContext = lastStatement.analyze()
         return lastStatement.getResolutionScope(bindingContext, lastStatement.getResolutionFacade())
     }
     else {
-        val containingDescriptor = getContainingDeclaration() ?: return null
+        val containingDescriptor = containingDeclaration ?: return null
         return when (containingDescriptor) {
-            is ClassDescriptorWithResolutionScopes -> containingDescriptor.getScopeForInitializerResolution()
+            is ClassDescriptorWithResolutionScopes -> containingDescriptor.scopeForInitializerResolution
             is PackageFragmentDescriptor -> LexicalScope.empty(containingDescriptor.getMemberScope().memberScopeAsImportingScope(), this)
             else -> null
         }
@@ -201,6 +201,6 @@ fun DeclarationDescriptor.getContainingScope(): LexicalScope? {
 }
 
 fun KtDeclarationWithBody.getBodyScope(bindingContext: BindingContext): LexicalScope? {
-    val expression = getBodyExpression()?.getChildren()?.firstOrNull { it is KtExpression } ?: return null
+    val expression = bodyExpression?.children?.firstOrNull { it is KtExpression } ?: return null
     return expression.getResolutionScope(bindingContext, getResolutionFacade())
 }

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

@@ -23,7 +23,7 @@ import org.jetbrains.kotlin.lexer.KtKeywordToken
 import org.jetbrains.kotlin.lexer.KtTokens
 
 public class KotlinNamesValidator : NamesValidator {
-    private val KEYWORD_SET = KtTokens.KEYWORDS.getTypes().filterIsInstance<KtKeywordToken>().map { it.getValue() }.toSet()
+    private val KEYWORD_SET = KtTokens.KEYWORDS.types.filterIsInstance<KtKeywordToken>().map { it.value }.toSet()
 
     override fun isKeyword(name: String, project: Project?): Boolean = name in KEYWORD_SET
     override fun isIdentifier(name: String, project: Project?): Boolean = KotlinNameSuggester.isIdentifier(name)

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

@@ -52,19 +52,19 @@ public class KotlinRefactoringSupportProvider : RefactoringSupportProvider() {
     override fun isInplaceRenameAvailable(element: PsiElement, context: PsiElement?): Boolean {
         when (element) {
             is KtProperty -> {
-                if (element.isLocal()) return true
+                if (element.isLocal) return true
             }
             is KtDestructuringDeclarationEntry -> return true
             is KtFunction -> {
-                if (element.isLocal() && element.nameIdentifier != null) return true
+                if (element.isLocal && element.nameIdentifier != null) return true
             }
             is KtParameter -> {
-                val parent = element.getParent()
+                val parent = element.parent
                 if (parent is KtForExpression) {
                     return true
                 }
                 if (parent is KtParameterList) {
-                    val grandparent = parent.getParent()
+                    val grandparent = parent.parent
                     return grandparent is KtCatchClause || grandparent is KtFunctionLiteral
                 }
             }

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

@@ -25,4 +25,4 @@ public class KotlinAwareJavaParameterInfoImpl(
         name: String,
         type: PsiType,
         val kotlinDefaultValue: KtExpression?
-): ParameterInfoImpl(oldParameterIndex, name, type, kotlinDefaultValue?.getText() ?: "")
+): ParameterInfoImpl(oldParameterIndex, name, type, kotlinDefaultValue?.text ?: "")

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

@@ -36,7 +36,7 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 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.refactoring.j2k
 import org.jetbrains.kotlin.idea.project.ProjectStructureUtil
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor.Kind
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
@@ -55,10 +55,10 @@ import java.util.*
 
 public open class KotlinChangeInfo(
         val methodDescriptor: KotlinMethodDescriptor,
-        private var name: String = methodDescriptor.getName(),
+        private var name: String = methodDescriptor.name,
         var newReturnTypeInfo: KotlinTypeInfo = KotlinTypeInfo(true, methodDescriptor.baseDescriptor.returnType),
-        var newVisibility: Visibility = methodDescriptor.getVisibility(),
+        var newVisibility: Visibility = methodDescriptor.visibility,
-        parameterInfos: List<KotlinParameterInfo> = methodDescriptor.getParameters(),
+        parameterInfos: List<KotlinParameterInfo> = methodDescriptor.parameters,
         receiver: KotlinParameterInfo? = methodDescriptor.receiver,
         val context: PsiElement,
         primaryPropagationTargets: Collection<PsiElement> = emptyList()
@@ -93,8 +93,8 @@ public open class KotlinChangeInfo(
     private val oldNameToParameterIndex: Map<String, Int> by lazy {
         val map = HashMap<String, Int>()
 
-        val parameters = methodDescriptor.baseDescriptor.getValueParameters()
+        val parameters = methodDescriptor.baseDescriptor.valueParameters
-        parameters.indices.forEach { i -> map[parameters.get(i).getName().asString()] = i }
+        parameters.indices.forEach { i -> map[parameters[i].name.asString()] = i }
 
         map
     }
@@ -102,8 +102,8 @@ public open class KotlinChangeInfo(
     private val isParameterSetOrOrderChangedLazy: Boolean by lazy {
         val signatureParameters = getNonReceiverParameters()
         methodDescriptor.receiver != receiverParameterInfo ||
-        signatureParameters.size() != methodDescriptor.getParametersCount() ||
+        signatureParameters.size != methodDescriptor.parametersCount ||
-        signatureParameters.indices.any { i -> signatureParameters[i].getOldIndex() != i }
+        signatureParameters.indices.any { i -> signatureParameters[i].oldIndex != i }
     }
 
     private var isPrimaryMethodUpdated: Boolean = false
@@ -119,21 +119,11 @@ public open class KotlinChangeInfo(
 
     override fun isParameterSetOrOrderChanged(): Boolean = isParameterSetOrOrderChangedLazy
 
-    public fun getNewParametersCount(): Int = newParameters.size()
+    public fun getNewParametersCount(): Int = newParameters.size
 
     override fun getNewParameters(): Array<KotlinParameterInfo> = newParameters.toTypedArray()
 
-    fun getToBeRemoved(): BooleanArray {
+    fun getNonReceiverParametersCount(): Int = newParameters.size - (if (receiverParameterInfo != null) 1 else 0)
-        return BooleanArray(originalParameters.size).apply {
-            Arrays.fill(this, true)
-            for (newParameter in newParameters) {
-                if (newParameter.oldIndex < 0) continue
-                this[newParameter.oldIndex] = false
-            }
-        }
-    }
-
-    fun getNonReceiverParametersCount(): Int = newParameters.size() - (if (receiverParameterInfo != null) 1 else 0)
 
     fun getNonReceiverParameters(): List<KotlinParameterInfo> {
         methodDescriptor.baseDeclaration.let { if (it is KtProperty || it is KtParameter) return emptyList() }
@@ -141,7 +131,7 @@ public open class KotlinChangeInfo(
     }
 
     public fun setNewParameter(index: Int, parameterInfo: KotlinParameterInfo) {
-        newParameters.set(index, parameterInfo)
+        newParameters[index] = parameterInfo
     }
 
     @JvmOverloads
@@ -155,7 +145,7 @@ public open class KotlinChangeInfo(
     }
 
     public fun removeParameter(index: Int) {
-        val parameterInfo = newParameters.remove(index);
+        val parameterInfo = newParameters.removeAt(index);
         if (parameterInfo == receiverParameterInfo) {
             receiverParameterInfo = null
         }
@@ -177,12 +167,12 @@ public open class KotlinChangeInfo(
         name = value
     }
 
-    override fun isNameChanged(): Boolean = name != methodDescriptor.getName()
+    override fun isNameChanged(): Boolean = name != methodDescriptor.name
 
-    public fun isVisibilityChanged(): Boolean = newVisibility != methodDescriptor.getVisibility()
+    public fun isVisibilityChanged(): Boolean = newVisibility != methodDescriptor.visibility
 
     override fun getMethod(): PsiElement {
-        return methodDescriptor.getMethod()
+        return methodDescriptor.method
     }
 
     override fun isReturnTypeChanged(): Boolean = !newReturnTypeInfo.isEquivalentTo(originalReturnTypeInfo)
@@ -281,7 +271,7 @@ public open class KotlinChangeInfo(
 
     public fun isRefactoringTarget(inheritedCallableDescriptor: CallableDescriptor?): Boolean {
         return inheritedCallableDescriptor != null
-               && getMethod() == DescriptorToSourceUtils.descriptorToDeclaration(inheritedCallableDescriptor)
+               && method == DescriptorToSourceUtils.descriptorToDeclaration(inheritedCallableDescriptor)
     }
 
     public fun getNewParametersSignature(inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
@@ -294,8 +284,8 @@ public open class KotlinChangeInfo(
         val signatureParameters = getNonReceiverParameters()
 
         val isLambda = inheritedCallable.declaration is KtFunctionLiteral
-        if (isLambda && signatureParameters.size() == 1 && !signatureParameters.get(0).requiresExplicitType(inheritedCallable)) {
+        if (isLambda && signatureParameters.size == 1 && !signatureParameters[0].requiresExplicitType(inheritedCallable)) {
-            return signatureParameters.get(0).getDeclarationSignature(0, inheritedCallable)
+            return signatureParameters[0].getDeclarationSignature(0, inheritedCallable)
         }
 
         return signatureParameters.indices
@@ -391,14 +381,14 @@ public open class KotlinChangeInfo(
                                  newParameters: Array<ParameterInfoImpl>
         ): JavaChangeInfo? {
             val newVisibility = if (isPrimaryMethodUpdated)
-                VisibilityUtil.getVisibilityModifier(currentPsiMethod.getModifierList())
+                VisibilityUtil.getVisibilityModifier(currentPsiMethod.modifierList)
             else
                 PsiModifier.PACKAGE_LOCAL
             val propagationTargets = primaryPropagationTargets.asSequence()
                     .mapNotNull { it.getRepresentativeLightMethod() }
                     .toSet()
             val javaChangeInfo = ChangeSignatureProcessor(
-                    getMethod().getProject(),
+                    method.project,
                     originalPsiMethod,
                     false,
                     newVisibility,
@@ -408,7 +398,7 @@ public open class KotlinChangeInfo(
                     arrayOf<ThrownExceptionInfo>(),
                     propagationTargets,
                     emptySet()
-            ).getChangeInfo()
+            ).changeInfo
             javaChangeInfo.updateMethod(currentPsiMethod)
 
             return javaChangeInfo
@@ -449,12 +439,12 @@ public open class KotlinChangeInfo(
                         if (javaOldIndex >= oldParameterCount) return@map null
 
                         val type = if (isPrimaryMethodUpdated)
-                            currentPsiMethod.getParameterList().getParameters()[indexInCurrentPsiMethod++].getType()
+                            currentPsiMethod.parameterList.parameters[indexInCurrentPsiMethod++].type
                         else
                             PsiType.VOID
 
                         val defaultValue = info.defaultValueForCall ?: info.defaultValueForParameter
-                        ParameterInfoImpl(javaOldIndex, info.getName(), type, defaultValue?.getText() ?: "")
+                        ParameterInfoImpl(javaOldIndex, info.name, type, defaultValue?.text ?: "")
                     }
         }
 
@@ -465,8 +455,8 @@ public open class KotlinChangeInfo(
         ): JavaChangeInfo? {
             val newParameterList = receiverParameterInfo.singletonOrEmptyList() + getNonReceiverParameters()
             val newJavaParameters = getJavaParameterInfos(originalPsiMethod, currentPsiMethod, newParameterList).toTypedArray()
-            val newName = if (isGetter) JvmAbi.getterName(getNewName()) else getNewName()
+            val newName = if (isGetter) JvmAbi.getterName(newName) else newName
-            return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, currentPsiMethod.getReturnType(), newJavaParameters)
+            return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, currentPsiMethod.returnType, newJavaParameters)
         }
 
         fun createJavaChangeInfoForSetter(originalPsiMethod: PsiMethod, currentPsiMethod: PsiMethod): JavaChangeInfo? {
@@ -474,21 +464,21 @@ public open class KotlinChangeInfo(
             val oldIndex = if (methodDescriptor.receiver != null) 1 else 0
             if (isPrimaryMethodUpdated) {
                 val newIndex = if (receiverParameterInfo != null) 1 else 0
-                val setterParameter = currentPsiMethod.getParameterList().getParameters()[newIndex]
+                val setterParameter = currentPsiMethod.parameterList.parameters[newIndex]
-                newJavaParameters.add(ParameterInfoImpl(oldIndex, setterParameter.getName(), setterParameter.getType()))
+                newJavaParameters.add(ParameterInfoImpl(oldIndex, setterParameter.name, setterParameter.type))
             }
             else {
                 newJavaParameters.add(ParameterInfoImpl(oldIndex, "receiver", PsiType.VOID))
             }
 
-            val newName = JvmAbi.setterName(getNewName())
+            val newName = JvmAbi.setterName(newName)
             return createJavaChangeInfo(originalPsiMethod, currentPsiMethod, newName, PsiType.VOID, newJavaParameters.toTypedArray())
         }
 
-        if (ProjectStructureUtil.isJsKotlinModule(getMethod().getContainingFile() as KtFile)) return null
+        if (ProjectStructureUtil.isJsKotlinModule(method.containingFile as KtFile)) return null
 
         if (javaChangeInfos == null) {
-            val method = getMethod()
+            val method = method
             originalToCurrentMethods = matchOriginalAndCurrentMethods(method.toLightMethods())
             javaChangeInfos = originalToCurrentMethods.entries.mapNotNull {
                 val (originalPsiMethod, currentPsiMethod) = it
@@ -497,7 +487,7 @@ public open class KotlinChangeInfo(
                     is KtFunction, is KtClassOrObject ->
                         createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, false)
                     is KtProperty, is KtParameter -> {
-                        val accessorName = originalPsiMethod.getName()
+                        val accessorName = originalPsiMethod.name
                         when {
                             JvmAbi.isGetterName(accessorName) ->
                                 createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, true)
@@ -521,40 +511,40 @@ public val KotlinChangeInfo.originalBaseFunctionDescriptor: CallableDescriptor
 public val KotlinChangeInfo.kind: Kind get() = methodDescriptor.kind
 
 public val KotlinChangeInfo.oldName: String?
-    get() = (methodDescriptor.getMethod() as? KtFunction)?.getName()
+    get() = (methodDescriptor.method as? KtFunction)?.name
 
 public fun KotlinChangeInfo.getAffectedCallables(): Collection<UsageInfo> = methodDescriptor.affectedCallables + propagationTargetUsageInfos
 
 public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: KotlinMethodDescriptor): KotlinChangeInfo {
-    val method = getMethod() as PsiMethod
+    val method = method as PsiMethod
 
     val functionDescriptor = method.getJavaMethodDescriptor()!!
-    val parameterDescriptors = functionDescriptor.getValueParameters()
+    val parameterDescriptors = functionDescriptor.valueParameters
 
     //noinspection ConstantConditions
-    val originalParameterDescriptors = originalChangeSignatureDescriptor.baseDescriptor.getValueParameters()
+    val originalParameterDescriptors = originalChangeSignatureDescriptor.baseDescriptor.valueParameters
 
-    val newParameters = getNewParameters().withIndex().map { pair ->
+    val newParameters = newParameters.withIndex().map { pair ->
         val (i, info) = pair
-        val oldIndex = info.getOldIndex()
+        val oldIndex = info.oldIndex
-        val currentType = parameterDescriptors[i].getType()
+        val currentType = parameterDescriptors[i].type
 
-        val defaultValueText = info.getDefaultValue()
+        val defaultValueText = info.defaultValue
         val defaultValueExpr =
                 when {
                     info is KotlinAwareJavaParameterInfoImpl -> info.kotlinDefaultValue
-                    getLanguage().`is`(JavaLanguage.INSTANCE) && !defaultValueText.isNullOrEmpty() -> {
+                    language.`is`(JavaLanguage.INSTANCE) && !defaultValueText.isNullOrEmpty() -> {
-                        PsiElementFactory.SERVICE.getInstance(method.getProject())
+                        PsiElementFactory.SERVICE.getInstance(method.project)
                                 .createExpressionFromText(defaultValueText!!, null)
                                 .j2k()
                     }
                     else -> null
                 }
 
-        val parameterType = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType
+        val parameterType = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].type else currentType
         KotlinParameterInfo(callableDescriptor = functionDescriptor,
                             originalIndex = oldIndex,
-                            name = info.getName(),
+                            name = info.name,
                             originalTypeInfo = KotlinTypeInfo(false, parameterType),
                             defaultValueForCall = defaultValueExpr).apply {
             currentTypeInfo = KotlinTypeInfo(false, currentType)
@@ -562,9 +552,9 @@ public fun ChangeInfo.toJetChangeInfo(originalChangeSignatureDescriptor: KotlinM
     }
 
     return KotlinChangeInfo(originalChangeSignatureDescriptor,
-                            getNewName(),
+                            newName,
                             KotlinTypeInfo(true, functionDescriptor.returnType),
-                            functionDescriptor.getVisibility(),
+                            functionDescriptor.visibility,
                             newParameters,
                             null,
                             method)

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

@@ -38,13 +38,13 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
-import org.jetbrains.kotlin.idea.core.refactoring.createJavaMethod
+import org.jetbrains.kotlin.idea.refactoring.createJavaMethod
-import org.jetbrains.kotlin.idea.core.refactoring.toPsiFile
+import org.jetbrains.kotlin.idea.refactoring.toPsiFile
 import org.jetbrains.kotlin.idea.refactoring.CallableRefactoring
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.ui.KotlinChangePropertySignatureDialog
 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 KotlinChangeSignatureConfiguration {
@@ -77,7 +77,7 @@ public class KotlinChangeSignature(project: Project,
                                                                                                callableDescriptor,
                                                                                                commandName ?: ChangeSignatureHandler.REFACTORING_NAME) {
 
-    private val LOG = Logger.getInstance(javaClass<KotlinChangeSignature>())
+    private val LOG = Logger.getInstance(KotlinChangeSignature::class.java)
 
     override fun forcePerformForSelectedFunctionOnly() = configuration.forcePerformForSelectedFunctionOnly()
 
@@ -91,8 +91,8 @@ public class KotlinChangeSignature(project: Project,
                 KotlinChangePropertySignatureDialog.createProcessorForSilentRefactoring(project, commandName, descriptor)
             }
             is PsiMethod -> {
-                if (baseDeclaration.getLanguage() != JavaLanguage.INSTANCE) {
+                if (baseDeclaration.language != JavaLanguage.INSTANCE) {
-                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.getLanguage().getDisplayName()} method", commandName)
+                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.language.displayName} method", commandName)
                     return
                 }
 
@@ -115,8 +115,8 @@ public class KotlinChangeSignature(project: Project,
                     return
                 }
 
-                if (baseDeclaration.getLanguage() != JavaLanguage.INSTANCE) {
+                if (baseDeclaration.language != JavaLanguage.INSTANCE) {
-                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.getLanguage().getDisplayName()} method", commandName)
+                    Messages.showErrorDialog("Can't change signature of ${baseDeclaration.language.displayName} method", commandName)
                     return
                 }
 
@@ -124,7 +124,7 @@ public class KotlinChangeSignature(project: Project,
                 object: JavaChangeSignatureDialog(project, JavaMethodDescriptor(preview), false, null) {
                     override fun createRefactoringProcessor(): BaseRefactoringProcessor? {
                         val processor = super.createRefactoringProcessor()
-                        (processor as? ChangeSignatureProcessor)?.getChangeInfo()?.updateMethod(javaChangeInfo.getMethod())
+                        (processor as? ChangeSignatureProcessor)?.changeInfo?.updateMethod(javaChangeInfo.method)
                         return processor
                     }
                 }
@@ -137,18 +137,18 @@ public class KotlinChangeSignature(project: Project,
 
     private fun getPreviewInfoForJavaMethod(descriptor: KotlinMethodDescriptor): Pair<PsiMethod, JavaChangeInfo> {
         val originalMethod = descriptor.baseDeclaration as PsiMethod
-        val contextFile = defaultValueContext.getContainingFile() as KtFile
+        val contextFile = defaultValueContext.containingFile as KtFile
 
         // Generate new Java method signature from the Kotlin point of view
         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") }
+            contextFile.packageDirective?.let { append(it.text).append("\n") }
             append("class Dummy {\n").append(ktSignature).append("{}\n}")
             toString()
         }
         val dummyFile = LightVirtualFile("dummy.kt", KotlinFileType.INSTANCE, dummyFileText).toPsiFile(project) as KtFile
-        val dummyDeclaration = (dummyFile.getDeclarations().first() as KtClass).getBody()!!.getDeclarations().first()
+        val dummyDeclaration = (dummyFile.declarations.first() as KtClass).getBody()!!.declarations.first()
 
         // Convert to PsiMethod which can be used in Change Signature dialog
         val containingClass = PsiElementFactory.SERVICE.getInstance(project).createClass("Dummy")
@@ -156,17 +156,17 @@ public class KotlinChangeSignature(project: Project,
 
         // Create JavaChangeInfo based on new signature
         // TODO: Support visibility change
-        val visibility = VisibilityUtil.getVisibilityModifier(originalMethod.getModifierList())
+        val visibility = VisibilityUtil.getVisibilityModifier(originalMethod.modifierList)
-        val returnType = CanonicalTypes.createTypeWrapper(preview.getReturnType() ?: PsiType.VOID)
+        val returnType = CanonicalTypes.createTypeWrapper(preview.returnType ?: PsiType.VOID)
-        val params = (preview.getParameterList().getParameters().zip(ktChangeInfo.getNewParameters())).map {
+        val params = (preview.parameterList.parameters.zip(ktChangeInfo.newParameters)).map {
             val (param, paramInfo) = it
             // Keep original default value for proper update of Kotlin usages
-            KotlinAwareJavaParameterInfoImpl(paramInfo.getOldIndex(), param.getName()!!, param.getType(), paramInfo.defaultValueForCall)
+            KotlinAwareJavaParameterInfoImpl(paramInfo.oldIndex, param.name!!, param.type, paramInfo.defaultValueForCall)
         }.toTypedArray()
 
         return preview to JavaChangeInfoImpl(visibility,
                                              originalMethod,
-                                             preview.getName(),
+                                             preview.name,
                                              returnType,
                                              params,
                                              arrayOf<ThrownExceptionInfo>(),
@@ -178,10 +178,10 @@ public class KotlinChangeSignature(project: Project,
     override fun performRefactoring(descriptorsForChange: Collection<CallableDescriptor>) {
         val adjustedDescriptor = adjustDescriptor(descriptorsForChange) ?: return
 
-        val affectedFunctions = adjustedDescriptor.affectedCallables.mapNotNull { it.getElement() }
+        val affectedFunctions = adjustedDescriptor.affectedCallables.mapNotNull { it.element }
         if (affectedFunctions.any { !checkModifiable(it) }) return
 
-        if (configuration.performSilently(affectedFunctions) || ApplicationManager.getApplication()!!.isUnitTestMode()) {
+        if (configuration.performSilently(affectedFunctions) || ApplicationManager.getApplication()!!.isUnitTestMode) {
             runSilentRefactoring(adjustedDescriptor)
         }
         else {
@@ -207,8 +207,8 @@ public class KotlinChangeSignature(project: Project,
 
     private fun preferContainedInClass(descriptorsForSignatureChange: Collection<CallableDescriptor>): CallableDescriptor {
         for (descriptor in descriptorsForSignatureChange) {
-            val containingDeclaration = descriptor.getContainingDeclaration()
+            val containingDeclaration = descriptor.containingDeclaration
-            if (containingDeclaration is ClassDescriptor && containingDeclaration.getKind() != ClassKind.INTERFACE) {
+            if (containingDeclaration is ClassDescriptor && containingDeclaration.kind != ClassKind.INTERFACE) {
                 return descriptor
             }
         }
@@ -237,5 +237,5 @@ public fun createChangeInfo(
             adjustedDescriptor,
             defaultValueContext
     ) as KotlinChangeSignatureProcessor
-    return processor.getChangeInfo()
+    return processor.changeInfo
 }

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

@@ -56,12 +56,12 @@ public class KotlinChangeSignatureData(
     init {
         receiver = createReceiverInfoIfNeeded()
 
-        val valueParameters = when {
+        val valueParameters = when (baseDeclaration) {
-            baseDeclaration is KtFunction -> baseDeclaration.getValueParameters()
+            is KtFunction -> baseDeclaration.valueParameters
-            baseDeclaration is KtClass -> baseDeclaration.getPrimaryConstructorParameters()
+            is KtClass -> baseDeclaration.getPrimaryConstructorParameters()
             else -> null
         }
-        parameters = baseDescriptor.getValueParameters()
+        parameters = baseDescriptor.valueParameters
                 .mapTo(receiver?.let{ arrayListOf(it) } ?: arrayListOf()) { parameterDescriptor ->
                     val jetParameter = valueParameters?.get(parameterDescriptor.index)
                     val parameterType = parameterDescriptor.type
@@ -70,11 +70,11 @@ public class KotlinChangeSignatureData(
                     KotlinParameterInfo(
                             callableDescriptor = baseDescriptor,
                             originalIndex = parameterDescriptor.index,
-                            name = parameterDescriptor.getName().asString(),
+                            name = parameterDescriptor.name.asString(),
                             originalTypeInfo = KotlinTypeInfo(false, parameterType, parameterTypeText),
-                            defaultValueForParameter = jetParameter?.getDefaultValue(),
+                            defaultValueForParameter = jetParameter?.defaultValue,
-                            valOrVar = jetParameter?.getValOrVarKeyword().toValVar(),
+                            valOrVar = jetParameter?.valOrVarKeyword.toValVar(),
-                            modifierList = jetParameter?.getModifierList()
+                            modifierList = jetParameter?.modifierList
                     )
                 }
     }
@@ -88,7 +88,7 @@ public class KotlinChangeSignatureData(
                 bodyScope.findVariable(Name.identifier(it), NoLookupLocation.FROM_IDE) == null
             }
         } ?: CollectingNameValidator(paramNames)
-        val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null
+        val receiverType = baseDescriptor.extensionReceiverParameter?.type ?: return null
         val receiverName = KotlinNameSuggester.suggestNamesByType(receiverType, validator, "receiver").first()
         val receiverTypeText = (baseDeclaration as? KtCallableDeclaration)?.receiverTypeReference?.text
                                ?: IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(receiverType)
@@ -102,9 +102,9 @@ public class KotlinChangeSignatureData(
 
     override val primaryCallables: Collection<KotlinCallableDefinitionUsage<PsiElement>> by lazy {
         descriptorsForSignatureChange.map {
-            val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(baseDeclaration.getProject(), it)
+            val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(baseDeclaration.project, it)
             assert(declaration != null) { "No declaration found for " + baseDescriptor }
-            KotlinCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
+            KotlinCallableDefinitionUsage(declaration!!, it, null, null)
         }
     }
 
@@ -137,22 +137,22 @@ public class KotlinChangeSignatureData(
 
     override fun getName(): String {
         if (baseDescriptor is ConstructorDescriptor) {
-            return baseDescriptor.getContainingDeclaration().getName().asString()
+            return baseDescriptor.containingDeclaration.name.asString()
         }
         else if (baseDescriptor is AnonymousFunctionDescriptor) {
             return ""
         }
         else {
-            return baseDescriptor.getName().asString()
+            return baseDescriptor.name.asString()
         }
     }
 
     override fun getParametersCount(): Int {
-        return baseDescriptor.getValueParameters().size()
+        return baseDescriptor.valueParameters.size
     }
 
     override fun getVisibility(): Visibility {
-        return baseDescriptor.getVisibility()
+        return baseDescriptor.visibility
     }
 
     override fun getMethod(): PsiElement {
@@ -161,8 +161,8 @@ public class KotlinChangeSignatureData(
 
     override fun canChangeVisibility(): Boolean {
         if (DescriptorUtils.isLocal(baseDescriptor)) return false;
-        val parent = baseDescriptor.getContainingDeclaration()
+        val parent = baseDescriptor.containingDeclaration
-        return !(baseDescriptor is AnonymousFunctionDescriptor || parent is ClassDescriptor && parent.getKind() == ClassKind.INTERFACE)
+        return !(baseDescriptor is AnonymousFunctionDescriptor || parent is ClassDescriptor && parent.kind == ClassKind.INTERFACE)
     }
 
     override fun canChangeParameters(): Boolean {

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

@@ -48,24 +48,24 @@ import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 public class KotlinChangeSignatureHandler : ChangeSignatureHandler {
 
     override fun findTargetMember(file: PsiFile, editor: Editor) =
-            file.findElementAt(editor.getCaretModel().getOffset())?.let { findTargetMember(it) }
+            file.findElementAt(editor.caretModel.offset)?.let { findTargetMember(it) }
 
     override fun findTargetMember(element: PsiElement) =
             findTargetForRefactoring(element)
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext) {
-        editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE)
+        editor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
 
         val element = findTargetMember(file, editor) ?: CommonDataKeys.PSI_ELEMENT.getData(dataContext) ?: return
-        val elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()) ?: return
+        val elementAtCaret = file.findElementAt(editor.caretModel.offset) ?: return
-        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.text}")
 
         invokeChangeSignature(element, elementAtCaret, project, editor)
     }
 
     override fun invoke(project: Project, elements: Array<PsiElement>, dataContext: DataContext?) {
         val element = elements.singleOrNull()?.unwrapped ?: return
-        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.getText()}")
+        if (element !is KtElement) throw AssertionError("This handler must be invoked for Kotlin elements only: ${element.text}")
 
         val editor = dataContext?.let { CommonDataKeys.EDITOR.getData(it) }
         invokeChangeSignature(element, element, project, editor)
@@ -76,36 +76,36 @@ public class KotlinChangeSignatureHandler : ChangeSignatureHandler {
 
     companion object {
         public fun findTargetForRefactoring(element: PsiElement): PsiElement? {
-            val elementParent = element.getParent()
+            val elementParent = element.parent
 
             if ((elementParent is KtNamedFunction || elementParent is KtClass || elementParent is KtProperty)
-                && (elementParent as KtNamedDeclaration).getNameIdentifier() === element) return elementParent
+                && (elementParent as KtNamedDeclaration).nameIdentifier === element) return elementParent
 
             if (elementParent is KtParameter) {
-                val primaryConstructor = PsiTreeUtil.getParentOfType(elementParent, javaClass<KtPrimaryConstructor>())
+                val primaryConstructor = PsiTreeUtil.getParentOfType(elementParent, KtPrimaryConstructor::class.java)
                 if (elementParent.hasValOrVar()
-                    && (elementParent.getNameIdentifier() === element || elementParent.getValOrVarKeyword() === element)
+                    && (elementParent.nameIdentifier === element || elementParent.valOrVarKeyword === element)
                     && primaryConstructor != null
-                    && primaryConstructor.getValueParameterList() === elementParent.getParent()) return elementParent
+                    && primaryConstructor.valueParameterList === elementParent.parent) return elementParent
             }
 
             if (elementParent is KtSecondaryConstructor && elementParent.getConstructorKeyword() === element) return elementParent
 
             element.getStrictParentOfType<KtParameterList>()?.let { parameterList ->
-                return PsiTreeUtil.getParentOfType(parameterList, javaClass<KtFunction>(), javaClass<KtProperty>(), javaClass<KtClass>())
+                return PsiTreeUtil.getParentOfType(parameterList, KtFunction::class.java, KtProperty::class.java, KtClass::class.java)
             }
 
             element.getStrictParentOfType<KtTypeParameterList>()?.let { typeParameterList ->
-                return PsiTreeUtil.getParentOfType(typeParameterList, javaClass<KtFunction>(), javaClass<KtProperty>(), javaClass<KtClass>())
+                return PsiTreeUtil.getParentOfType(typeParameterList, KtFunction::class.java, KtProperty::class.java, KtClass::class.java)
             }
 
             val call: KtCallElement? = PsiTreeUtil.getParentOfType(element,
-                                                                   javaClass<KtCallExpression>(),
+                                                                   KtCallExpression::class.java,
-                                                                   javaClass<KtSuperTypeCallEntry>(),
+                                                                   KtSuperTypeCallEntry::class.java,
-                                                                   javaClass<KtConstructorDelegationCall>())
+                                                                   KtConstructorDelegationCall::class.java)
             val calleeExpr = call?.let {
-                val callee = it.getCalleeExpression()
+                val callee = it.calleeExpression
-                (callee as? KtConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
+                (callee as? KtConstructorCalleeExpression)?.constructorReferenceExpression ?: callee
             } ?: element.getStrictParentOfType<KtSimpleNameExpression>()
 
             if (calleeExpr is KtSimpleNameExpression || calleeExpr is KtConstructorDelegationReferenceExpression) {
@@ -157,7 +157,7 @@ public class KotlinChangeSignatureHandler : ChangeSignatureHandler {
                 is KtReferenceExpression -> bindingContext[BindingContext.REFERENCE_TARGET, element]
                 else -> bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, element]
             }
-            return if (descriptor is ClassDescriptor) descriptor.getUnsubstitutedPrimaryConstructor() else descriptor
+            return if (descriptor is ClassDescriptor) descriptor.unsubstitutedPrimaryConstructor else descriptor
         }
 
         public fun findDescriptor(element: PsiElement, project: Project, editor: Editor?, bindingContext: BindingContext): CallableDescriptor? {
@@ -167,14 +167,14 @@ public class KotlinChangeSignatureHandler : ChangeSignatureHandler {
 
             return when (descriptor) {
                 is FunctionDescriptor -> {
-                    if (descriptor.getValueParameters().any { it.varargElementType != null }) {
+                    if (descriptor.valueParameters.any { it.varargElementType != null }) {
                         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) {
+                    if (descriptor.kind === SYNTHESIZED) {
-                        val message = KotlinRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.getName())
+                        val message = KotlinRefactoringBundle.message("cannot.refactor.synthesized.function", descriptor.name)
                         CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
                         return null
                     }

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

@@ -38,18 +38,18 @@ public class KotlinChangeSignatureProcessor(project: Project,
                                             changeInfo: KotlinChangeInfo,
                                             private val commandName: String) : ChangeSignatureProcessorBase(project, changeInfo) {
     override fun createUsageViewDescriptor(usages: Array<UsageInfo>): UsageViewDescriptor {
-        val subject = if (getChangeInfo().kind.isConstructor) "constructor" else "function"
+        val subject = if (changeInfo.kind.isConstructor) "constructor" else "function"
-        return KotlinUsagesViewDescriptor(myChangeInfo.getMethod(), RefactoringBundle.message("0.to.change.signature", subject))
+        return KotlinUsagesViewDescriptor(myChangeInfo.method, RefactoringBundle.message("0.to.change.signature", subject))
     }
 
     override fun getChangeInfo() = super.getChangeInfo() as KotlinChangeInfo
 
     override fun findUsages(): Array<UsageInfo> {
         val allUsages = ArrayList<UsageInfo>()
-        getChangeInfo().getOrCreateJavaChangeInfos()?.let { javaChangeInfos ->
+        changeInfo.getOrCreateJavaChangeInfos()?.let { javaChangeInfos ->
             val javaProcessor = JavaChangeSignatureUsageProcessor()
             javaChangeInfos.mapTo(allUsages) {
-                KotlinWrapperForJavaUsageInfos(it, javaProcessor.findUsages(it), getChangeInfo().getMethod())
+                KotlinWrapperForJavaUsageInfos(it, javaProcessor.findUsages(it), changeInfo.method)
             }
         }
         super.findUsages().filterTo(allUsages) { it is KotlinUsageInfo<*> || it is UnresolvableCollisionUsageInfo }
@@ -58,7 +58,7 @@ public class KotlinChangeSignatureProcessor(project: Project,
     }
 
     override fun preprocessUsages(refUsages: Ref<Array<UsageInfo>>): Boolean {
-        val usageProcessors = ChangeSignatureUsageProcessor.EP_NAME.getExtensions()
+        val usageProcessors = ChangeSignatureUsageProcessor.EP_NAME.extensions
 
         if (!usageProcessors.all { it.setupDefaultValues(myChangeInfo, refUsages, myProject) }) return false
 
@@ -72,25 +72,25 @@ public class KotlinChangeSignatureProcessor(project: Project,
 
         RenameUtil.addConflictDescriptions(usages, conflictDescriptions)
         RenameUtil.removeConflictUsages(usagesSet)
-        if (!conflictDescriptions.isEmpty()) {
+        if (!conflictDescriptions.isEmpty) {
-            if (ApplicationManager.getApplication().isUnitTestMode()) {
+            if (ApplicationManager.getApplication().isUnitTestMode) {
                 throw BaseRefactoringProcessor.ConflictsInTestsException(conflictDescriptions.values())
             }
 
             val dialog = prepareConflictsDialog(conflictDescriptions, usages)
             dialog.show()
-            if (!dialog.isOK()) {
+            if (!dialog.isOK) {
-                if (dialog.isShowConflicts()) prepareSuccessful()
+                if (dialog.isShowConflicts) prepareSuccessful()
                 return false
             }
         }
 
         val usageArray = usagesSet.toTypedArray()
         Arrays.sort(usageArray) { u1, u2 ->
-            val element1 = u1.getElement()
+            val element1 = u1.element
-            val element2 = u2.getElement()
+            val element2 = u2.element
-            val rank1 = if (element1 != null) element1.getTextOffset() else -1
+            val rank1 = if (element1 != null) element1.textOffset else -1
-            val rank2 = if (element2 != null) element2.getTextOffset() else -1
+            val rank2 = if (element2 != null) element2.textOffset else -1
             rank2 - rank1 // Reverse order
         }
         refUsages.set(usageArray)
@@ -100,7 +100,7 @@ public class KotlinChangeSignatureProcessor(project: Project,
         return true
     }
 
-    override fun isPreviewUsages(usages: Array<out UsageInfo>): Boolean = isPreviewUsages()
+    override fun isPreviewUsages(usages: Array<out UsageInfo>): Boolean = isPreviewUsages
 
     override fun getCommandName() = commandName
 }

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

@@ -47,8 +47,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptorIfAny
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.codeInsight.KotlinFileReferencesResolver
 import org.jetbrains.kotlin.idea.core.compareDescriptors
-import org.jetbrains.kotlin.idea.core.refactoring.createTempCopy
+import org.jetbrains.kotlin.idea.refactoring.createTempCopy
-import org.jetbrains.kotlin.idea.core.refactoring.isTrueJavaMethod
+import org.jetbrains.kotlin.idea.refactoring.isTrueJavaMethod
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.*
 import org.jetbrains.kotlin.idea.refactoring.getBodyScope
 import org.jetbrains.kotlin.idea.refactoring.getContainingScope

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

@@ -37,7 +37,7 @@ public interface KotlinMethodDescriptor : MethodDescriptor<KotlinParameterInfo,
         val descriptor = baseDescriptor
         return when {
             descriptor !is ConstructorDescriptor -> Kind.FUNCTION
-            descriptor.isPrimary() -> Kind.PRIMARY_CONSTRUCTOR
+            descriptor.isPrimary -> Kind.PRIMARY_CONSTRUCTOR
             else -> Kind.SECONDARY_CONSTRUCTOR
         }
     }

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.refactoring.changeSignature
 import org.jetbrains.kotlin.descriptors.Visibility
 
 public class KotlinMutableMethodDescriptor(override val original: KotlinMethodDescriptor): KotlinMethodDescriptor by original {
-    private val parameters: MutableList<KotlinParameterInfo> = original.getParameters()
+    private val parameters: MutableList<KotlinParameterInfo> = original.parameters
 
     override var receiver: KotlinParameterInfo? = original.receiver
         set(value: KotlinParameterInfo?) {
@@ -34,19 +34,14 @@ public class KotlinMutableMethodDescriptor(override val original: KotlinMethodDe
     }
 
     public fun removeParameter(index: Int) {
-        val paramInfo = parameters.remove(index)
+        val paramInfo = parameters.removeAt(index)
         if (paramInfo == receiver) {
             receiver = null
         }
     }
 
     public fun renameParameter(index: Int, newName: String) {
-        parameters[index].setName(newName)
+        parameters[index].name = newName
-    }
-
-    public fun clearParameters() {
-        parameters.clear()
-        receiver = null
     }
 
     public fun clearNonReceiverParameters() {
@@ -55,6 +50,6 @@ public class KotlinMutableMethodDescriptor(override val original: KotlinMethodDe
     }
 
     override fun getVisibility(): Visibility? {
-        return original.getVisibility()
+        return original.visibility
     }
 }

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

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.descriptors.*
 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.quoteIfNeeded
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.references.mainReference
@@ -49,17 +49,17 @@ public class KotlinParameterInfo @JvmOverloads constructor (
     public val defaultValueParameterReferences: Map<PsiReference, DeclarationDescriptor>
 
     init {
-        val file = defaultValueForCall?.getContainingFile() as? KtFile
+        val file = defaultValueForCall?.containingFile as? KtFile
         defaultValueParameterReferences =
-                if (defaultValueForCall != null && file != null && (file.isPhysical() || file.analysisContext != null)) {
+                if (defaultValueForCall != null && file != null && (file.isPhysical || file.analysisContext != null)) {
-                    val project = file.getProject()
+                    val project = file.project
                     val map = LinkedHashMap<PsiReference, DeclarationDescriptor>()
 
                     defaultValueForCall!!.accept(
                             object : KtTreeVisitorVoid() {
                                 private fun selfParameterOrNull(parameter: DeclarationDescriptor?): ValueParameterDescriptor? {
                                     return if (parameter is ValueParameterDescriptor &&
-                                               compareDescriptors(project, parameter.getContainingDeclaration(), callableDescriptor)) {
+                                               compareDescriptors(project, parameter.containingDeclaration, callableDescriptor)) {
                                         parameter
                                     } else null
                                 }
@@ -67,12 +67,12 @@ public class KotlinParameterInfo @JvmOverloads constructor (
                                 private fun selfReceiverOrNull(receiverDescriptor: DeclarationDescriptor?): DeclarationDescriptor? {
                                     if (compareDescriptors(project,
                                                            receiverDescriptor,
-                                                           callableDescriptor.getExtensionReceiverParameter()?.getContainingDeclaration())) {
+                                                           callableDescriptor.extensionReceiverParameter?.containingDeclaration)) {
                                         return receiverDescriptor
                                     }
                                     if (compareDescriptors(project,
                                                            receiverDescriptor,
-                                                           callableDescriptor.getDispatchReceiverParameter()?.getContainingDeclaration())) {
+                                                           callableDescriptor.dispatchReceiverParameter?.containingDeclaration)) {
                                         return receiverDescriptor
                                     }
                                     return null
@@ -97,12 +97,12 @@ public class KotlinParameterInfo @JvmOverloads constructor (
                                     }
 
                                     val resolvedCall = expression.getResolvedCall(context) ?: return null
-                                    (resolvedCall.getResultingDescriptor() as? ReceiverParameterDescriptor)?.let {
+                                    (resolvedCall.resultingDescriptor as? ReceiverParameterDescriptor)?.let {
-                                        return if (selfReceiverOrNull(it.getContainingDeclaration()) != null) it else null
+                                        return if (selfReceiverOrNull(it.containingDeclaration) != null) it else null
                                     }
 
-                                    selfReceiverOrNull(resolvedCall.getExtensionReceiver() as? ImplicitReceiver)?.let { return it }
+                                    selfReceiverOrNull(resolvedCall.extensionReceiver as? ImplicitReceiver)?.let { return it }
-                                    selfReceiverOrNull(resolvedCall.getDispatchReceiver() as? ImplicitReceiver)?.let { return it }
+                                    selfReceiverOrNull(resolvedCall.dispatchReceiver as? ImplicitReceiver)?.let { return it }
 
                                     return null
                                 }
@@ -149,7 +149,7 @@ public class KotlinParameterInfo @JvmOverloads constructor (
         val defaultRendering = currentTypeInfo.render()
         val typeSubstitutor = inheritedCallable.typeSubstitutor ?: return defaultRendering
         val currentBaseFunction = inheritedCallable.baseFunction.currentCallableDescriptor ?: return defaultRendering
-        val parameterType = currentBaseFunction.getValueParameters().get(parameterIndex).getType()
+        val parameterType = currentBaseFunction.valueParameters[parameterIndex].type
         if (parameterType.isError) return defaultRendering
         return parameterType.renderTypeWithSubstitution(typeSubstitutor, defaultRendering, true)
     }
@@ -161,13 +161,13 @@ public class KotlinParameterInfo @JvmOverloads constructor (
         val baseFunctionDescriptor = baseFunction.originalCallableDescriptor
 
         val inheritedFunctionDescriptor = inheritedCallable.originalCallableDescriptor
-        val inheritedParameterDescriptors = inheritedFunctionDescriptor.getValueParameters()
+        val inheritedParameterDescriptors = inheritedFunctionDescriptor.valueParameters
         if (originalIndex < 0
-            || originalIndex >= baseFunctionDescriptor.getValueParameters().size()
+            || originalIndex >= baseFunctionDescriptor.valueParameters.size
-            || originalIndex >= inheritedParameterDescriptors.size()) return name
+            || originalIndex >= inheritedParameterDescriptors.size) return name
 
-        val inheritedParamName = inheritedParameterDescriptors.get(originalIndex).getName().asString()
+        val inheritedParamName = inheritedParameterDescriptors[originalIndex].name.asString()
-        val oldParamName = baseFunctionDescriptor.getValueParameters().get(originalIndex).getName().asString()
+        val oldParamName = baseFunctionDescriptor.valueParameters[originalIndex].name.asString()
 
         return when {
             oldParamName == inheritedParamName && inheritedFunctionDescriptor !is AnonymousFunctionDescriptor -> name
@@ -181,16 +181,16 @@ public class KotlinParameterInfo @JvmOverloads constructor (
 
         if (originalIndex < 0) return !inheritedCallable.hasExpectedType
 
-        val inheritedParameterDescriptor = inheritedFunctionDescriptor.getValueParameters().get(originalIndex)
+        val inheritedParameterDescriptor = inheritedFunctionDescriptor.valueParameters[originalIndex]
         val parameter = DescriptorToSourceUtils.descriptorToDeclaration(inheritedParameterDescriptor) as? KtParameter ?: return false
-        return parameter.getTypeReference() != null
+        return parameter.typeReference != null
     }
 
     public fun getDeclarationSignature(parameterIndex: Int, inheritedCallable: KotlinCallableDefinitionUsage<*>): String {
         val buffer = StringBuilder()
 
         if (modifierList != null) {
-            buffer.append(modifierList.getText()).append(' ')
+            buffer.append(modifierList.text).append(' ')
         }
 
         if (valOrVar != KotlinValVar.None) {
@@ -204,7 +204,7 @@ public class KotlinParameterInfo @JvmOverloads constructor (
         }
 
         if (!inheritedCallable.isInherited) {
-            defaultValueForParameter?.let { buffer.append(" = ").append(it.getText()) }
+            defaultValueForParameter?.let { buffer.append(" = ").append(it.text) }
         }
 
         return buffer.toString()

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

@@ -39,8 +39,8 @@ public enum class KotlinValVar(val keywordName: String) {
 fun PsiElement?.toValVar(): KotlinValVar {
     return when {
         this == null -> KotlinValVar.None
-        getNode().getElementType() == KtTokens.VAL_KEYWORD -> KotlinValVar.Val
+        node.elementType == KtTokens.VAL_KEYWORD -> KotlinValVar.Val
-        getNode().getElementType() == KtTokens.VAR_KEYWORD -> KotlinValVar.Var
+        node.elementType == KtTokens.VAR_KEYWORD -> KotlinValVar.Var
-        else -> throw IllegalArgumentException("Unknown val/var token: " + getText())
+        else -> throw IllegalArgumentException("Unknown val/var token: " + text)
     }
 }

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

@@ -37,7 +37,7 @@ fun KtNamedDeclaration.getDeclarationBody(): KtElement? {
         this is KtClassOrObject -> getSuperTypeList()
         this is KtPrimaryConstructor -> getContainingClassOrObject().getSuperTypeList()
         this is KtSecondaryConstructor -> getDelegationCall()
-        this is KtNamedFunction -> getBodyExpression()
+        this is KtNamedFunction -> bodyExpression
         else -> null
     }
 }
@@ -51,9 +51,9 @@ public fun PsiElement.isCaller(allUsages: Array<out UsageInfo>): Boolean {
                 usage is KotlinCallerUsage
                 || usage is DeferredJavaMethodKotlinCallerUsage
                 || usage is CallerUsageInfo
-                || (usage is OverriderUsageInfo && !usage.isOriginalOverrider())
+                || (usage is OverriderUsageInfo && !usage.isOriginalOverrider)
             }
-            .any { it.getElement() == elementToSearch }
+            .any { it.element == elementToSearch }
 }
 
 public fun KtElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Boolean {
@@ -61,7 +61,7 @@ public fun KtElement.isInsideOfCallerBody(allUsages: Array<out UsageInfo>): Bool
         it is KtNamedFunction || it is KtConstructor<*> || it is KtClassOrObject
     } as? KtNamedDeclaration ?: return false
     val body = container.getDeclarationBody() ?: return false
-    return body.getTextRange().contains(getTextRange()) && container.isCaller(allUsages)
+    return body.textRange.contains(textRange) && container.isCaller(allUsages)
 }
 
 fun getCallableSubstitutor(

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

@@ -81,27 +81,27 @@ public class KotlinMethodNode(
     override fun customizeRendererText(renderer: ColoredTreeCellRenderer) {
         val descriptor = when (myMethod) {
             is KtFunction -> myMethod.resolveToDescriptor() as FunctionDescriptor
-            is KtClass -> (myMethod.resolveToDescriptor() as ClassDescriptor).getUnsubstitutedPrimaryConstructor() ?: return
+            is KtClass -> (myMethod.resolveToDescriptor() as ClassDescriptor).unsubstitutedPrimaryConstructor ?: return
             is PsiMethod -> myMethod.getJavaMethodDescriptor() ?: return
             else -> throw AssertionError("Invalid declaration: ${myMethod.getElementTextWithContext()}")
         }
-        val containerName = sequence<DeclarationDescriptor>(descriptor) { it.getContainingDeclaration() }
+        val containerName = sequence<DeclarationDescriptor>(descriptor) { it.containingDeclaration }
                 .firstOrNull { it is ClassDescriptor }
-                ?.getName()
+                ?.name
 
         val renderedFunction = KotlinCallHierarchyNodeDescriptor.renderNamedFunction(descriptor)
         val renderedFunctionWithContainer =
                 containerName?.let {
-                    "${if (it.isSpecial()) "[Anonymous]" else it.asString()}.$renderedFunction"
+                    "${if (it.isSpecial) "[Anonymous]" else it.asString()}.$renderedFunction"
                 } ?: renderedFunction
 
-        val attributes = if (isEnabled())
+        val attributes = if (isEnabled)
             SimpleTextAttributes(SimpleTextAttributes.STYLE_PLAIN, UIUtil.getTreeForeground())
         else
             SimpleTextAttributes.EXCLUDED_ATTRIBUTES
         renderer.append(renderedFunctionWithContainer, attributes)
 
-        val packageName = (myMethod.getContainingFile() as? PsiClassOwner)?.getPackageName() ?: ""
+        val packageName = (myMethod.containingFile as? PsiClassOwner)?.packageName ?: ""
         renderer.append("  ($packageName)", SimpleTextAttributes(SimpleTextAttributes.STYLE_ITALIC, JBColor.GRAY))
     }
 
@@ -117,8 +117,8 @@ public class KotlinMethodNode(
                 }
             }
         }
-        val query = myMethod.getRepresentativeLightMethod()?.let { MethodReferencesSearch.search(it, it.getUseScope(), true) }
+        val query = myMethod.getRepresentativeLightMethod()?.let { MethodReferencesSearch.search(it, it.useScope, true) }
-                    ?: ReferencesSearch.search(myMethod, myMethod.getUseScope())
+                    ?: ReferencesSearch.search(myMethod, myMethod.useScope)
         query.forEach { processor.process(it) }
         return callers.toList()
     }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.changeSignature
+package org.jetbrains.kotlin.idea.refactoring.changeSignature.ui
 
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiDocumentManager
@@ -25,7 +25,8 @@ import com.intellij.util.ui.FormBuilder
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.idea.core.refactoring.validateElement
+import org.jetbrains.kotlin.idea.refactoring.validateElement
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtProperty
 import org.jetbrains.kotlin.psi.KtPsiFactory
@@ -43,7 +44,7 @@ public class KotlinChangePropertySignatureDialog(
     private val visibilityCombo = JComboBox(
             arrayOf(Visibilities.INTERNAL, Visibilities.PRIVATE, Visibilities.PROTECTED, Visibilities.PUBLIC)
     )
-    private val nameField = EditorTextField(methodDescriptor.getName())
+    private val nameField = EditorTextField(methodDescriptor.name)
     private var returnTypeField: EditorTextField by Delegates.notNull()
     private var receiverTypeCheckBox: JCheckBox? = null
     var receiverTypeLabel: JLabel by Delegates.notNull()
@@ -52,7 +53,7 @@ public class KotlinChangePropertySignatureDialog(
     private var receiverDefaultValueField: EditorTextField? = null
 
     init {
-        setTitle("Change Signature")
+        title = "Change Signature"
         init()
     }
 
@@ -60,11 +61,11 @@ public class KotlinChangePropertySignatureDialog(
 
     override fun createCenterPanel(): JComponent? {
         fun updateReceiverUI() {
-            val withReceiver = receiverTypeCheckBox!!.isSelected()
+            val withReceiver = receiverTypeCheckBox!!.isSelected
-            receiverTypeLabel.setEnabled(withReceiver)
+            receiverTypeLabel.isEnabled = withReceiver
-            receiverTypeField.setEnabled(withReceiver)
+            receiverTypeField.isEnabled = withReceiver
-            receiverDefaultValueLabel?.setEnabled(withReceiver)
+            receiverDefaultValueLabel?.isEnabled = withReceiver
-            receiverDefaultValueField?.setEnabled(withReceiver)
+            receiverDefaultValueField?.isEnabled = withReceiver
         }
 
         val documentManager = PsiDocumentManager.getInstance(myProject)
@@ -72,8 +73,8 @@ public class KotlinChangePropertySignatureDialog(
 
         return with(FormBuilder.createFormBuilder()) {
             val baseDeclaration = methodDescriptor.baseDeclaration
-            if (!((baseDeclaration as? KtProperty)?.isLocal() ?: false)) {
+            if (!((baseDeclaration as? KtProperty)?.isLocal ?: false)) {
-                visibilityCombo.setSelectedItem(methodDescriptor.getVisibility())
+                visibilityCombo.selectedItem = methodDescriptor.visibility
                 addLabeledComponent("&Visibility: ", visibilityCombo)
             }
 
@@ -90,7 +91,7 @@ public class KotlinChangePropertySignatureDialog(
                 val receiverTypeCheckBox = JCheckBox("Extension property: ")
                 receiverTypeCheckBox.setMnemonic('x')
                 receiverTypeCheckBox.addActionListener { updateReceiverUI() }
-                receiverTypeCheckBox.setSelected(methodDescriptor.receiver != null)
+                receiverTypeCheckBox.isSelected = methodDescriptor.receiver != null
                 addComponent(receiverTypeCheckBox)
                 this@KotlinChangePropertySignatureDialog.receiverTypeCheckBox = receiverTypeCheckBox
 
@@ -114,22 +115,22 @@ public class KotlinChangePropertySignatureDialog(
                 updateReceiverUI()
             }
 
-            getPanel()
+            panel
         }
     }
 
     private fun getDefaultReceiverValue(): KtExpression? {
-        val receiverDefaultValue = receiverDefaultValueField?.getText() ?: ""
+        val receiverDefaultValue = receiverDefaultValueField?.text ?: ""
         return if (receiverDefaultValue.isNotEmpty()) KtPsiFactory(myProject).createExpression(receiverDefaultValue) else null
     }
 
     override fun canRun() {
         val psiFactory = KtPsiFactory(myProject)
 
-        psiFactory.createSimpleName(nameField.getText()).validateElement("Invalid name")
+        psiFactory.createSimpleName(nameField.text).validateElement("Invalid name")
-        psiFactory.createType(returnTypeField.getText()).validateElement("Invalid return type")
+        psiFactory.createType(returnTypeField.text).validateElement("Invalid return type")
-        if (receiverTypeCheckBox?.isSelected() ?: false) {
+        if (receiverTypeCheckBox?.isSelected ?: false) {
-            psiFactory.createType(receiverTypeField.getText()).validateElement("Invalid receiver type")
+            psiFactory.createType(receiverTypeField.text).validateElement("Invalid receiver type")
         }
         getDefaultReceiverValue()?.validateElement("Invalid default receiver value")
     }
@@ -137,21 +138,21 @@ public class KotlinChangePropertySignatureDialog(
     override fun doAction() {
         val originalDescriptor = methodDescriptor.original
 
-        val receiver = if (receiverTypeCheckBox?.isSelected() ?: false) {
+        val receiver = if (receiverTypeCheckBox?.isSelected ?: false) {
             originalDescriptor.receiver ?: KotlinParameterInfo(callableDescriptor = originalDescriptor.baseDescriptor,
                                                                name = "receiver",
                                                                defaultValueForCall = getDefaultReceiverValue())
         } else null
-        receiver?.currentTypeInfo = KotlinTypeInfo(false, null, receiverTypeField.getText())
+        receiver?.currentTypeInfo = KotlinTypeInfo(false, null, receiverTypeField.text)
         val changeInfo = KotlinChangeInfo(originalDescriptor,
-                                          nameField.getText(),
+                                          nameField.text,
                                           KotlinTypeInfo(true, null, returnTypeField.text),
-                                          visibilityCombo.getSelectedItem() as Visibility,
+                                          visibilityCombo.selectedItem as Visibility,
                                           emptyList(),
                                           receiver,
-                                          originalDescriptor.getMethod())
+                                          originalDescriptor.method)
 
-        invokeRefactoring(KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle()))
+        invokeRefactoring(KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: title))
     }
 
     companion object {
@@ -161,8 +162,8 @@ public class KotlinChangePropertySignatureDialog(
                 descriptor: KotlinMethodDescriptor
         ): BaseRefactoringProcessor {
             val originalDescriptor = descriptor.original
-            val changeInfo = KotlinChangeInfo(methodDescriptor = originalDescriptor, context = originalDescriptor.getMethod())
+            val changeInfo = KotlinChangeInfo(methodDescriptor = originalDescriptor, context = originalDescriptor.method)
-            changeInfo.setNewName(descriptor.getName())
+            changeInfo.newName = descriptor.name
             changeInfo.receiverParameterInfo = descriptor.receiver
             return KotlinChangeSignatureProcessor(project, changeInfo, commandName)
         }

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

@@ -48,7 +48,6 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.idea.KotlinFileType
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
-import org.jetbrains.kotlin.idea.core.refactoring.validateElementAndNotNull
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinMethodDescriptor.Kind
@@ -62,7 +61,6 @@ import java.awt.BorderLayout
 import java.awt.Font
 import java.awt.Toolkit
 import java.awt.event.ItemEvent
-import java.awt.event.ItemListener
 import java.util.*
 import javax.swing.*
 
@@ -102,30 +100,30 @@ public class KotlinChangeSignatureDialog(
         }
 
         val parameterName = getPresentationName(item)
-        val typeText = item.typeCodeFragment.getText()
+        val typeText = item.typeCodeFragment.text
-        val defaultValue = item.defaultValueCodeFragment.getText()
+        val defaultValue = item.defaultValueCodeFragment.text
-        val separator = StringUtil.repeatSymbol(' ', getParamNamesMaxLength() - parameterName.length() + 1)
+        val separator = StringUtil.repeatSymbol(' ', getParamNamesMaxLength() - parameterName.length + 1)
         var text = "$valOrVar$parameterName:$separator$typeText"
 
         if (StringUtil.isNotEmpty(defaultValue)) {
             text += " // default value = $defaultValue"
         }
 
-        val field = object : EditorTextField(" $text", getProject(), getFileType()) {
+        val field = object : EditorTextField(" $text", project, fileType) {
             override fun shouldHaveBorder() = false
         }
 
-        val plainFont  = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN)
+        val plainFont  = EditorColorsManager.getInstance().globalScheme.getFont(EditorFontType.PLAIN)
-        field.setFont(Font(plainFont.getFontName(), plainFont.getStyle(), 12))
+        field.font = Font(plainFont.fontName, plainFont.style, 12)
 
         if (selected && focused) {
-            panel.setBackground(UIUtil.getTableSelectionBackground())
+            panel.background = UIUtil.getTableSelectionBackground()
             field.setAsRendererWithSelection(UIUtil.getTableSelectionBackground(), UIUtil.getTableSelectionForeground())
         }
         else {
-            panel.setBackground(UIUtil.getTableBackground())
+            panel.background = UIUtil.getTableBackground()
             if (selected && !focused) {
-                panel.setBorder(DottedBorder(UIUtil.getTableForeground()))
+                panel.border = DottedBorder(UIUtil.getTableForeground())
             }
         }
         panel.add(field, BorderLayout.WEST)
@@ -135,50 +133,50 @@ public class KotlinChangeSignatureDialog(
 
     private fun getPresentationName(item: ParameterTableModelItemBase<KotlinParameterInfo>): String {
         val parameter = item.parameter
-        return if (parameter == parametersTableModel.getReceiver()) "<receiver>" else parameter.getName()
+        return if (parameter == parametersTableModel.receiver) "<receiver>" else parameter.name
     }
 
     private fun getColumnTextMaxLength(nameFunction: Function1<ParameterTableModelItemBase<KotlinParameterInfo>, String?>) =
-            parametersTableModel.getItems().map { nameFunction(it)?.length() ?: 0 }.max() ?: 0
+            parametersTableModel.items.map { nameFunction(it)?.length ?: 0 }.max() ?: 0
 
     private fun getParamNamesMaxLength() = getColumnTextMaxLength { getPresentationName(it) }
 
-    private fun getTypesMaxLength() = getColumnTextMaxLength { it.typeCodeFragment?.getText() }
+    private fun getTypesMaxLength() = getColumnTextMaxLength { it.typeCodeFragment?.text }
 
-    private fun getDefaultValuesMaxLength() = getColumnTextMaxLength { it.defaultValueCodeFragment?.getText() }
+    private fun getDefaultValuesMaxLength() = getColumnTextMaxLength { it.defaultValueCodeFragment?.text }
 
     override fun isListTableViewSupported() = true
 
     override fun isEmptyRow(row: ParameterTableModelItemBase<KotlinParameterInfo>): Boolean {
-        if (!row.parameter.getName().isNullOrEmpty()) return false
+        if (!row.parameter.name.isNullOrEmpty()) return false
-        if (!row.parameter.getTypeText().isNullOrEmpty()) return false
+        if (!row.parameter.typeText.isNullOrEmpty()) return false
         return true
     }
 
     override fun createCallerChooser(title: String, treeToReuse: Tree?, callback: Consumer<Set<PsiElement>>) =
-            KotlinCallerChooser(myMethod.getMethod(), myProject, title, treeToReuse, callback)
+            KotlinCallerChooser(myMethod.method, myProject, title, treeToReuse, callback)
 
     // Forbid receiver propagation
     override fun mayPropagateParameters() =
-            getParameters().any { it.isNewParameter && it != parametersTableModel.getReceiver() }
+            parameters.any { it.isNewParameter && it != parametersTableModel.receiver }
 
     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())
+            private val nameEditor = EditorTextField(item.parameter.name, getProject(), getFileType())
 
             private fun updateNameEditor() {
-                nameEditor.setEnabled(item.parameter != parametersTableModel.getReceiver())
+                nameEditor.isEnabled = item.parameter != parametersTableModel.receiver
             }
 
             private fun isDefaultColumnEnabled() =
                     item.parameter.isNewParameter && item.parameter != myMethod.receiver
 
             override fun prepareEditor(table: JTable, row: Int) {
-                setLayout(BoxLayout(this, BoxLayout.X_AXIS))
+                layout = BoxLayout(this, BoxLayout.X_AXIS)
                 var column = 0
 
-                for (columnInfo in parametersTableModel.getColumnInfos()) {
+                for (columnInfo in parametersTableModel.columnInfos) {
                     val panel = JPanel(VerticalFlowLayout(VerticalFlowLayout.TOP, 4, 2, true, false))
                     val editor: EditorTextField?
                     val component: JComponent
@@ -201,22 +199,20 @@ public class KotlinChangeSignatureDialog(
                     }
                     else if (KotlinPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo)) {
                         val comboBox = JComboBox(KotlinValVar.values())
-                        comboBox.setSelectedItem(item.parameter.valOrVar)
+                        comboBox.selectedItem = item.parameter.valOrVar
-                        comboBox.addItemListener(object : ItemListener {
+                        comboBox.addItemListener {
-                            override fun itemStateChanged(e: ItemEvent) {
+                            parametersTableModel.setValueAtWithoutUpdate(it.item, row, columnFinal)
-                                parametersTableModel.setValueAtWithoutUpdate(e.getItem(), row, columnFinal)
+                            updateSignature()
-                                updateSignature()
+                        }
-                            }
-                        })
                         component = comboBox
                         editor = null
                     }
                     else if (KotlinFunctionParameterTableModel.isReceiverColumn(columnInfo)) {
                         val checkBox = JCheckBox()
-                        checkBox.setSelected(parametersTableModel.getReceiver() == item.parameter)
+                        checkBox.isSelected = parametersTableModel.receiver == item.parameter
                         checkBox.addItemListener {
-                            val newReceiver = if (it.getStateChange() == ItemEvent.SELECTED) item.parameter else null
+                            val newReceiver = if (it.stateChange == ItemEvent.SELECTED) item.parameter else null
-                            (parametersTableModel as KotlinFunctionParameterTableModel).setReceiver(newReceiver)
+                            (parametersTableModel as KotlinFunctionParameterTableModel).receiver = newReceiver
                             updateSignature()
                             updateNameEditor()
                         }
@@ -226,7 +222,7 @@ public class KotlinChangeSignatureDialog(
                     else
                         continue
 
-                    val label = JBLabel(columnInfo.getName(), UIUtil.ComponentStyle.SMALL)
+                    val label = JBLabel(columnInfo.name, UIUtil.ComponentStyle.SMALL)
                     panel.add(label)
 
                     if (editor != null) {
@@ -237,7 +233,7 @@ public class KotlinChangeSignatureDialog(
                                     }
                                 }
                         )
-                        editor.setPreferredWidth(table.getWidth() / parametersTableModel.getColumnCount())
+                        editor.setPreferredWidth(table.width / parametersTableModel.columnCount)
                     }
 
                     components.add(component)
@@ -249,27 +245,25 @@ public class KotlinChangeSignatureDialog(
             }
 
             override fun getValue(): JBTableRow {
-                return object : JBTableRow {
+                return JBTableRow { column ->
-                    override fun getValueAt(column: Int): Any? {
+                    val columnInfo = parametersTableModel.columnInfos[column]
-                        val columnInfo = parametersTableModel.getColumnInfos()[column]
 
-                        if (KotlinPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
+                    if (KotlinPrimaryConstructorParameterTableModel.isValVarColumn(columnInfo))
-                            return (components.get(column) as @Suppress("NO_TYPE_ARGUMENTS_ON_RHS") JComboBox).getSelectedItem()
+                        (components[column] as @Suppress("NO_TYPE_ARGUMENTS_ON_RHS") JComboBox).selectedItem
-                        else if (KotlinCallableParameterTableModel.isTypeColumn(columnInfo))
+                    else if (KotlinCallableParameterTableModel.isTypeColumn(columnInfo))
-                            return item.typeCodeFragment
+                        item.typeCodeFragment
-                        else if (KotlinCallableParameterTableModel.isNameColumn(columnInfo))
+                    else if (KotlinCallableParameterTableModel.isNameColumn(columnInfo))
-                            return (components.get(column) as EditorTextField).getText()
+                        (components[column] as EditorTextField).text
-                        else if (KotlinCallableParameterTableModel.isDefaultValueColumn(columnInfo))
+                    else if (KotlinCallableParameterTableModel.isDefaultValueColumn(columnInfo))
-                            return item.defaultValueCodeFragment
+                        item.defaultValueCodeFragment
-                        else
+                    else
-                            return null
+                        null
-                    }
                 }
             }
 
             private fun getColumnWidth(letters: Int): Int {
-                var font = EditorColorsManager.getInstance().getGlobalScheme().getFont(EditorFontType.PLAIN)
+                var font = EditorColorsManager.getInstance().globalScheme.getFont(EditorFontType.PLAIN)
-                font = Font(font.getFontName(), font.getStyle(), 12)
+                font = Font(font.fontName, font.style, 12)
                 return letters * Toolkit.getDefaultToolkit().getFontMetrics(font).stringWidth("W")
             }
 
@@ -282,7 +276,7 @@ public class KotlinChangeSignatureDialog(
                     intArrayOf(4, getParamNamesMaxLength(), getTypesMaxLength())
 
                 var columnIndex = 0
-                for (i in (if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) 0 else 1)..columnLetters.size() - 1) {
+                for (i in (if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) 0 else 1)..columnLetters.size - 1) {
                     val width = getColumnWidth(columnLetters[i])
 
                     if (x <= width)
@@ -296,18 +290,18 @@ public class KotlinChangeSignatureDialog(
             }
 
             override fun getPreferredFocusedComponent(): JComponent {
-                val me = getMouseEvent()
+                val me = mouseEvent
                 val index = if (me != null)
-                    getEditorIndex(me.getPoint().getX().toInt())
+                    getEditorIndex(me.point.getX().toInt())
                 else if (myMethod.kind === Kind.PRIMARY_CONSTRUCTOR) 1 else 0
-                val component = components.get(index)
+                val component = components[index]
-                return if (component is EditorTextField) component.getFocusTarget() else component
+                return if (component is EditorTextField) component.focusTarget else component
             }
 
             override fun getFocusableComponents(): Array<JComponent> {
-                return Array(components.size()) {
+                return Array(components.size) {
-                    val component = components.get(it)
+                    val component = components[it]
-                    (component as? EditorTextField)?.getFocusTarget() ?: component
+                    (component as? EditorTextField)?.focusTarget ?: component
                 }
             }
         }
@@ -317,8 +311,8 @@ public class KotlinChangeSignatureDialog(
         val changeInfo = evaluateChangeInfo(parametersTableModel,
                                             myReturnTypeCodeFragment,
                                             getMethodDescriptor(),
-                                            getVisibility(),
+                                            visibility,
-                                            getMethodName(),
+                                            methodName,
                                             myDefaultValueContext,
                                             true)
         return changeInfo.getNewSignature(getMethodDescriptor().originalPrimaryCallable)
@@ -388,18 +382,18 @@ public class KotlinChangeSignatureDialog(
         val changeInfo = evaluateChangeInfo(parametersTableModel,
                                             myReturnTypeCodeFragment,
                                             getMethodDescriptor(),
-                                            getVisibility(),
+                                            visibility,
-                                            getMethodName(),
+                                            methodName,
                                             myDefaultValueContext,
                                             false)
         changeInfo.primaryPropagationTargets = myMethodsToPropagateParameters ?: emptyList();
-        return KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: getTitle())
+        return KotlinChangeSignatureProcessor(myProject, changeInfo, commandName ?: title)
     }
 
     public fun getMethodDescriptor(): KotlinMethodDescriptor = myMethod
 
     override fun getSelectedIdx(): Int {
-        return myMethod.getParameters().withIndex().firstOrNull { it.value.isNewParameter }?.index
+        return myMethod.parameters.withIndex().firstOrNull { it.value.isNewParameter }?.index
                ?: super.getSelectedIdx()
     }
 
@@ -420,12 +414,12 @@ public class KotlinChangeSignatureDialog(
                                                                       method: KotlinMethodDescriptor,
                                                                       defaultValueContext: PsiElement): BaseRefactoringProcessor {
             val parameterTableModel = createParametersInfoModel(method, defaultValueContext)
-            parameterTableModel.setParameterInfos(method.getParameters())
+            parameterTableModel.setParameterInfos(method.parameters)
             val changeInfo = evaluateChangeInfo(parameterTableModel,
                                                 createReturnTypeCodeFragment(project, method),
                                                 method,
-                                                method.getVisibility(),
+                                                method.visibility,
-                                                method.getName(),
+                                                method.name,
                                                 defaultValueContext,
                                                 false)
             return KotlinChangeSignatureProcessor(project, changeInfo, commandName)
@@ -450,14 +444,14 @@ public class KotlinChangeSignatureDialog(
                                        methodName: String,
                                        defaultValueContext: PsiElement,
                                        forPreview: Boolean): KotlinChangeInfo {
-            val parameters = parametersModel.getItems().map { parameter ->
+            val parameters = parametersModel.items.map { parameter ->
                 val parameterInfo = parameter.parameter
 
                 parameterInfo.currentTypeInfo = parameter.typeCodeFragment.getTypeInfo(false, forPreview)
 
                 val codeFragment = parameter.defaultValueCodeFragment as KtExpressionCodeFragment
                 val oldDefaultValue = parameterInfo.defaultValueForCall
-                if (codeFragment.getText() != (if (oldDefaultValue != null) oldDefaultValue.getText() else "")) {
+                if (codeFragment.text != (if (oldDefaultValue != null) oldDefaultValue.text else "")) {
                     parameterInfo.defaultValueForCall = codeFragment.getContentElement()
                 }
 
@@ -469,7 +463,7 @@ public class KotlinChangeSignatureDialog(
                                     returnTypeCodeFragment.getTypeInfo(true, forPreview),
                                     visibility ?: Visibilities.DEFAULT_VISIBILITY,
                                     parameters,
-                                    parametersModel.getReceiver(),
+                                    parametersModel.receiver,
                                     defaultValueContext)
         }
     }

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

@@ -20,7 +20,6 @@ import com.intellij.psi.PsiElement
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 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
@@ -50,13 +49,3 @@ public class DeferredJavaMethodKotlinCallerUsage(
         }
     }
 }
-
-public class JavaConstructorDeferredUsageInDelegationCall(
-        val delegationCall: KtConstructorDelegationCall
-) : JavaMethodDeferredKotlinUsage<KtConstructorDelegationCall>(delegationCall) {
-    override fun resolve(javaMethodChangeInfo: KotlinChangeInfo): JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall> {
-        return object : JavaMethodKotlinUsageWithDelegate<KtConstructorDelegationCall>(delegationCall, javaMethodChangeInfo) {
-            override val delegateUsage = KotlinConstructorDelegationCallUsage(delegationCall, javaMethodChangeInfo)
-        }
-    }
-}

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

@@ -26,9 +26,9 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaMethodDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.codeInsight.shorten.addToShorteningWaitSet
-import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorIfAbsent
+import org.jetbrains.kotlin.idea.refactoring.createPrimaryConstructorIfAbsent
-import org.jetbrains.kotlin.idea.core.refactoring.dropOverrideKeywordIfNecessary
+import org.jetbrains.kotlin.idea.refactoring.dropOverrideKeywordIfNecessary
-import org.jetbrains.kotlin.idea.core.refactoring.replaceListPsiAndKeepDelimiters
+import org.jetbrains.kotlin.idea.refactoring.replaceListPsiAndKeepDelimiters
 import org.jetbrains.kotlin.idea.core.setVisibility
 import org.jetbrains.kotlin.idea.core.toKeywordToken
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo

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

@@ -18,7 +18,7 @@ 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.createPrimaryConstructorParameterListIfAbsent
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.getAffectedCallables
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBody
@@ -28,14 +28,14 @@ import org.jetbrains.kotlin.psi.*
 public class KotlinCallerUsage(element: KtNamedDeclaration): KotlinUsageInfo<KtNamedDeclaration>(element) {
     override fun processUsage(changeInfo: KotlinChangeInfo, element: KtNamedDeclaration, allUsages: Array<out UsageInfo>): Boolean {
         // Do not process function twice
-        if (changeInfo.getAffectedCallables().any { it is KotlinCallableDefinitionUsage<*> && it.getElement() == element }) return true
+        if (changeInfo.getAffectedCallables().any { it is KotlinCallableDefinitionUsage<*> && it.element == element }) return true
 
         val parameterList = when (element) {
-            is KtFunction -> element.getValueParameterList()
+            is KtFunction -> element.valueParameterList
             is KtClass -> element.createPrimaryConstructorParameterListIfAbsent()
             else -> null
         } ?: return true
-        val psiFactory = KtPsiFactory(getProject())
+        val psiFactory = KtPsiFactory(project)
         changeInfo.getNonReceiverParameters()
                 .withIndex()
                 .filter { it.value.isNewParameter }
@@ -52,13 +52,13 @@ public class KotlinCallerUsage(element: KtNamedDeclaration): KotlinUsageInfo<KtN
 
 public class KotlinCallerCallUsage(element: KtCallElement): KotlinUsageInfo<KtCallElement>(element) {
     override fun processUsage(changeInfo: KotlinChangeInfo, element: KtCallElement, allUsages: Array<out UsageInfo>): Boolean {
-        val argumentList = element.getValueArgumentList() ?: return true
+        val argumentList = element.valueArgumentList ?: return true
-        val psiFactory = KtPsiFactory(getProject())
+        val psiFactory = KtPsiFactory(project)
-        val isNamedCall = argumentList.getArguments().any { it.getArgumentName() != null }
+        val isNamedCall = argumentList.arguments.any { it.getArgumentName() != null }
         changeInfo.getNonReceiverParameters()
                 .filter { it.isNewParameter }
                 .forEach {
-                    val parameterName = it.getName()
+                    val parameterName = it.name
                     val argumentExpression = if (element.isInsideOfCallerBody(allUsages)) {
                         psiFactory.createExpression(parameterName)
                     }

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

@@ -29,18 +29,18 @@ public class KotlinConstructorDelegationCallUsage(
     val delegate = KotlinFunctionCallUsage(call, changeInfo.methodDescriptor.originalPrimaryCallable)
 
     override fun processUsage(changeInfo: KotlinChangeInfo, element: KtConstructorDelegationCall, allUsages: Array<out UsageInfo>): Boolean {
-        val isThisCall = element.isCallToThis()
+        val isThisCall = element.isCallToThis
 
         var elementToWorkWith = element
-        if (changeInfo.getNewParametersCount() > 0 && element.isImplicit()) {
+        if (changeInfo.getNewParametersCount() > 0 && element.isImplicit) {
-            val constructor = element.getParent() as KtSecondaryConstructor
+            val constructor = element.parent as KtSecondaryConstructor
             elementToWorkWith = constructor.replaceImplicitDelegationCallWithExplicit(isThisCall)
         }
 
         val result = delegate.processUsage(changeInfo, elementToWorkWith, allUsages)
 
-        if (changeInfo.getNewParametersCount() == 0 && !isThisCall && !elementToWorkWith.isImplicit()) {
+        if (changeInfo.getNewParametersCount() == 0 && !isThisCall && !elementToWorkWith.isImplicit) {
-            (elementToWorkWith.getParent() as? KtSecondaryConstructor)?.getColon()?.delete()
+            (elementToWorkWith.parent as? KtSecondaryConstructor)?.colon?.delete()
             elementToWorkWith.replace(KtPsiFactory(element).creareDelegatedSuperTypeEntry(""))
         }
 

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

@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.psi.*
 
 public class KotlinEnumEntryWithoutSuperCallUsage(enumEntry: KtEnumEntry) : KotlinUsageInfo<KtEnumEntry>(enumEntry) {
     override fun processUsage(changeInfo: KotlinChangeInfo, element: KtEnumEntry, allUsages: Array<out UsageInfo>): Boolean {
-        if (changeInfo.newParameters.size() > 0) {
+        if (changeInfo.newParameters.size > 0) {
             val psiFactory = KtPsiFactory(element)
 
             val delegatorToSuperCall = (element.addAfter(

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

@@ -26,7 +26,7 @@ import org.jetbrains.kotlin.descriptors.*
 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.replaceListPsiAndKeepDelimiters
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.isInsideOfCallerBody
@@ -461,15 +461,13 @@ class KotlinFunctionCallUsage(
     }
 
     companion object {
-        private val REVERSED_TEXT_OFFSET_COMPARATOR = object : Comparator<Pair<KtElement, KtElement>> {
+        private val REVERSED_TEXT_OFFSET_COMPARATOR = Comparator<kotlin.Pair<KtElement, KtElement>> { p1, p2 ->
-            override fun compare(p1: Pair<KtElement, KtElement>, p2: Pair<KtElement, KtElement>): Int {
+            val offset1 = p1.first.startOffset
-                val offset1 = p1.first.startOffset
+            val offset2 = p2.first.startOffset
-                val offset2 = p2.first.startOffset
+            when {
-                return when {
+                offset1 < offset2 -> 1
-                    offset1 < offset2 -> 1
+                offset1 > offset2 -> -1
-                    offset1 > offset2 -> -1
+                else -> 0
-                    else -> 0
-                }
             }
         }
 

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

@@ -34,8 +34,8 @@ public abstract class KotlinImplicitReceiverUsage(callElement: KtElement): Kotli
     }
 
     override fun processUsage(changeInfo: KotlinChangeInfo, element: KtElement, allUsages: Array<out UsageInfo>): Boolean {
-        val newQualifiedCall = KtPsiFactory(element.getProject()).createExpression(
+        val newQualifiedCall = KtPsiFactory(element.project).createExpression(
-                "${getNewReceiverText()}.${element.getText()}"
+                "${getNewReceiverText()}.${element.text}"
         ) as KtQualifiedExpression
         processReplacedElement(element.replace(newQualifiedCall) as KtElement)
         return false

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

@@ -17,17 +17,16 @@
 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.KotlinChangeInfo
-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
-import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinChangeInfo
-import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.idea.refactoring.changeSignature.KotlinParameterInfo
-import org.jetbrains.kotlin.psi.KtThisExpression
 import org.jetbrains.kotlin.idea.util.ShortenReferences.Options
+import org.jetbrains.kotlin.psi.KtElement
+import org.jetbrains.kotlin.psi.KtPsiFactory
+import org.jetbrains.kotlin.psi.KtQualifiedExpression
+import org.jetbrains.kotlin.psi.KtThisExpression
 
 // Explicit reference to function parameter or outer this
 public abstract class KotlinExplicitReferenceUsage<T : KtElement>(element: T) : KotlinUsageInfo<T>(element) {
@@ -38,8 +37,8 @@ public abstract class KotlinExplicitReferenceUsage<T : KtElement>(element: T) :
     }
 
     override fun processUsage(changeInfo: KotlinChangeInfo, element: T, allUsages: Array<out UsageInfo>): Boolean {
-        val newElement = KtPsiFactory(element.getProject()).createExpression(getReplacementText(changeInfo))
+        val newElement = KtPsiFactory(element.project).createExpression(getReplacementText(changeInfo))
-        val elementToReplace = (element.getParent() as? KtThisExpression) ?: element
+        val elementToReplace = (element.parent as? KtThisExpression) ?: element
         processReplacedElement(elementToReplace.replace(newElement) as KtElement)
         return false
     }
@@ -51,15 +50,15 @@ public class KotlinParameterUsage(
         val containingCallable: KotlinCallableDefinitionUsage<*>
 ) : KotlinExplicitReferenceUsage<KtElement>(element) {
     override fun processReplacedElement(element: KtElement) {
-        val qualifiedExpression = element.getParent() as? KtQualifiedExpression
+        val qualifiedExpression = element.parent as? KtQualifiedExpression
-        val elementToShorten = if (qualifiedExpression?.getReceiverExpression() == element) qualifiedExpression!! else element
+        val elementToShorten = if (qualifiedExpression?.receiverExpression == element) qualifiedExpression!! else element
         elementToShorten.addToShorteningWaitSet(Options(removeThis = true, removeThisLabels = true))
     }
 
     override fun getReplacementText(changeInfo: KotlinChangeInfo): String {
         if (changeInfo.receiverParameterInfo != parameterInfo) return parameterInfo.getInheritedName(containingCallable)
 
-        val newName = changeInfo.getNewName()
+        val newName = changeInfo.newName
         if (KotlinNameSuggester.isIdentifier(newName)) return "this@$newName"
 
         return "this"
@@ -74,5 +73,5 @@ public class KotlinNonQualifiedOuterThisUsage(
         element.addToShorteningWaitSet(Options(removeThisLabels = true))
     }
 
-    override fun getReplacementText(changeInfo: KotlinChangeInfo): String = "this@${targetDescriptor.getName().asString()}"
+    override fun getReplacementText(changeInfo: KotlinChangeInfo): String = "this@${targetDescriptor.name.asString()}"
 }

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

@@ -38,8 +38,8 @@ public class KotlinPropertyCallUsage(element: KtSimpleNameExpression): KotlinUsa
     }
 
     private fun updateName(changeInfo: KotlinChangeInfo, element: KtSimpleNameExpression) {
-        if (changeInfo.isNameChanged()) {
+        if (changeInfo.isNameChanged) {
-            element.mainReference.handleElementRename(changeInfo.getNewName())
+            element.mainReference.handleElementRename(changeInfo.newName)
         }
     }
 
@@ -53,10 +53,10 @@ public class KotlinPropertyCallUsage(element: KtSimpleNameExpression): KotlinUsa
         // Do not add extension receiver to calls with explicit dispatch receiver
         if (newReceiver != null
             && elementToReplace is KtQualifiedExpression
-            && resolvedCall?.getDispatchReceiver() is ExpressionReceiver) return
+            && resolvedCall?.dispatchReceiver is ExpressionReceiver) return
 
         val replacingElement = newReceiver?.let {
-            val psiFactory = KtPsiFactory(getProject())
+            val psiFactory = KtPsiFactory(project)
             val receiver = it.defaultValueForCall ?: psiFactory.createExpression("_")
             psiFactory.createExpressionByPattern("$0.$1", receiver, element)
         } ?: element

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

@@ -25,11 +25,9 @@ public class KotlinWrapperForJavaUsageInfos(
         val javaUsageInfos: Array<UsageInfo>,
         val primaryMethod: PsiElement
 ): UsageInfo(primaryMethod) {
-    override fun hashCode(): Int {
+    override fun hashCode() = javaChangeInfo.method.hashCode()
-        return javaChangeInfo.getMethod().hashCode();
-    }
 
     override fun equals(other: Any?): Boolean {
-        return other === this || (other is KotlinWrapperForJavaUsageInfos && javaChangeInfo.getMethod() == other.javaChangeInfo.getMethod())
+        return other === this || (other is KotlinWrapperForJavaUsageInfos && javaChangeInfo.method == other.javaChangeInfo.method)
     }
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/copy/CopyKotlinFileHandler.kt

@@ -27,7 +27,7 @@ public class CopyKotlinFileHandler : CopyHandlerDelegateBase() {
 
     private fun adjustElements(elements: Array<out PsiElement>): Array<PsiElement>? {
         return elements
-                .map { it.getContainingFile() as? KtFile ?: return null }
+                .map { it.containingFile as? KtFile ?: return null }
                 .toTypedArray()
     }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/inline/KotlinInlineValHandler.kt

@@ -41,9 +41,9 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.shorten.performDelayedShortening
-import org.jetbrains.kotlin.idea.core.refactoring.addTypeArgumentsIfNeeded
+import org.jetbrains.kotlin.idea.refactoring.addTypeArgumentsIfNeeded
-import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
+import org.jetbrains.kotlin.idea.refactoring.checkConflictsInteractively
-import org.jetbrains.kotlin.idea.core.refactoring.getQualifiedTypeArgumentList
+import org.jetbrains.kotlin.idea.refactoring.getQualifiedTypeArgumentList
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.refactoring.move.PackageNameInfo
 import org.jetbrains.kotlin.idea.refactoring.move.lazilyProcessInternalReferencesToUpdateOnPackageNameChange

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

@@ -40,11 +40,11 @@ public abstract class AbstractKotlinInplaceIntroducer<D: KtNamedDeclaration>(
         editor: Editor
 ): AbstractInplaceIntroducer<D, KtExpression>(project, editor, expression, localVariable, occurrences, title, KotlinFileType.INSTANCE) {
     protected fun initFormComponents(init: FormBuilder.() -> Unit) {
-        myWholePanel.setLayout(BorderLayout())
+        myWholePanel.layout = BorderLayout()
 
         with(FormBuilder.createFormBuilder()) {
             init()
-            myWholePanel.add(getPanel(), BorderLayout.CENTER)
+            myWholePanel.add(panel, BorderLayout.CENTER)
         }
     }
 
@@ -52,7 +52,7 @@ public abstract class AbstractKotlinInplaceIntroducer<D: KtNamedDeclaration>(
         myEditor.putUserData(InplaceRefactoring.INTRODUCE_RESTART, true)
         try {
             stopIntroduce(myEditor)
-            myProject.executeWriteCommand(getCommandName(), getCommandName(), action)
+            myProject.executeWriteCommand(commandName, commandName, action)
             // myExprMarker was invalidated by stopIntroduce()
             myExprMarker = myExpr?.let { createMarker(it) }
             startInplaceIntroduceTemplate()
@@ -70,7 +70,7 @@ public abstract class AbstractKotlinInplaceIntroducer<D: KtNamedDeclaration>(
             marker: RangeMarker,
             exprText: String?
     ): KtExpression? {
-        if (exprText == null || !declaration.isValid()) return null
+        if (exprText == null || !declaration.isValid) return null
 
         val leaf = containingFile.findElementAt(marker.startOffset) ?: return null
 

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/KotlinIntroduceHandlerBase.java

@@ -1,22 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.idea.refactoring.introduce;
-
-import com.intellij.refactoring.RefactoringActionHandler;
-
-public abstract class KotlinIntroduceHandlerBase implements RefactoringActionHandler {
-}

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

@@ -22,7 +22,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.refactoring.RefactoringActionHandler
-import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
+import org.jetbrains.kotlin.idea.refactoring.getExtractionContainers
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinExtractFunctionDialog
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -44,7 +44,7 @@ public class ExtractKotlinFunctionHandler(
                 onFinish: (ExtractionResult) -> Unit
         ) {
             KotlinExtractFunctionDialog(descriptorWithConflicts.descriptor.extractionData.project, descriptorWithConflicts) {
-                doRefactor(it.getCurrentConfiguration(), onFinish)
+                doRefactor(it.currentConfiguration, onFinish)
             }.show()
         }
     }
@@ -55,10 +55,10 @@ public class ExtractKotlinFunctionHandler(
             elements: List<PsiElement>,
             targetSibling: PsiElement
     ) {
-        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements
+        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.statements ?: elements
         val extractionData = ExtractionData(file, adjustedElements.toRange(false), targetSibling)
         ExtractionEngine(helper).run(editor, extractionData) {
-            processDuplicates(it.duplicateReplacers, file.getProject(), editor)
+            processDuplicates(it.duplicateReplacers, file.project, editor)
         }
     }
 
@@ -67,7 +67,7 @@ public class ExtractKotlinFunctionHandler(
                 EXTRACT_FUNCTION,
                 editor,
                 file,
-                { elements, parent -> parent.getExtractionContainers(elements.size() == 1, allContainersEnabled) },
+                { elements, parent -> parent.getExtractionContainers(elements.size == 1, allContainersEnabled) },
                 continuation
         )
     }

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

@@ -31,7 +31,7 @@ import org.jetbrains.annotations.NotNull;
 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.JetRefactoringUtilKt;
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle;
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*;
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers;
@@ -101,9 +101,9 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
     }
 
     private boolean checkNames() {
-        if (!KotlinNameSuggester.INSTANCE$.isIdentifier(getFunctionName())) return false;
+        if (!KotlinNameSuggester.INSTANCE.isIdentifier(getFunctionName())) return false;
         for (KotlinParameterTablePanel.ParameterInfo parameterInfo : parameterTablePanel.getParameterInfos()) {
-            if (!KotlinNameSuggester.INSTANCE$.isIdentifier(parameterInfo.getName())) return false;
+            if (!KotlinNameSuggester.INSTANCE.isIdentifier(parameterInfo.getName())) return false;
         }
         return true;
     }
@@ -227,7 +227,7 @@ public class KotlinExtractFunctionDialog extends DialogWrapper {
                     @Override
                     public Unit invoke() {
                         close(OK_EXIT_CODE);
-                        return Unit.INSTANCE$;
+                        return Unit.INSTANCE;
                     }
                 },
                 new Function0<Unit>() {

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

@@ -25,7 +25,7 @@ import com.intellij.ui.table.JBTable;
 import com.intellij.util.Function;
 import com.intellij.util.ui.AbstractTableCellEditor;
 import com.intellij.util.ui.EditableModel;
-import kotlin.CollectionsKt;
+import kotlin.collections.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
@@ -110,7 +110,9 @@ public class KotlinParameterTablePanel extends JPanel {
     public void init(@Nullable Parameter receiver, @NotNull List<Parameter> parameters) {
         parameterInfos = CollectionsKt.mapTo(
                 parameters,
-                receiver != null ? CollectionsKt.arrayListOf(new ParameterInfo(receiver, true)) : new ArrayList<ParameterInfo>(),
+                receiver != null
+                ? CollectionsKt.arrayListOf(new ParameterInfo(receiver, true))
+                : new ArrayList<ParameterInfo>(),
                 new Function1<Parameter, ParameterInfo>() {
                     @Override
                     public ParameterInfo invoke(Parameter parameter) {
@@ -345,7 +347,7 @@ public class KotlinParameterTablePanel extends JPanel {
                 }
                 case PARAMETER_NAME_COLUMN: {
                     String name = (String) aValue;
-                    if (KotlinNameSuggester.INSTANCE$.isIdentifier(name)) {
+                    if (KotlinNameSuggester.INSTANCE.isIdentifier(name)) {
                         info.setName(name);
                     }
                     updateSignature();

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

@@ -28,8 +28,6 @@ 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.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.*
 import org.jetbrains.kotlin.idea.references.KtSimpleNameReference.ShorteningMode
 import org.jetbrains.kotlin.idea.references.mainReference
@@ -85,10 +83,10 @@ class RenameReplacement(override val parameter: Parameter): ParameterReplacement
     override fun copy(parameter: Parameter) = RenameReplacement(parameter)
 
     override fun invoke(descriptor: ExtractableCodeDescriptor, e: KtElement): KtElement {
-        var expressionToReplace = (e.getParent() as? KtThisExpression ?: e).let { it.getQualifiedExpressionForSelector() ?: it }
+        var expressionToReplace = (e.parent as? KtThisExpression ?: e).let { it.getQualifiedExpressionForSelector() ?: it }
         val parameterName = KtPsiUtil.unquoteIdentifier(parameter.nameForRef)
         val replacingName =
-                if (e.getText().startsWith('`') || !KotlinNameSuggester.isIdentifier(parameterName)) "`$parameterName`" else parameterName
+                if (e.text.startsWith('`') || !KotlinNameSuggester.isIdentifier(parameterName)) "`$parameterName`" else parameterName
         val psiFactory = KtPsiFactory(e)
         val replacement = when {
             parameter == descriptor.receiverParameter -> psiFactory.createExpression("this")
@@ -137,13 +135,13 @@ class AddPrefixReplacement(override val parameter: Parameter): ParameterReplacem
 
 class FqNameReplacement(val fqName: FqName): Replacement {
     override fun invoke(descriptor: ExtractableCodeDescriptor, e: KtElement): KtElement {
-        val thisExpr = e.getParent() as? KtThisExpression
+        val thisExpr = e.parent as? KtThisExpression
         if (thisExpr != null) {
             return thisExpr.replaced(KtPsiFactory(e).createExpression(fqName.asString())).getQualifiedElementSelector()!!
         }
 
         val newExpr = (e as? KtSimpleNameExpression)?.mainReference?.bindToFqName(fqName, ShorteningMode.NO_SHORTENING) as KtElement
-        return if (newExpr is KtQualifiedExpression) newExpr.getSelectorExpression()!! else newExpr
+        return if (newExpr is KtQualifiedExpression) newExpr.selectorExpression!! else newExpr
     }
 }
 
@@ -201,11 +199,11 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
     protected fun extractArgumentExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression? {
         val call: KtCallExpression? = when (boxedExpression) {
             is KtCallExpression -> boxedExpression
-            is KtQualifiedExpression -> boxedExpression.getSelectorExpression() as? KtCallExpression
+            is KtQualifiedExpression -> boxedExpression.selectorExpression as? KtCallExpression
             else -> null
         }
-        val arguments = call?.getValueArguments()
+        val arguments = call?.valueArguments
-        if (arguments == null || arguments.size() <= index) return null
+        if (arguments == null || arguments.size <= index) return null
 
         return arguments[index].getArgumentExpression()
     }
@@ -224,7 +222,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             val module: ModuleDescriptor
     ) : OutputValueBoxer(outputValues) {
         init {
-            assert(outputValues.size() <= 3) { "At most 3 output values are supported" }
+            assert(outputValues.size <= 3) { "At most 3 output values are supported" }
         }
 
         companion object {
@@ -233,7 +231,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
 
         override val returnType: KotlinType by lazy {
             fun getType(): KotlinType {
-                val boxingClass = when (outputValues.size()) {
+                val boxingClass = when (outputValues.size) {
                     1 -> return outputValues.first().valueType
                     2 -> module.resolveTopLevelClass(FqName("kotlin.Pair"), NoLookupLocation.FROM_IDE)!!
                     3 -> module.resolveTopLevelClass(FqName("kotlin.Triple"), NoLookupLocation.FROM_IDE)!!
@@ -245,7 +243,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             getType()
         }
 
-        override val boxingRequired: Boolean = outputValues.size() > 1
+        override val boxingRequired: Boolean = outputValues.size > 1
 
         override fun getBoxingExpressionPattern(arguments: List<KtExpression>): String? {
             return when (arguments.size) {
@@ -259,12 +257,12 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
         }
 
         override fun extractExpressionByIndex(boxedExpression: KtExpression, index: Int): KtExpression? {
-            if (outputValues.size() == 1) return boxedExpression
+            if (outputValues.size == 1) return boxedExpression
             return extractArgumentExpressionByIndex(boxedExpression, index)
         }
 
         override fun getUnboxingExpressions(boxedText: String): Map<OutputValue, String> {
-            return when (outputValues.size()) {
+            return when (outputValues.size) {
                 0 -> Collections.emptyMap()
                 1 -> Collections.singletonMap(outputValues.first(), boxedText)
                 else -> {
@@ -285,7 +283,7 @@ abstract class OutputValueBoxer(val outputValues: List<OutputValue>) {
             )
         }
 
-        override val boxingRequired: Boolean = outputValues.size() > 0
+        override val boxingRequired: Boolean = outputValues.size > 0
 
         override fun getBoxingExpressionPattern(arguments: List<KtExpression>): String? {
             if (arguments.isEmpty()) return null
@@ -311,15 +309,15 @@ data class ControlFlow(
     val outputValueBoxer = boxerFactory(outputValues)
 
     val defaultOutputValue: ExpressionValue? = with(outputValues.filterIsInstance<ExpressionValue>()) {
-        if (size() > 1) throw IllegalArgumentException("Multiple expression values: ${outputValues.joinToString()}") else firstOrNull()
+        if (size > 1) throw IllegalArgumentException("Multiple expression values: ${outputValues.joinToString()}") else firstOrNull()
     }
 
     val jumpOutputValue: Jump? = with(outputValues.filterIsInstance<Jump>()) {
-        val jumpCount = size()
+        val jumpCount = size
         when {
             isEmpty() ->
                 null
-            outputValues.size() > jumpCount || jumpCount > 1 ->
+            outputValues.size > jumpCount || jumpCount > 1 ->
                 throw IllegalArgumentException("Jump values must be the only value if it's present: ${outputValues.joinToString()}")
             else ->
                 first()
@@ -336,7 +334,7 @@ val ControlFlow.possibleReturnTypes: List<KotlinType>
             returnType.isAnnotatedNotNull() || returnType.isAnnotatedNullable() ->
                 listOf(approximateFlexibleTypes(returnType))
             else ->
-                returnType.getCapability(javaClass<Flexibility>()).let { listOf(it!!.upperBound, it.lowerBound) }
+                returnType.getCapability(Flexibility::class.java).let { listOf(it!!.upperBound, it.lowerBound) }
         }
     }
 
@@ -457,7 +455,7 @@ enum class ExtractionTarget(val targetName: String) {
             if (!descriptor.parameters.isEmpty()) return false
             if (descriptor.returnType.isUnit()) return false
 
-            val parent = descriptor.extractionData.targetSibling.getParent()
+            val parent = descriptor.extractionData.targetSibling.parent
             return (parent is KtFile || parent is KtClassBody)
         }
     }
@@ -476,7 +474,7 @@ data class ExtractionGeneratorOptions(
         val delayInitialOccurrenceReplacement: Boolean = false
 ) {
     companion object {
-        val DEFAULT = ExtractionGeneratorOptions()
+        @JvmField val DEFAULT = ExtractionGeneratorOptions()
     }
 }
 

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

@@ -28,7 +28,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.codeInsight.KotlinFileReferencesResolver
 import org.jetbrains.kotlin.idea.core.compareDescriptors
-import org.jetbrains.kotlin.idea.core.refactoring.getContextForContainingDeclarationBody
+import org.jetbrains.kotlin.idea.refactoring.getContextForContainingDeclarationBody
 import org.jetbrains.kotlin.idea.refactoring.introduce.ExtractableSubstringInfo
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractableSubstringInfo
 import org.jetbrains.kotlin.idea.refactoring.introduce.substringContextOrThis

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

@@ -24,7 +24,7 @@ import com.intellij.openapi.ui.popup.Balloon
 import com.intellij.openapi.ui.popup.JBPopupFactory
 import com.intellij.refactoring.BaseRefactoringProcessor
 import com.intellij.ui.awt.RelativePoint
-import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
+import org.jetbrains.kotlin.idea.refactoring.checkConflictsInteractively
 import org.jetbrains.kotlin.idea.refactoring.introduce.showErrorHint
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import javax.swing.event.HyperlinkEvent
@@ -56,7 +56,7 @@ public class ExtractionEngine(
 
         val analysisResult = helper.adjustExtractionData(extractionData).performAnalysis()
 
-        if (ApplicationManager.getApplication()!!.isUnitTestMode() && analysisResult.status != AnalysisResult.Status.SUCCESS) {
+        if (ApplicationManager.getApplication()!!.isUnitTestMode && analysisResult.status != AnalysisResult.Status.SUCCESS) {
             throw BaseRefactoringProcessor.ConflictsInTestsException(analysisResult.messages.map { it.renderMessage() })
         }
 
@@ -83,15 +83,15 @@ public class ExtractionEngine(
 
             AnalysisResult.Status.NON_CRITICAL_ERROR -> {
                 val anchorPoint = RelativePoint(
-                        editor.getContentComponent(),
+                        editor.contentComponent,
-                        editor.visualPositionToXY(editor.getSelectionModel().getSelectionStartPosition()!!)
+                        editor.visualPositionToXY(editor.selectionModel.selectionStartPosition!!)
                 )
                 JBPopupFactory.getInstance()!!
                         .createHtmlTextBalloonBuilder(
                                 "$message<br/><br/><a href=\"EXTRACT\">Proceed with extraction</a>",
                                 MessageType.WARNING,
                                 { event ->
-                                    if (event?.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+                                    if (event?.eventType == HyperlinkEvent.EventType.ACTIVATED) {
                                         validateAndRefactor()
                                     }
                                 }

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

@@ -40,24 +40,24 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.getPhysicalTextRange
 public fun KotlinPsiRange.highlight(project: Project, editor: Editor): RangeHighlighter? {
     val textRange = getPhysicalTextRange()
     val highlighters = ArrayList<RangeHighlighter>()
-    val attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES)!!
+    val attributes = EditorColorsManager.getInstance().globalScheme.getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES)!!
     HighlightManager.getInstance(project).addRangeHighlight(
-            editor, textRange.getStartOffset(), textRange.getEndOffset(), attributes, true, highlighters
+            editor, textRange.startOffset, textRange.endOffset, attributes, true, highlighters
     )
     return highlighters.firstOrNull()
 }
 
 public fun KotlinPsiRange.preview(project: Project, editor: Editor): RangeHighlighter? {
     return highlight(project, editor)?.let {
-        val startOffset = getPhysicalTextRange().getStartOffset()
+        val startOffset = getPhysicalTextRange().startOffset
         val foldedRegions =
                 CodeFoldingManager.getInstance(project)
                         .getFoldRegionsAtOffset(editor, startOffset)
-                        .filter { !it.isExpanded() }
+                        .filter { !it.isExpanded }
         if (!foldedRegions.isEmpty()) {
-            editor.getFoldingModel().runBatchFoldingOperation { foldedRegions.forEach { it.setExpanded(true) } }
+            editor.foldingModel.runBatchFoldingOperation { foldedRegions.forEach { it.isExpanded = true } }
         }
-        editor.getScrollingModel().scrollTo(editor.offsetToLogicalPosition(startOffset), ScrollType.MAKE_VISIBLE)
+        editor.scrollingModel.scrollTo(editor.offsetToLogicalPosition(startOffset), ScrollType.MAKE_VISIBLE)
 
         it
     }
@@ -68,22 +68,22 @@ public fun processDuplicates(
         project: Project,
         editor: Editor
 ) {
-    val size = duplicateReplacers.size()
+    val size = duplicateReplacers.size
     if (size == 0) return
 
     if (size == 1) {
-        duplicateReplacers.keySet().first().preview(project, editor)
+        duplicateReplacers.keys.first().preview(project, editor)
     }
 
-    val answer = if (ApplicationManager.getApplication()!!.isUnitTestMode())
+    val answer = if (ApplicationManager.getApplication()!!.isUnitTestMode)
         Messages.YES
     else
         Messages.showYesNoDialog(
                 project,
                 KotlinRefactoringBundle.message(
                         "0.has.detected.1.code.fragments.in.this.file.that.can.be.replaced.with.a.call.to.extracted.declaration",
-                        ApplicationNamesInfo.getInstance().getProductName(),
+                        ApplicationNamesInfo.getInstance().productName,
-                        duplicateReplacers.size()
+                        duplicateReplacers.size
                 ),
                 "Process Duplicates",
                 Messages.getQuestionIcon()
@@ -93,16 +93,16 @@ public fun processDuplicates(
     var showAll = false
 
     duplicateReplacersLoop@
-    for ((i, entry) in duplicateReplacers.entrySet().withIndex()) {
+    for ((i, entry) in duplicateReplacers.entries.withIndex()) {
         val (pattern, replacer) = entry
         if (!pattern.isValid()) continue
 
         val highlighter = pattern.preview(project, editor)
-        if (!ApplicationManager.getApplication()!!.isUnitTestMode()) {
+        if (!ApplicationManager.getApplication()!!.isUnitTestMode) {
             if (size > 1 && !showAll) {
                 val promptDialog = ReplacePromptDialog(false, RefactoringBundle.message("process.duplicates.title", i + 1, size), project)
                 promptDialog.show()
-                when(promptDialog.getExitCode()) {
+                when(promptDialog.exitCode) {
                     FindManager.PromptResult.ALL -> showAll = true
                     FindManager.PromptResult.SKIP -> continue@duplicateReplacersLoop
                     FindManager.PromptResult.CANCEL -> return
@@ -117,6 +117,6 @@ public fun processDuplicates(
 
 public fun processDuplicatesSilently(duplicateReplacers: Map<KotlinPsiRange, () -> Unit>, project: Project) {
     project.executeWriteCommand(MethodDuplicatesHandler.REFACTORING_NAME) {
-        duplicateReplacers.values().forEach { it() }
+        duplicateReplacers.values.forEach { it() }
     }
 }

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

@@ -45,7 +45,7 @@ import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 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.createTempCopy
 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

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

@@ -25,8 +25,8 @@ import com.intellij.refactoring.BaseRefactoringProcessor
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.core.*
-import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine
+import org.jetbrains.kotlin.idea.refactoring.isMultiLine
-import org.jetbrains.kotlin.idea.core.refactoring.removeTemplateEntryBracesIfPossible
+import org.jetbrains.kotlin.idea.refactoring.removeTemplateEntryBracesIfPossible
 import org.jetbrains.kotlin.idea.intentions.ConvertToExpressionBodyIntention
 import org.jetbrains.kotlin.idea.intentions.InfixCallToOrdinaryIntention
 import org.jetbrains.kotlin.idea.intentions.OperatorToFunctionIntention

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

@@ -30,7 +30,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 import com.intellij.ui.JBColor
 import com.intellij.ui.NonFocusableCheckBox
-import org.jetbrains.kotlin.idea.core.refactoring.createPrimaryConstructorParameterListIfAbsent
+import org.jetbrains.kotlin.idea.refactoring.createPrimaryConstructorParameterListIfAbsent
 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
@@ -65,22 +65,22 @@ public class KotlinInplaceParameterIntroducer(
         editor
 ) {
     companion object {
-        private val LOG = Logger.getInstance(javaClass<KotlinInplaceParameterIntroducer>())
+        private val LOG = Logger.getInstance(KotlinInplaceParameterIntroducer::class.java)
     }
 
     enum class PreviewDecorator {
         FOR_ADD() {
             override val textAttributes: TextAttributes = with(TextAttributes()) {
-                setEffectType(EffectType.ROUNDED_BOX)
+                effectType = EffectType.ROUNDED_BOX
-                setEffectColor(JBColor.RED)
+                effectColor = JBColor.RED
                 this
             }
         },
 
         FOR_REMOVAL() {
             override val textAttributes: TextAttributes = with(TextAttributes()) {
-                setEffectType(EffectType.STRIKEOUT)
+                effectType = EffectType.STRIKEOUT
-                setEffectColor(Color.BLACK)
+                effectColor = Color.BLACK
                 this
             }
         };
@@ -88,8 +88,8 @@ public class KotlinInplaceParameterIntroducer(
         protected abstract val textAttributes: TextAttributes
 
         fun applyToRange(range: TextRange, markupModel: MarkupModel) {
-            markupModel.addRangeHighlighter(range.getStartOffset(),
+            markupModel.addRangeHighlighter(range.startOffset,
-                                            range.getEndOffset(),
+                                            range.endOffset,
                                             0,
                                             textAttributes,
                                             HighlighterTargetArea.EXACT_RANGE
@@ -110,23 +110,23 @@ public class KotlinInplaceParameterIntroducer(
 
         init {
             val templateState = TemplateManagerImpl.getTemplateState(myEditor)
-            val currentType = if (templateState != null && templateState.getTemplate() != null) {
+            val currentType = if (templateState != null && templateState.template != null) {
                 templateState
                         .getVariableValue(KotlinInplaceVariableIntroducer.TYPE_REFERENCE_VARIABLE_NAME)
-                        ?.getText()
+                        ?.text
             } else null
 
             val builder = StringBuilder()
 
             with(descriptor) {
-                (callable as? KtFunction)?.getReceiverTypeReference()?.let { receiverTypeRef ->
+                (callable as? KtFunction)?.receiverTypeReference?.let { receiverTypeRef ->
-                    builder.append(receiverTypeRef.getText()).append('.')
+                    builder.append(receiverTypeRef.text).append('.')
                     if (!descriptor.withDefaultValue && receiverTypeRef in parametersToRemove) {
-                        _rangesToRemove.add(TextRange(0, builder.length()))
+                        _rangesToRemove.add(TextRange(0, builder.length))
                     }
                 }
 
-                builder.append(callable.getName())
+                builder.append(callable.name)
 
                 val parameters = callable.getValueParameters()
                 builder.append("(")
@@ -134,8 +134,8 @@ public class KotlinInplaceParameterIntroducer(
                     val parameter = parameters[i]
 
                     val parameterText = if (parameter == addedParameter){
-                        val parameterName = currentName ?: parameter.getName()
+                        val parameterName = currentName ?: parameter.name
-                        val parameterType = currentType ?: parameter.getTypeReference()!!.getText()
+                        val parameterType = currentType ?: parameter.typeReference!!.text
                         descriptor = descriptor.copy(newParameterName = parameterName!!, newParameterTypeText = parameterType)
                         val modifier = if (valVar != KotlinValVar.None) "${valVar.keywordName} " else ""
                         val defaultValue = if (withDefaultValue) {
@@ -144,11 +144,11 @@ public class KotlinInplaceParameterIntroducer(
 
                         "$modifier$parameterName: $parameterType$defaultValue"
                     }
-                    else parameter.getText()
+                    else parameter.text
 
                     builder.append(parameterText)
 
-                    val range = TextRange(builder.length() - parameterText.length(), builder.length())
+                    val range = TextRange(builder.length - parameterText.length, builder.length)
                     if (parameter == addedParameter) {
                         addedRange = range
                     }
@@ -176,21 +176,21 @@ public class KotlinInplaceParameterIntroducer(
 
     init {
         initFormComponents {
-            addComponent(getPreviewComponent())
+            addComponent(previewComponent)
 
             val defaultValueCheckBox = NonFocusableCheckBox("Introduce default value")
-            defaultValueCheckBox.setSelected(descriptor.withDefaultValue)
+            defaultValueCheckBox.isSelected = descriptor.withDefaultValue
             defaultValueCheckBox.setMnemonic('d')
             defaultValueCheckBox.addActionListener {
-                descriptor = descriptor.copy(withDefaultValue = defaultValueCheckBox.isSelected())
+                descriptor = descriptor.copy(withDefaultValue = defaultValueCheckBox.isSelected)
-                updateTitle(getVariable())
+                updateTitle(variable)
             }
             addComponent(defaultValueCheckBox)
 
-            val occurrenceCount = descriptor.occurrencesToReplace.size()
+            val occurrenceCount = descriptor.occurrencesToReplace.size
             if (occurrenceCount > 1) {
                 val replaceAllCheckBox = NonFocusableCheckBox("Replace all occurrences ($occurrenceCount)")
-                replaceAllCheckBox.setSelected(true)
+                replaceAllCheckBox.isSelected = true
                 replaceAllCheckBox.setMnemonic('R')
                 addComponent(replaceAllCheckBox)
                 this@KotlinInplaceParameterIntroducer.replaceAllCheckBox = replaceAllCheckBox
@@ -218,15 +218,15 @@ public class KotlinInplaceParameterIntroducer(
     }
 
     override fun deleteTemplateField(psiField: KtParameter) {
-        if (psiField.isValid()) {
+        if (psiField.isValid) {
-            (psiField.getParent() as? KtParameterList)?.removeParameter(psiField)
+            (psiField.parent as? KtParameterList)?.removeParameter(psiField)
         }
     }
 
-    override fun isReplaceAllOccurrences() = replaceAllCheckBox?.isSelected() ?: true
+    override fun isReplaceAllOccurrences() = replaceAllCheckBox?.isSelected ?: true
 
     override fun setReplaceAllOccurrences(allOccurrences: Boolean) {
-        replaceAllCheckBox?.setSelected(allOccurrences)
+        replaceAllCheckBox?.isSelected = allOccurrences
     }
 
     override fun getComponent() = myWholePanel
@@ -234,7 +234,7 @@ public class KotlinInplaceParameterIntroducer(
     override fun updateTitle(addedParameter: KtParameter?, currentName: String?) {
         val preview = Preview(addedParameter, currentName)
 
-        val document = getPreviewEditor().getDocument()
+        val document = previewEditor.document
         runWriteAction { document.setText(preview.text) }
 
         val markupModel = DocumentMarkupModel.forDocument(document, myProject, true)
@@ -255,15 +255,15 @@ public class KotlinInplaceParameterIntroducer(
     }
 
     override fun performIntroduce() {
-        getDescriptorToRefactor(isReplaceAllOccurrences()).performRefactoring()
+        getDescriptorToRefactor(isReplaceAllOccurrences).performRefactoring()
     }
 
     private fun getDescriptorToRefactor(replaceAll: Boolean): IntroduceParameterDescriptor {
-        val originalRange = getExpr().toRange()
+        val originalRange = expr.toRange()
         return descriptor.copy(
                 originalRange = originalRange,
-                occurrencesToReplace = if (replaceAll) getOccurrences().map { it.toRange() } else originalRange.singletonList(),
+                occurrencesToReplace = if (replaceAll) occurrences.map { it.toRange() } else originalRange.singletonList(),
-                argumentValue = getExpr()!!
+                argumentValue = expr!!
         )
     }
 

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

@@ -27,9 +27,9 @@ import com.intellij.ui.NonFocusableCheckBox
 import com.intellij.usageView.BaseUsageViewDescriptor
 import com.intellij.usageView.UsageInfo
 import org.jetbrains.kotlin.idea.KotlinFileType
-import org.jetbrains.kotlin.idea.core.refactoring.isMultiLine
+import org.jetbrains.kotlin.idea.refactoring.isMultiLine
-import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
+import org.jetbrains.kotlin.idea.refactoring.runRefactoringWithPostprocessing
-import org.jetbrains.kotlin.idea.core.refactoring.validateElement
+import org.jetbrains.kotlin.idea.refactoring.validateElement
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinExtractFunctionDialog
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractFunction.ui.KotlinParameterTablePanel
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
@@ -86,25 +86,25 @@ public class KotlinIntroduceParameterDialog private constructor(
     private val typeField = NameSuggestionsField(typeNameSuggestions, project, KotlinFileType.INSTANCE)
     private var replaceAllCheckBox: JCheckBox? = null
     private var defaultValueCheckBox: JCheckBox? = null
-    private val removeParamsCheckBoxes = LinkedHashMap<JCheckBox, KtElement>(descriptor.parametersToRemove.size())
+    private val removeParamsCheckBoxes = LinkedHashMap<JCheckBox, KtElement>(descriptor.parametersToRemove.size)
     private var parameterTablePanel: KotlinParameterTablePanel? = null
     private val commandName = if (lambdaExtractionDescriptor != null) INTRODUCE_LAMBDA_PARAMETER else INTRODUCE_PARAMETER
 
     init {
-        setTitle(commandName)
+        title = commandName
         init()
 
         nameField.addDataChangedListener { validateButtons() }
         typeField.addDataChangedListener { validateButtons() }
     }
 
-    override fun getPreferredFocusedComponent() = nameField.getFocusableComponent()
+    override fun getPreferredFocusedComponent() = nameField.focusableComponent
 
     private fun updateRemoveParamCheckBoxes() {
-        val enableParamRemove = (replaceAllCheckBox?.isSelected() ?: true) && (!defaultValueCheckBox!!.isSelected())
+        val enableParamRemove = (replaceAllCheckBox?.isSelected ?: true) && (!defaultValueCheckBox!!.isSelected)
-        removeParamsCheckBoxes.keySet().forEach {
+        removeParamsCheckBoxes.keys.forEach {
-            it.setEnabled(enableParamRemove)
+            it.isEnabled = enableParamRemove
-            it.setSelected(enableParamRemove)
+            it.isSelected = enableParamRemove
         }
     }
 
@@ -124,7 +124,7 @@ public class KotlinIntroduceParameterDialog private constructor(
         gbConstraints.gridy = 0
         val nameLabel = JLabel("Parameter name: ")
         nameLabel.setDisplayedMnemonic('n')
-        nameLabel.setLabelFor(nameField)
+        nameLabel.labelFor = nameField
         panel.add(nameLabel, gbConstraints)
 
         gbConstraints.insets = Insets(4, 4, 4, 8)
@@ -141,7 +141,7 @@ public class KotlinIntroduceParameterDialog private constructor(
         gbConstraints.fill = GridBagConstraints.NONE
         val typeLabel = JLabel(if (lambdaExtractionDescriptor != null) "Lambda return type" else "Parameter type: ")
         typeLabel.setDisplayedMnemonic('t')
-        typeLabel.setLabelFor(typeField)
+        typeLabel.labelFor = typeField
         panel.add(typeLabel, gbConstraints)
 
         gbConstraints.gridx++
@@ -171,7 +171,7 @@ public class KotlinIntroduceParameterDialog private constructor(
             gbConstraints.fill = GridBagConstraints.NONE
             val parametersLabel = JLabel("Lambda parameters: ")
             parametersLabel.setDisplayedMnemonic('p')
-            parametersLabel.setLabelFor(parameterTablePanel)
+            parametersLabel.labelFor = parameterTablePanel
             panel.add(parametersLabel, gbConstraints)
 
             gbConstraints.gridx++
@@ -190,19 +190,19 @@ public class KotlinIntroduceParameterDialog private constructor(
         gbConstraints.gridy++
 
         val defaultValueCheckBox = NonFocusableCheckBox("Introduce default value")
-        defaultValueCheckBox.setSelected(descriptor.withDefaultValue)
+        defaultValueCheckBox.isSelected = descriptor.withDefaultValue
         defaultValueCheckBox.setMnemonic('d')
         defaultValueCheckBox.addActionListener { updateRemoveParamCheckBoxes() }
         panel.add(defaultValueCheckBox, gbConstraints)
 
         this.defaultValueCheckBox = defaultValueCheckBox
 
-        val occurrenceCount = descriptor.occurrencesToReplace.size()
+        val occurrenceCount = descriptor.occurrencesToReplace.size
 
         if (occurrenceCount > 1) {
             gbConstraints.gridy++
             val replaceAllCheckBox = NonFocusableCheckBox("Replace all occurrences ($occurrenceCount)")
-            replaceAllCheckBox.setSelected(true)
+            replaceAllCheckBox.isSelected = true
             replaceAllCheckBox.setMnemonic('R')
             replaceAllCheckBox.addActionListener { updateRemoveParamCheckBoxes() }
             panel.add(replaceAllCheckBox, gbConstraints)
@@ -214,11 +214,11 @@ public class KotlinIntroduceParameterDialog private constructor(
         }
 
         for (parameter in descriptor.parametersToRemove) {
-            val removeWhat = if (parameter is KtParameter) "parameter '${parameter.getName()}'" else "receiver"
+            val removeWhat = if (parameter is KtParameter) "parameter '${parameter.name}'" else "receiver"
             val cb = NonFocusableCheckBox("Remove $removeWhat no longer used")
 
             removeParamsCheckBoxes[cb] = parameter
-            cb.setSelected(true)
+            cb.isSelected = true
             gbConstraints.gridy++
             panel.add(cb, gbConstraints)
         }
@@ -230,8 +230,8 @@ public class KotlinIntroduceParameterDialog private constructor(
 
     override fun canRun() {
         val psiFactory = KtPsiFactory(myProject)
-        psiFactory.createSimpleName(nameField.getEnteredName()).validateElement("Invalid parameter name")
+        psiFactory.createSimpleName(nameField.enteredName).validateElement("Invalid parameter name")
-        psiFactory.createType(typeField.getEnteredName()).validateElement("Invalid parameter type")
+        psiFactory.createType(typeField.enteredName).validateElement("Invalid parameter type")
     }
 
     override fun doAction() {
@@ -245,19 +245,19 @@ public class KotlinIntroduceParameterDialog private constructor(
 
                     override fun performRefactoring(usages: Array<out UsageInfo>) {
                         fun createLambdaForArgument(function: KtFunction): KtExpression {
-                            val statement = (function.getBodyExpression() as KtBlockExpression).getStatements().single()
+                            val statement = (function.bodyExpression as KtBlockExpression).statements.single()
                             val space = if (statement.isMultiLine()) "\n" else " "
-                            val parameters = function.getValueParameters()
+                            val parameters = function.valueParameters
                             val parametersText = if (parameters.isNotEmpty()) {
-                                " " + parameters.map { it.getName() }.joinToString() + " ->"
+                                " " + parameters.map { it.name }.joinToString() + " ->"
                             } else ""
-                            val text = "{$parametersText$space${statement.getText()}$space}"
+                            val text = "{$parametersText$space${statement.text}$space}"
 
                             return KtPsiFactory(myProject).createExpression(text)
                         }
 
-                        val chosenName = nameField.getEnteredName()
+                        val chosenName = nameField.enteredName
-                        var chosenType = typeField.getEnteredName()
+                        var chosenType = typeField.enteredName
                         var newArgumentValue = descriptor.newArgumentValue
                         var newReplacer = descriptor.occurrenceReplacer
 
@@ -268,8 +268,8 @@ public class KotlinIntroduceParameterDialog private constructor(
                                     oldDescriptor,
                                     chosenName,
                                     "",
-                                    parameterTablePanel?.getReceiverInfo(),
+                                    parameterTablePanel?.receiverInfo,
-                                    parameterTablePanel?.getParameterInfos() ?: listOf(),
+                                    parameterTablePanel?.parameterInfos ?: listOf(),
                                     null
                             )
                             val options = ExtractionGeneratorOptions.DEFAULT.copy(
@@ -278,12 +278,12 @@ public class KotlinIntroduceParameterDialog private constructor(
                             )
                             with (ExtractionGeneratorConfiguration(newDescriptor, options).generateDeclaration()) {
                                 val function = declaration as KtFunction
-                                val receiverType = function.getReceiverTypeReference()?.getText()
+                                val receiverType = function.receiverTypeReference?.text
                                 val parameterTypes = function
-                                        .getValueParameters()
+                                        .valueParameters
-                                        .map { it.getTypeReference()!!.getText() }
+                                        .map { it.typeReference!!.text }
                                         .joinToString()
-                                val returnType = function.getTypeReference()?.getText() ?: "Unit"
+                                val returnType = function.typeReference?.text ?: "Unit"
 
                                 chosenType = (receiverType?.let { "$it." } ?: "") + "($parameterTypes) -> $returnType"
                                 newArgumentValue = createLambdaForArgument(function)
@@ -297,16 +297,16 @@ public class KotlinIntroduceParameterDialog private constructor(
                                 newParameterName = chosenName,
                                 newParameterTypeText = chosenType,
                                 argumentValue = newArgumentValue,
-                                withDefaultValue = defaultValueCheckBox!!.isSelected(),
+                                withDefaultValue = defaultValueCheckBox!!.isSelected,
                                 occurrencesToReplace = with(descriptor) {
-                                    if (replaceAllCheckBox?.isSelected() ?: true) {
+                                    if (replaceAllCheckBox?.isSelected ?: true) {
                                         occurrencesToReplace
                                     }
                                     else {
                                         Collections.singletonList(originalOccurrence)
                                     }
                                 },
-                                parametersToRemove = removeParamsCheckBoxes.filter { it.key.isEnabled() && it.key.isSelected() }.map { it.value },
+                                parametersToRemove = removeParamsCheckBoxes.filter { it.key.isEnabled && it.key.isSelected }.map { it.value },
                                 occurrenceReplacer = newReplacer
                         )
 

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

@@ -25,6 +25,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiFile
 import com.intellij.psi.search.searches.ReferencesSearch
 import com.intellij.psi.util.PsiTreeUtil
+import com.intellij.refactoring.RefactoringActionHandler
 import com.intellij.refactoring.introduce.inplace.AbstractInplaceIntroducer
 import com.intellij.refactoring.listeners.RefactoringEventListener
 import com.intellij.util.SmartList
@@ -38,8 +39,8 @@ import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
 import org.jetbrains.kotlin.idea.core.NewDeclarationNameValidator
 import org.jetbrains.kotlin.idea.core.moveInsideParenthesesAndReplaceWith
-import org.jetbrains.kotlin.idea.core.refactoring.removeTemplateEntryBracesIfPossible
+import org.jetbrains.kotlin.idea.refactoring.removeTemplateEntryBracesIfPossible
-import org.jetbrains.kotlin.idea.core.refactoring.runRefactoringWithPostprocessing
+import org.jetbrains.kotlin.idea.refactoring.runRefactoringWithPostprocessing
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
@@ -96,11 +97,11 @@ public data class IntroduceParameterDescriptor(
         valVar = if (callable is KtClass) {
             val modifierIsUnnecessary: (PsiElement) -> Boolean = {
                 when {
-                    it.getParent() != callable.getBody() ->
+                    it.parent != callable.getBody() ->
                         false
                     it is KtAnonymousInitializer ->
                         true
-                    it is KtProperty && it.getInitializer()?.getTextRange()?.intersects(originalRange.getTextRange()) ?: false ->
+                    it is KtProperty && it.initializer?.textRange?.intersects(originalRange.getTextRange()) ?: false ->
                         true
                     else ->
                         false
@@ -125,7 +126,7 @@ fun getParametersToRemove(
     return parametersUsages.entrySet()
             .filter {
                 it.value.all { paramUsage ->
-                    occurrenceRanges.any { occurrenceRange -> occurrenceRange.contains(paramUsage.getTextRange()) }
+                    occurrenceRanges.any { occurrenceRange -> occurrenceRange.contains(paramUsage.textRange) }
                 }
             }
             .map { it.key }
@@ -163,14 +164,14 @@ fun IntroduceParameterDescriptor.performRefactoring() {
             override fun performSilently(affectedFunctions: Collection<PsiElement>): Boolean = true
         }
 
-        val project = callable.getProject();
+        val project = callable.project;
         val changeSignature = { runChangeSignature(project, callableDescriptor, config, callable, INTRODUCE_PARAMETER) }
         changeSignature.runRefactoringWithPostprocessing(project, "refactoring.changeSignature") {
             try {
                 occurrencesToReplace.forEach { occurrenceReplacer(it) }
             }
             finally {
-                project.getMessageBus()
+                project.messageBus
                         .syncPublisher(RefactoringEventListener.REFACTORING_EVENT_TOPIC)
                         .refactoringDone(INTRODUCE_PARAMETER_REFACTORING_ID, null)
             }
@@ -198,7 +199,7 @@ fun selectNewParameterContext(
                 (if (stopAt != null) parent.parents.takeWhile { it != stopAt } else parents)
                         .filter {
                             ((it is KtClass && !it.isInterface() && it !is KtEnumEntry) || it is KtNamedFunction || it is KtSecondaryConstructor) &&
-                            ((it as KtNamedDeclaration).getValueParameterList() != null || it.getNameIdentifier() != null)
+                            ((it as KtNamedDeclaration).getValueParameterList() != null || it.nameIdentifier != null)
                         }
                         .toList()
             },
@@ -214,7 +215,7 @@ public interface KotlinIntroduceParameterHelper {
 
 public open class KotlinIntroduceParameterHandler(
         val helper: KotlinIntroduceParameterHelper = KotlinIntroduceParameterHelper.Default
-): KotlinIntroduceHandlerBase() {
+): RefactoringActionHandler {
     open fun invoke(project: Project, editor: Editor, expression: KtExpression, targetParent: KtNamedDeclaration) {
         val physicalExpression = expression.substringContextOrThis
         if (physicalExpression is KtProperty && physicalExpression.isLocal && physicalExpression.nameIdentifier == null) {
@@ -250,7 +251,7 @@ public open class KotlinIntroduceParameterHandler(
         val replacementType = expressionType.approximateWithResolvableType(targetParent.getResolutionScope(context, targetParent.getResolutionFacade()), false)
 
         val body = when (targetParent) {
-                       is KtFunction -> targetParent.getBodyExpression()
+                       is KtFunction -> targetParent.bodyExpression
                        is KtClass -> targetParent.getBody()
                        else -> null
                    } ?: throw AssertionError("Body element is not found: ${targetParent.getElementTextWithContext()}")
@@ -267,7 +268,7 @@ public open class KotlinIntroduceParameterHandler(
 
         val forbiddenRanges =
                 if (targetParent is KtClass) {
-                    targetParent.getDeclarations().filter { isObjectOrNonInnerClass(it) }.map { it.getTextRange() }
+                    targetParent.declarations.filter { isObjectOrNonInnerClass(it) }.map { it.textRange }
                 }
                 else {
                     Collections.emptyList()
@@ -298,7 +299,7 @@ public open class KotlinIntroduceParameterHandler(
                 INTRODUCE_PARAMETER,
                 null,
                 fun() {
-                    val isTestMode = ApplicationManager.getApplication().isUnitTestMode()
+                    val isTestMode = ApplicationManager.getApplication().isUnitTestMode
                     val haveLambdaArgumentsToReplace = occurrencesToReplace.any {
                         it.elements.any { it is KtLambdaExpression && it.parent is KtLambdaArgument }
                     }
@@ -347,8 +348,8 @@ public open class KotlinIntroduceParameterHandler(
 
                     if (inplaceIsAvailable) {
                         with(PsiDocumentManager.getInstance(project)) {
-                            commitDocument(editor.getDocument())
+                            commitDocument(editor.document)
-                            doPostponedOperationsAndUnblockDocument(editor.getDocument())
+                            doPostponedOperationsAndUnblockDocument(editor.document)
                         }
 
                         val introducer = KotlinInplaceParameterIntroducer(introduceParameterDescriptor,
@@ -377,7 +378,7 @@ public open class KotlinIntroduceParameterHandler(
 
         if (file !is KtFile) return
         selectNewParameterContext(editor, file) { elements, targetParent ->
-            val expression = ((elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements).singleOrNull()
+            val expression = ((elements.singleOrNull() as? KtBlockExpression)?.statements ?: elements).singleOrNull()
             if (expression is KtExpression) {
                 invoke(project, editor, expression, targetParent as KtNamedDeclaration)
             }
@@ -396,13 +397,10 @@ private fun DeclarationDescriptor?.toFunctionDescriptor(targetParent: KtNamedDec
     val functionDescriptor: FunctionDescriptor? =
             when (this) {
                 is FunctionDescriptor -> this
-                is ClassDescriptor -> this.getUnsubstitutedPrimaryConstructor()
+                is ClassDescriptor -> this.unsubstitutedPrimaryConstructor
                 else -> null
             }
-    if (functionDescriptor == null) {
+    return functionDescriptor ?: throw AssertionError("Unexpected element type: ${targetParent.getElementTextWithContext()}")
-        throw AssertionError("Unexpected element type: ${targetParent.getElementTextWithContext()}")
-    }
-    return functionDescriptor
 }
 
 private fun findInternalUsagesOfParametersAndReceiver(
@@ -413,19 +411,19 @@ private fun findInternalUsagesOfParametersAndReceiver(
     targetParent.getValueParameters()
             .filter { !it.hasValOrVar() }
             .forEach {
-                val paramUsages = ReferencesSearch.search(it).map { it.getElement() as KtElement }
+                val paramUsages = ReferencesSearch.search(it).map { it.element as KtElement }
                 if (paramUsages.isNotEmpty()) {
                     usages.put(it, paramUsages)
                 }
             }
-    val receiverTypeRef = (targetParent as? KtFunction)?.getReceiverTypeReference()
+    val receiverTypeRef = (targetParent as? KtFunction)?.receiverTypeReference
     if (receiverTypeRef != null) {
         targetParent.acceptChildren(
                 object : KtTreeVisitorVoid() {
                     override fun visitThisExpression(expression: KtThisExpression) {
                         super.visitThisExpression(expression)
 
-                        if (expression.getInstanceReference().mainReference.resolve() == targetDescriptor) {
+                        if (expression.instanceReference.mainReference.resolve() == targetDescriptor) {
                             usages.putValue(receiverTypeRef, expression)
                         }
                     }
@@ -436,9 +434,9 @@ private fun findInternalUsagesOfParametersAndReceiver(
                         val bindingContext = element.analyze()
                         val resolvedCall = element.getResolvedCall(bindingContext) ?: return
 
-                        if ((resolvedCall.getExtensionReceiver() as? ImplicitReceiver)?.declarationDescriptor == targetDescriptor ||
+                        if ((resolvedCall.extensionReceiver as? ImplicitReceiver)?.declarationDescriptor == targetDescriptor ||
-                            (resolvedCall.getDispatchReceiver() as? ImplicitReceiver)?.declarationDescriptor == targetDescriptor) {
+                            (resolvedCall.dispatchReceiver as? ImplicitReceiver)?.declarationDescriptor == targetDescriptor) {
-                            usages.putValue(receiverTypeRef, resolvedCall.getCall().getCallElement())
+                            usages.putValue(receiverTypeRef, resolvedCall.call.callElement)
                         }
                     }
                 }
@@ -495,7 +493,7 @@ public open class KotlinIntroduceLambdaParameterHandler(
             }
 
             val dialog = createDialog(project, editor, lambdaExtractionDescriptor)
-            if (ApplicationManager.getApplication()!!.isUnitTestMode()) {
+            if (ApplicationManager.getApplication()!!.isUnitTestMode) {
                 dialog.performRefactoring()
             }
             else {
@@ -507,7 +505,7 @@ public open class KotlinIntroduceLambdaParameterHandler(
     override fun invoke(project: Project, editor: Editor, expression: KtExpression, targetParent: KtNamedDeclaration) {
         val duplicateContainer =
                 when (targetParent) {
-                    is KtFunction -> targetParent.getBodyExpression()
+                    is KtFunction -> targetParent.bodyExpression
                     is KtClass -> targetParent.getBody()
                     else -> null
                 } ?: throw AssertionError("Body element is not found: ${targetParent.getElementTextWithContext()}")

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

@@ -29,8 +29,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 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.dropOverrideKeywordIfNecessary
+import org.jetbrains.kotlin.idea.refactoring.dropOverrideKeywordIfNecessary
-import org.jetbrains.kotlin.idea.core.refactoring.j2k
+import org.jetbrains.kotlin.idea.refactoring.j2k
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.*
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinCallableDefinitionUsage
 import org.jetbrains.kotlin.idea.refactoring.changeSignature.usages.KotlinConstructorDelegationCallUsage
@@ -44,8 +44,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 import java.util.*
 
 public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMethodUsagesProcessor {
-    override fun isMethodUsage(usage: UsageInfo): Boolean = (usage.getElement() as? KtElement)?.let {
+    override fun isMethodUsage(usage: UsageInfo): Boolean = (usage.element as? KtElement)?.let {
-        it.getParentOfTypeAndBranch<KtCallElement>(true) { getCalleeExpression() } != null
+        it.getParentOfTypeAndBranch<KtCallElement>(true) { calleeExpression } != null
     } ?: false
 
     override fun findConflicts(data: IntroduceParameterData, usages: Array<UsageInfo>, conflicts: MultiMap<PsiElement, String>) {
@@ -61,26 +61,26 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
         val changeSignatureData = KotlinChangeSignatureData(psiMethodDescriptor, method, Collections.singletonList(psiMethodDescriptor))
         val changeInfo = KotlinChangeInfo(methodDescriptor = changeSignatureData, context = method)
 
-        data.getParametersToRemove().toNativeArray().sortedDescending().forEach { changeInfo.removeParameter(it) }
+        data.parametersToRemove.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() }
+        val defaultValueForCall = (data.parameterInitializer.expression as? PsiExpression)?.let { it.j2k() }
         changeInfo.addParameter(KotlinParameterInfo(callableDescriptor = psiMethodDescriptor,
-                                                    name = data.getParameterName(),
+                                                    name = data.parameterName,
                                                     originalTypeInfo = KotlinTypeInfo(false, psiMethodDescriptor.builtIns.anyType),
                                                     defaultValueForCall = defaultValueForCall))
         return changeInfo
     }
 
     override fun processChangeMethodSignature(data: IntroduceParameterData, usage: UsageInfo, usages: Array<out UsageInfo>): Boolean {
-        val element = usage.getElement() as? KtFunction ?: return true
+        val element = usage.element as? KtFunction ?: return true
 
         val changeInfo = createChangeInfo(data, element) ?: return true
         // Java method is already updated at this point
-        val addedParameterType = data.getMethodToReplaceIn().getJavaMethodDescriptor()!!.getValueParameters().last().getType()
+        val addedParameterType = data.methodToReplaceIn.getJavaMethodDescriptor()!!.valueParameters.last().type
-        changeInfo.getNewParameters().last().currentTypeInfo = KotlinTypeInfo(false, addedParameterType)
+        changeInfo.newParameters.last().currentTypeInfo = KotlinTypeInfo(false, addedParameterType)
 
-        val scope = element.getUseScope().let {
+        val scope = element.useScope.let {
             if (it is GlobalSearchScope) GlobalSearchScope.getScopeRestrictedByFileTypes(it, KotlinFileType.INSTANCE) else it
         }
         val kotlinFunctions = HierarchySearchRequest(element, scope)
@@ -95,10 +95,10 @@ public class KotlinIntroduceParameterMethodUsageProcessor : IntroduceParameterMe
     }
 
     override fun processChangeMethodUsage(data: IntroduceParameterData, usage: UsageInfo, usages: Array<out UsageInfo>): Boolean {
-        val psiMethod = data.getMethodToReplaceIn()
+        val psiMethod = data.methodToReplaceIn
         val changeInfo = createChangeInfo(data, psiMethod) ?: return true
-        val refElement = usage.getElement() as? KtReferenceExpression ?: return true
+        val refElement = usage.element as? KtReferenceExpression ?: return true
-        val callElement = refElement.getParentOfTypeAndBranch<KtCallElement>(true) { getCalleeExpression() } ?: return true
+        val callElement = refElement.getParentOfTypeAndBranch<KtCallElement>(true) { calleeExpression } ?: return true
         val delegateUsage = if (callElement is KtConstructorDelegationCall) {
             @Suppress("CAST_NEVER_SUCCEEDS")
             (KotlinConstructorDelegationCallUsage(callElement, changeInfo) as KotlinUsageInfo<KtCallElement>)

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable
+package org.jetbrains.kotlin.idea.refactoring.introduce.introduceProperty
 
 import com.intellij.refactoring.RefactoringActionHandler
 import com.intellij.lang.refactoring.RefactoringSupportProvider

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

@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.Extracti
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.generateDeclaration
 import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.processDuplicatesSilently
 import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer
-import org.jetbrains.kotlin.idea.refactoring.introduce.introduceVariable.KotlinInplaceVariableIntroducer.ControlWrapper
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtExpression
 import org.jetbrains.kotlin.psi.KtFile
@@ -84,7 +83,7 @@ public class KotlinInplacePropertyIntroducer(
     private fun isInitializer(): Boolean = currentTarget == ExtractionTarget.PROPERTY_WITH_INITIALIZER
 
     override fun initPanelControls() {
-        if (availableTargets.size() > 1) {
+        if (availableTargets.size > 1) {
             addPanelControl(
                     ControlWrapper {
                         val propertyKindComboBox = with(JComboBox(availableTargets.map { it.targetName.capitalize() }.toTypedArray())) {
@@ -92,20 +91,20 @@ public class KotlinInplacePropertyIntroducer(
                                     object : PopupMenuListenerAdapter() {
                                         override fun popupMenuWillBecomeInvisible(e: PopupMenuEvent?) {
                                             ApplicationManager.getApplication().invokeLater {
-                                                currentTarget = availableTargets[getSelectedIndex()]
+                                                currentTarget = availableTargets[selectedIndex]
                                             }
                                         }
                                     }
                             )
 
-                            setSelectedIndex(availableTargets.indexOf(currentTarget))
+                            selectedIndex = availableTargets.indexOf(currentTarget)
 
                             this
                         }
 
                         val propertyKindLabel = JLabel("Introduce as: ")
                         propertyKindLabel.setDisplayedMnemonic('I')
-                        propertyKindLabel.setLabelFor(propertyKindComboBox)
+                        propertyKindLabel.labelFor = propertyKindComboBox
 
                         val panel = JPanel()
                         panel.add(propertyKindLabel)
@@ -119,32 +118,32 @@ public class KotlinInplacePropertyIntroducer(
         if (ExtractionTarget.PROPERTY_WITH_INITIALIZER in availableTargets) {
             val condition = { isInitializer() }
 
-            getCreateVarCheckBox()?.let {
+            createVarCheckBox?.let {
                 val initializer = object: Pass<JComponent>() {
                     override fun pass(t: JComponent) {
-                        (t as JCheckBox).setSelected(property.isVar())
+                        (t as JCheckBox).isSelected = property.isVar
                     }
                 }
                 addPanelControl(ControlWrapper(it, condition, initializer))
             }
-            getCreateExplicitTypeCheckBox()?.let {
+            createExplicitTypeCheckBox?.let {
                 val initializer = object: Pass<JComponent>() {
                     override fun pass(t: JComponent) {
-                        (t as JCheckBox).setSelected(property.getTypeReference() != null)
+                        (t as JCheckBox).isSelected = property.typeReference != null
                     }
                 }
                 addPanelControl(ControlWrapper(it, condition, initializer))
             }
         }
 
-        val occurrenceCount = extractionResult.duplicateReplacers.size() + 1
+        val occurrenceCount = extractionResult.duplicateReplacers.size + 1
         if (occurrenceCount > 1) {
             addPanelControl(
                     ControlWrapper {
                         val replaceAllCheckBox = NonFocusableCheckBox("Replace all occurrences ($occurrenceCount)")
-                        replaceAllCheckBox.setSelected(replaceAll)
+                        replaceAllCheckBox.isSelected = replaceAll
                         replaceAllCheckBox.setMnemonic('R')
-                        replaceAllCheckBox.addActionListener { replaceAll = replaceAllCheckBox.isSelected() }
+                        replaceAllCheckBox.addActionListener { replaceAll = replaceAllCheckBox.isSelected }
                         replaceAllCheckBox
                     }
             )

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

@@ -27,12 +27,13 @@ import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.*
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.*
 import kotlin.test.*
 import com.intellij.openapi.application.*
-import org.jetbrains.kotlin.idea.core.refactoring.getExtractionContainers
+import com.intellij.refactoring.RefactoringActionHandler
+import org.jetbrains.kotlin.idea.refactoring.getExtractionContainers
 import java.util.*
 
 public class KotlinIntroducePropertyHandler(
         val helper: ExtractionEngineHelper = KotlinIntroducePropertyHandler.InteractiveExtractionHelper
-): KotlinIntroduceHandlerBase() {
+): RefactoringActionHandler {
     object InteractiveExtractionHelper : ExtractionEngineHelper(INTRODUCE_PROPERTY) {
         override fun configureAndRun(
                 project: Project,
@@ -65,7 +66,7 @@ public class KotlinIntroducePropertyHandler(
     }
 
     public fun doInvoke(project: Project, editor: Editor, file: KtFile, elements: List<PsiElement>, targetSibling: PsiElement) {
-        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.getStatements() ?: elements
+        val adjustedElements = (elements.singleOrNull() as? KtBlockExpression)?.statements ?: elements
         if (adjustedElements.isNotEmpty()) {
             val options = ExtractionOptions(extractAsProperty = true)
             val extractionData = ExtractionData(file, adjustedElements.toRange(), targetSibling, null, options)
@@ -73,12 +74,12 @@ public class KotlinIntroducePropertyHandler(
                 val property = it.declaration as KtProperty
                 val descriptor = it.config.descriptor
 
-                editor.getCaretModel().moveToOffset(property.getTextOffset())
+                editor.caretModel.moveToOffset(property.textOffset)
-                editor.getSelectionModel().removeSelection()
+                editor.selectionModel.removeSelection()
-                if (editor.getSettings().isVariableInplaceRenameEnabled() && !ApplicationManager.getApplication().isUnitTestMode()) {
+                if (editor.settings.isVariableInplaceRenameEnabled && !ApplicationManager.getApplication().isUnitTestMode) {
                     with(PsiDocumentManager.getInstance(project)) {
-                        commitDocument(editor.getDocument())
+                        commitDocument(editor.document)
-                        doPostponedOperationsAndUnblockDocument(editor.getDocument())
+                        doPostponedOperationsAndUnblockDocument(editor.document)
                     }
 
                     val introducer = KotlinInplacePropertyIntroducer(

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

@@ -25,7 +25,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiWhiteSpace
 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.chooseContainerElementIfNecessary
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
 import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.idea.util.psi.patternMatching.KotlinPsiRange
@@ -59,7 +59,7 @@ fun selectElementsWithTargetSibling(
 
         val outermostParent = parent.getOutermostParentContainedIn(targetContainer)
         if (outermostParent == null) {
-            showErrorHintByKey(file.getProject(), editor, "cannot.refactor.no.container", operationName)
+            showErrorHintByKey(file.project, editor, "cannot.refactor.no.container", operationName)
             return
         }
 
@@ -77,7 +77,7 @@ fun selectElementsWithTargetParent(
         continuation: (elements: List<PsiElement>, targetParent: PsiElement) -> Unit
 ) {
     fun showErrorHintByKey(key: String) {
-        showErrorHintByKey(file.getProject(), editor, key, operationName)
+        showErrorHintByKey(file.project, editor, key, operationName)
     }
 
     fun selectTargetContainer(elements: List<PsiElement>) {
@@ -102,8 +102,8 @@ fun selectElementsWithTargetParent(
     }
 
     fun selectMultipleExpressions() {
-        val startOffset = editor.getSelectionModel().getSelectionStart()
+        val startOffset = editor.selectionModel.selectionStart
-        val endOffset = editor.getSelectionModel().getSelectionEnd()
+        val endOffset = editor.selectionModel.selectionEnd
 
         val elements = CodeInsightUtils.findStatements(file, startOffset, endOffset)
         if (elements.isEmpty()) {
@@ -120,20 +120,20 @@ fun selectElementsWithTargetParent(
                 selectTargetContainer(listOf(expr))
             }
             else {
-                if (!editor.getSelectionModel().hasSelection()) {
+                if (!editor.selectionModel.hasSelection()) {
                     val elementAtCaret = file.findElementAt(editor.caretModel.offset)
                     elementAtCaret?.getParentOfTypeAndBranch<KtProperty> { nameIdentifier }?.let {
                         return@selectExpression selectTargetContainer(listOf(it))
                     }
 
-                    editor.getSelectionModel().selectLineAtCaret()
+                    editor.selectionModel.selectLineAtCaret()
                 }
                 selectMultipleExpressions()
             }
         }
     }
 
-    editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE)
+    editor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
     selectSingleExpression()
 }
 

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

@@ -35,8 +35,6 @@ import com.intellij.psi.search.SearchScope;
 import com.intellij.refactoring.introduce.inplace.InplaceVariableIntroducer;
 import com.intellij.ui.NonFocusableCheckBox;
 import com.intellij.util.ui.PositionTracker;
-import kotlin.ArraysKt;
-import kotlin.CollectionsKt;
 import kotlin.jvm.functions.Function0;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
@@ -391,8 +389,8 @@ public class KotlinInplaceVariableIntroducer<D extends KtCallableDeclaration> ex
 
     @Override
     protected Collection<PsiReference> collectRefs(SearchScope referencesSearchScope) {
-        return CollectionsKt.map(
+        return kotlin.collections.CollectionsKt.map(
-                ArraysKt.filterIsInstance(getOccurrences(), KtSimpleNameExpression.class),
+                kotlin.collections.ArraysKt.filterIsInstance(getOccurrences(), KtSimpleNameExpression.class),
                 new Function1<KtSimpleNameExpression, PsiReference>() {
                     @Override
                     public PsiReference invoke(KtSimpleNameExpression expression) {

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

@@ -30,6 +30,7 @@ import com.intellij.openapi.util.TextRange
 import com.intellij.psi.*
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.refactoring.HelpID
+import com.intellij.refactoring.RefactoringActionHandler
 import com.intellij.refactoring.introduce.inplace.OccurrencesChooser
 import com.intellij.refactoring.util.CommonRefactoringUtil
 import com.intellij.ui.components.JBList
@@ -42,10 +43,8 @@ import org.jetbrains.kotlin.idea.analysis.computeTypeInfoInContext
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.codeInsight.DescriptorToSourceUtilsIde
 import org.jetbrains.kotlin.idea.core.*
-import org.jetbrains.kotlin.idea.core.refactoring.*
 import org.jetbrains.kotlin.idea.intentions.ConvertToBlockBodyIntention
-import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringBundle
+import org.jetbrains.kotlin.idea.refactoring.*
-import org.jetbrains.kotlin.idea.refactoring.KotlinRefactoringUtil
 import org.jetbrains.kotlin.idea.refactoring.introduce.*
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
@@ -74,7 +73,7 @@ import org.jetbrains.kotlin.utils.ifEmpty
 import org.jetbrains.kotlin.utils.sure
 import java.util.*
 
-object KotlinIntroduceVariableHandler : KotlinIntroduceHandlerBase() {
+object KotlinIntroduceVariableHandler : RefactoringActionHandler {
     val INTRODUCE_VARIABLE = KotlinRefactoringBundle.message("introduce.variable")
 
     private val EXPRESSION_KEY = Key.create<Boolean>("EXPRESSION_KEY")

idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt

@@ -28,15 +28,16 @@ import com.intellij.psi.PsiFile
 import com.intellij.psi.PsiReference
 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil
 import com.intellij.ui.NonFocusableCheckBox
-import com.intellij.util.ui.FormBuilder
 import org.jetbrains.kotlin.idea.intentions.SpecifyTypeExplicitlyIntention
 import org.jetbrains.kotlin.idea.refactoring.introduce.AbstractKotlinInplaceIntroducer
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.KtDeclaration
+import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.psi.KtProperty
+import org.jetbrains.kotlin.psi.KtPsiFactory
 import org.jetbrains.kotlin.psi.psiUtil.startOffset
 import org.jetbrains.kotlin.types.KotlinType
-import java.awt.BorderLayout
 
 public class KotlinVariableInplaceIntroducer(
         val addedVariable: KtProperty,
@@ -64,15 +65,15 @@ public class KotlinVariableInplaceIntroducer(
         initFormComponents {
             if (!doNotChangeVar) {
                 val varCheckBox = NonFocusableCheckBox("Declare with var")
-                varCheckBox.setSelected(isVar)
+                varCheckBox.isSelected = isVar
                 varCheckBox.setMnemonic('v')
                 varCheckBox.addActionListener {
-                    myProject.executeWriteCommand(getCommandName(), getCommandName()) {
+                    myProject.executeWriteCommand(commandName, commandName) {
-                        PsiDocumentManager.getInstance(myProject).commitDocument(myEditor.getDocument())
+                        PsiDocumentManager.getInstance(myProject).commitDocument(myEditor.document)
 
                         val psiFactory = KtPsiFactory(myProject)
-                        val keyword = if (varCheckBox.isSelected()) psiFactory.createVarKeyword() else psiFactory.createValKeyword()
+                        val keyword = if (varCheckBox.isSelected) psiFactory.createVarKeyword() else psiFactory.createValKeyword()
-                        addedVariable.getValOrVarKeyword().replace(keyword)
+                        addedVariable.valOrVarKeyword.replace(keyword)
                     }
                 }
                 addComponent(varCheckBox)
@@ -80,11 +81,11 @@ public class KotlinVariableInplaceIntroducer(
 
             if (expressionType != null && !noTypeInference) {
                 val expressionTypeCheckBox = NonFocusableCheckBox("Specify type explicitly")
-                expressionTypeCheckBox.setSelected(false)
+                expressionTypeCheckBox.isSelected = false
                 expressionTypeCheckBox.setMnemonic('t')
                 expressionTypeCheckBox.addActionListener {
                     runWriteCommandAndRestart {
-                        if (expressionTypeCheckBox.isSelected()) {
+                        if (expressionTypeCheckBox.isSelected) {
                             val renderedType = IdeDescriptorRenderers.SOURCE_CODE_SHORT_NAMES_IN_TYPES.renderType(expressionType)
                             addedVariable.setTypeReference(KtPsiFactory(myProject).createType(renderedType))
                         }
@@ -105,7 +106,7 @@ public class KotlinVariableInplaceIntroducer(
     override fun createFieldToStartTemplateOn(replaceAll: Boolean, names: Array<out String>) = addedVariable
 
     override fun addAdditionalVariables(builder: TemplateBuilderImpl) {
-        addedVariable.getTypeReference()?.let {
+        addedVariable.typeReference?.let {
             builder.replaceElement(it,
                                    "TypeReferenceVariable",
                                    SpecifyTypeExplicitlyIntention.createTypeExpressionForTemplate(expressionType!!),
@@ -117,12 +118,12 @@ public class KotlinVariableInplaceIntroducer(
                                        stringUsages: Collection<Pair<PsiElement, TextRange>>,
                                        scope: PsiElement,
                                        containingFile: PsiFile): Boolean {
-        myEditor.getCaretModel().moveToOffset(getNameIdentifier()!!.startOffset)
+        myEditor.caretModel.moveToOffset(nameIdentifier!!.startOffset)
 
         val result = super.buildTemplateAndStart(refs, stringUsages, scope, containingFile)
 
         val templateState = TemplateManagerImpl.getTemplateState(InjectedLanguageUtil.getTopLevelEditor(myEditor))
-        if (templateState != null && addedVariable.getTypeReference() != null) {
+        if (templateState != null && addedVariable.typeReference != null) {
             templateState.addTemplateStateListener(SpecifyTypeExplicitlyIntention.createTypeReferencePostprocessor(addedVariable))
         }
 
@@ -146,11 +147,11 @@ public class KotlinVariableInplaceIntroducer(
     override fun getComponent() = myWholePanel
 
     override fun performIntroduce() {
-        val newName = getInputName() ?: return
+        val newName = inputName ?: return
         addedVariable.setName(newName)
         val replacement = KtPsiFactory(myProject).createExpression(newName)
-        getOccurrences().forEach {
+        occurrences.forEach {
-            if (it.isValid()) {
+            if (it.isValid) {
                 it.replace(replacement)
             }
         }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.core.refactoring
+package org.jetbrains.kotlin.idea.refactoring
 
 import com.intellij.psi.PsiElementFactory
 import com.intellij.psi.PsiJavaCodeReferenceElement
@@ -25,12 +25,12 @@ public fun PsiElementFactory.createReferenceListWithRole(
         references: Array<PsiJavaCodeReferenceElement>,
         role: Role
 ): PsiReferenceList? {
-    val refsText = references.map { it.getCanonicalText() }
+    val refsText = references.map { it.canonicalText }
     val refListText = if (refsText.isNotEmpty()) refsText.joinToString() else return null
     return when (role) {
-        Role.THROWS_LIST -> createMethodFromText("void foo() throws $refListText {}", null).getThrowsList()
+        Role.THROWS_LIST -> createMethodFromText("void foo() throws $refListText {}", null).throwsList
-        Role.EXTENDS_LIST -> createClassFromText("class Foo extends $refListText {}", null).getInnerClasses()[0].getExtendsList()
+        Role.EXTENDS_LIST -> createClassFromText("class Foo extends $refListText {}", null).innerClasses[0].extendsList
-        Role.IMPLEMENTS_LIST -> createClassFromText("class Foo implements $refListText {}", null).getInnerClasses()[0].getImplementsList()
+        Role.IMPLEMENTS_LIST -> createClassFromText("class Foo implements $refListText {}", null).innerClasses[0].implementsList
-        Role.EXTENDS_BOUNDS_LIST -> createTypeParameterFromText("T extends $refListText", null).getExtendsList()
+        Role.EXTENDS_BOUNDS_LIST -> createTypeParameterFromText("T extends $refListText", null).extendsList
     }
 }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.idea.core.refactoring
+package org.jetbrains.kotlin.idea.refactoring
 
 import com.intellij.codeInsight.daemon.impl.quickfix.CreateFromUsageUtils
 import com.intellij.codeInsight.unwrap.RangeSplitter
@@ -39,7 +39,6 @@ import com.intellij.openapi.ui.popup.JBPopup
 import com.intellij.openapi.ui.popup.JBPopupAdapter
 import com.intellij.openapi.ui.popup.LightweightWindowEvent
 import com.intellij.openapi.ui.popup.PopupChooserBuilder
-import com.intellij.openapi.util.Key
 import com.intellij.openapi.util.Pass
 import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.util.text.StringUtil
@@ -94,12 +93,6 @@ import java.lang.annotation.Retention
 import java.util.*
 import javax.swing.Icon
 
-fun <T: Any> PsiElement.getAndRemoveCopyableUserData(key: Key<T>): T? {
-    val data = getCopyableUserData(key)
-    putCopyableUserData(key, null)
-    return data
-}
-
 fun getOrCreateKotlinFile(fileName: String, targetDir: PsiDirectory): KtFile? =
         (targetDir.findFile(fileName) ?: createKotlinFile(fileName, targetDir)) as? KtFile
 
@@ -107,7 +100,7 @@ fun createKotlinFile(fileName: String,
                      targetDir: PsiDirectory,
                      packageName: String? = targetDir.getPackage()?.qualifiedName): KtFile {
     targetDir.checkCreateFile(fileName)
-    val file = PsiFileFactory.getInstance(targetDir.getProject()).createFileFromText(
+    val file = PsiFileFactory.getInstance(targetDir.project).createFileFromText(
             fileName, KotlinFileType.INSTANCE, if (!packageName.isNullOrBlank()) "package $packageName \n\n" else ""
     )
 
@@ -128,13 +121,13 @@ public fun VirtualFile.toPsiDirectory(project: Project): PsiDirectory? = PsiMana
 
 public fun PsiElement.getUsageContext(): PsiElement {
     return when (this) {
-        is KtElement -> PsiTreeUtil.getParentOfType(this, javaClass<KtNamedDeclaration>(), javaClass<KtFile>())!!
+        is KtElement -> PsiTreeUtil.getParentOfType(this, KtNamedDeclaration::class.java, KtFile::class.java)!!
         else -> ConflictsUtil.getContainer(this)
     }
 }
 
 public fun PsiElement.isInJavaSourceRoot(): Boolean =
-        !JavaProjectRootsUtil.isOutsideJavaSourceRoot(getContainingFile())
+        !JavaProjectRootsUtil.isOutsideJavaSourceRoot(containingFile)
 
 public fun KtFile.createTempCopy(text: String? = null): KtFile {
     val tmpFile = KtPsiFactory(this).createAnalyzableFile(name, text ?: this.text ?: "", this)
@@ -188,7 +181,7 @@ public fun PsiElement.getExtractionContainers(strict: Boolean = true, includeAll
         is KtClassBody -> getAllExtractionContainers(strict).filterIsInstance<KtClassBody>()
         else -> {
             val targetContainer = when (enclosingDeclaration) {
-                is KtDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
+                is KtDeclarationWithBody -> enclosingDeclaration.bodyExpression
                 is KtAnonymousInitializer -> enclosingDeclaration.body
                 else -> null
             }
@@ -201,13 +194,13 @@ public fun Project.checkConflictsInteractively(
         conflicts: MultiMap<PsiElement, String>,
         onShowConflicts: () -> Unit = {},
         onAccept: () -> Unit) {
-    if (!conflicts.isEmpty()) {
+    if (!conflicts.isEmpty) {
-        if (ApplicationManager.getApplication()!!.isUnitTestMode()) throw ConflictsInTestsException(conflicts.values())
+        if (ApplicationManager.getApplication()!!.isUnitTestMode) throw ConflictsInTestsException(conflicts.values())
 
         val dialog = ConflictsDialog(this, conflicts) { onAccept() }
         dialog.show()
-        if (!dialog.isOK()) {
+        if (!dialog.isOK) {
-            if (dialog.isShowConflicts()) {
+            if (dialog.isShowConflicts) {
                 onShowConflicts()
             }
             return
@@ -236,12 +229,12 @@ public fun <T, E: PsiElement> getPsiElementPopup(
     val highlighter = if (highlightSelection) SelectionAwareScopeHighlighter(editor) else null
 
     val list = JBList(elements.map(toPsi))
-    list.setCellRenderer(renderer)
+    list.cellRenderer = renderer
     list.addListSelectionListener { e ->
         highlighter?.dropHighlight()
-        val index = list.getSelectedIndex()
+        val index = list.selectedIndex
         if (index >= 0) {
-            highlighter?.highlight(list.getModel()!!.getElementAt(index) as PsiElement)
+            highlighter?.highlight(list.model!!.getElementAt(index) as PsiElement)
         }
     }
 
@@ -249,7 +242,7 @@ public fun <T, E: PsiElement> getPsiElementPopup(
         title?.let { setTitle(it) }
         renderer.installSpeedSearch(this, true)
         setItemChoosenCallback {
-            val index = list.getSelectedIndex()
+            val index = list.selectedIndex
             if (index >= 0) {
                 processor(elements[index])
             }
@@ -269,9 +262,9 @@ public class SelectionAwareScopeHighlighter(val editor: Editor) {
 
     private fun addHighlighter(r: TextRange, attr: TextAttributes) {
         highlighters.add(
-                editor.getMarkupModel().addRangeHighlighter(
+                editor.markupModel.addRangeHighlighter(
-                        r.getStartOffset(),
+                        r.startOffset,
-                        r.getEndOffset(),
+                        r.endOffset,
                         UnwrapHandler.HIGHLIGHTER_LEVEL,
                         attr,
                         HighlighterTargetArea.EXACT_RANGE
@@ -282,9 +275,9 @@ public class SelectionAwareScopeHighlighter(val editor: Editor) {
     public fun highlight(wholeAffected: PsiElement) {
         dropHighlight()
 
-        val attributes = EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES)!!
+        val attributes = EditorColorsManager.getInstance().globalScheme.getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES)!!
-        val selectedRange = with(editor.getSelectionModel()) { TextRange(getSelectionStart(), getSelectionEnd()) }
+        val selectedRange = with(editor.selectionModel) { TextRange(selectionStart, selectionEnd) }
-        for (r in RangeSplitter.split(wholeAffected.getTextRange()!!, Collections.singletonList(selectedRange))) {
+        for (r in RangeSplitter.split(wholeAffected.textRange!!, Collections.singletonList(selectedRange))) {
             addHighlighter(r, attributes)
         }
     }
@@ -316,17 +309,17 @@ fun PsiElement.getLineNumber(start: Boolean = true): Int {
 }
 
 fun PsiElement.getLineCount(): Int {
-    val doc = getContainingFile()?.let { file -> PsiDocumentManager.getInstance(getProject()).getDocument(file) }
+    val doc = containingFile?.let { file -> PsiDocumentManager.getInstance(project).getDocument(file) }
     if (doc != null) {
-        val spaceRange = getTextRange() ?: TextRange.EMPTY_RANGE
+        val spaceRange = textRange ?: TextRange.EMPTY_RANGE
 
-        val startLine = doc.getLineNumber(spaceRange.getStartOffset())
+        val startLine = doc.getLineNumber(spaceRange.startOffset)
-        val endLine = doc.getLineNumber(spaceRange.getEndOffset())
+        val endLine = doc.getLineNumber(spaceRange.endOffset)
 
         return endLine - startLine
     }
 
-    return (getText() ?: "").count { it == '\n' } + 1
+    return (text ?: "").count { it == '\n' } + 1
 }
 
 fun PsiElement.isMultiLine(): Boolean = getLineCount() > 1
@@ -334,10 +327,10 @@ fun PsiElement.isMultiLine(): Boolean = getLineCount() > 1
 public fun KtElement.getContextForContainingDeclarationBody(): BindingContext? {
     val enclosingDeclaration = getStrictParentOfType<KtDeclaration>()
     val bodyElement = when (enclosingDeclaration) {
-        is KtDeclarationWithBody -> enclosingDeclaration.getBodyExpression()
+        is KtDeclarationWithBody -> enclosingDeclaration.bodyExpression
-        is KtWithExpressionInitializer -> enclosingDeclaration.getInitializer()
+        is KtWithExpressionInitializer -> enclosingDeclaration.initializer
-        is KtDestructuringDeclaration -> enclosingDeclaration.getInitializer()
+        is KtDestructuringDeclaration -> enclosingDeclaration.initializer
-        is KtParameter -> enclosingDeclaration.getDefaultValue()
+        is KtParameter -> enclosingDeclaration.defaultValue
         is KtAnonymousInitializer -> enclosingDeclaration.body
         is KtClass -> {
             val delegationSpecifierList = enclosingDeclaration.getSuperTypeList()
@@ -361,40 +354,40 @@ public fun <T> chooseContainerElement(
             object : PsiElementListCellRenderer<PsiElement>() {
                 private fun PsiElement.renderName(): String {
                     if (this is KtPropertyAccessor) {
-                        return (getParent() as KtProperty).renderName() + if (isGetter()) ".get" else ".set"
+                        return (parent as KtProperty).renderName() + if (isGetter) ".get" else ".set"
                     }
                     if (this is KtObjectDeclaration && this.isCompanion()) {
                         return "Companion object of ${getStrictParentOfType<KtClassOrObject>()?.renderName() ?: "<anonymous>"}"
                     }
-                    return (this as? PsiNamedElement)?.getName() ?: "<anonymous>"
+                    return (this as? PsiNamedElement)?.name ?: "<anonymous>"
                 }
 
                 private fun PsiElement.renderDeclaration(): String? {
                     if (this is KtFunctionLiteral || isFunctionalExpression()) return renderText()
 
                     val descriptor = when {
-                        this is KtFile -> getName()
+                                         this is KtFile -> name
-                        this is KtElement -> analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this]
+                                         this is KtElement -> analyze()[BindingContext.DECLARATION_TO_DESCRIPTOR, this]
-                        this is PsiMember -> getJavaMemberDescriptor()
+                                         this is PsiMember -> getJavaMemberDescriptor()
-                        else -> null
+                                         else -> null
-                    } ?: return null
+                                     } ?: return null
                     val name = renderName()
                     val params = (descriptor as? FunctionDescriptor)?.let { descriptor ->
-                        descriptor.getValueParameters()
+                        descriptor.valueParameters
-                                .map { DescriptorRenderer.SHORT_NAMES_IN_TYPES.renderType(it.getType()) }
+                                .map { DescriptorRenderer.Companion.SHORT_NAMES_IN_TYPES.renderType(it.type) }
                                 .joinToString(", ", "(", ")")
                     } ?: ""
                     return "$name$params"
                 }
 
                 private fun PsiElement.renderText(): String {
-                    return StringUtil.shortenTextWithEllipsis(getText()!!.collapseSpaces(), 53, 0)
+                    return StringUtil.shortenTextWithEllipsis(text!!.collapseSpaces(), 53, 0)
                 }
 
                 private fun PsiElement.getRepresentativeElement(): PsiElement {
                     return when (this) {
-                        is KtBlockExpression -> (getParent() as? KtDeclarationWithBody) ?: this
+                        is KtBlockExpression -> (parent as? KtDeclarationWithBody) ?: this
-                        is KtClassBody -> getParent() as KtClassOrObject
+                        is KtClassBody -> parent as KtClassOrObject
                         else -> this
                     }
                 }
@@ -431,7 +424,7 @@ public fun <T> chooseContainerElementIfNecessary(
 ) {
     when {
         containers.isEmpty() -> return
-        containers.size() == 1 || ApplicationManager.getApplication()!!.isUnitTestMode() -> onSelect(containers.first())
+        containers.size == 1 || ApplicationManager.getApplication()!!.isUnitTestMode -> onSelect(containers.first())
         else -> chooseContainerElement(containers, editor, title, highlightSelection, toPsi, onSelect)
     }
 }
@@ -441,11 +434,11 @@ public fun PsiElement.isTrueJavaMethod(): Boolean = this is PsiMethod && this !i
 public fun PsiElement.canRefactor(): Boolean {
     return when {
         this is PsiPackage ->
-            getDirectories().any { it.canRefactor() }
+            directories.any { it.canRefactor() }
         this is KtElement ||
-        this is PsiMember && getLanguage() == JavaLanguage.INSTANCE ||
+        this is PsiMember && language == JavaLanguage.INSTANCE ||
         this is PsiDirectory ->
-            isWritable() && ProjectRootsUtil.isInProjectSource(this)
+            isWritable && ProjectRootsUtil.isInProjectSource(this)
         else ->
             false
     }
@@ -459,10 +452,10 @@ private fun copyModifierListItems(from: PsiModifierList, to: PsiModifierList, wi
             }
         }
     }
-    for (annotation in from.getAnnotations()) {
+    for (annotation in from.annotations) {
-        val annotationName = annotation.getQualifiedName()!!
+        val annotationName = annotation.qualifiedName!!
 
-        if (javaClass<Retention>().getName() != annotationName) {
+        if (Retention::class.java.name != annotationName) {
             to.addAnnotation(annotationName)
         }
     }
@@ -473,19 +466,19 @@ private fun <T> copyTypeParameters(
         to: T,
         inserter: (T, PsiTypeParameterList) -> Unit
 ) where T : PsiTypeParameterListOwner, T : PsiNameIdentifierOwner {
-    val factory = PsiElementFactory.SERVICE.getInstance((from as PsiElement).getProject())
+    val factory = PsiElementFactory.SERVICE.getInstance((from as PsiElement).project)
-    val templateTypeParams = from.getTypeParameterList()?.getTypeParameters() ?: PsiTypeParameter.EMPTY_ARRAY
+    val templateTypeParams = from.typeParameterList?.typeParameters ?: PsiTypeParameter.EMPTY_ARRAY
     if (templateTypeParams.isNotEmpty()) {
         inserter(to, factory.createTypeParameterList())
-        val targetTypeParamList = to.getTypeParameterList()
+        val targetTypeParamList = to.typeParameterList
         val newTypeParams = templateTypeParams.map {
-            factory.createTypeParameter(it.getName(), it.getExtendsList().getReferencedTypes())
+            factory.createTypeParameter(it.name, it.extendsList.referencedTypes)
         }
         ChangeSignatureUtil.synchronizeList(
                 targetTypeParamList,
                 newTypeParams,
-                { it!!.getTypeParameters().toList() },
+                { it!!.typeParameters.toList() },
-                BooleanArray(newTypeParams.size())
+                BooleanArray(newTypeParams.size)
         )
     }
 }
@@ -497,41 +490,41 @@ public fun createJavaMethod(function: KtFunction, targetClass: PsiClass): PsiMet
 }
 
 public fun createJavaMethod(template: PsiMethod, targetClass: PsiClass): PsiMethod {
-    val factory = PsiElementFactory.SERVICE.getInstance(template.getProject())
+    val factory = PsiElementFactory.SERVICE.getInstance(template.project)
-    val methodToAdd = if (template.isConstructor()) {
+    val methodToAdd = if (template.isConstructor) {
-        factory.createConstructor(template.getName())
+        factory.createConstructor(template.name)
     }
     else {
-        factory.createMethod(template.getName(), template.getReturnType())
+        factory.createMethod(template.name, template.returnType)
     }
     val method = targetClass.add(methodToAdd) as PsiMethod
 
-    copyModifierListItems(template.getModifierList(), method.getModifierList())
+    copyModifierListItems(template.modifierList, method.modifierList)
-    if (targetClass.isInterface()) {
+    if (targetClass.isInterface) {
-        method.getModifierList().setModifierProperty(PsiModifier.FINAL, false)
+        method.modifierList.setModifierProperty(PsiModifier.FINAL, false)
     }
 
     copyTypeParameters(template, method) { method, typeParameterList ->
-        method.addAfter(typeParameterList, method.getModifierList())
+        method.addAfter(typeParameterList, method.modifierList)
     }
 
-    val targetParamList = method.getParameterList()
+    val targetParamList = method.parameterList
-    val newParams = template.getParameterList().getParameters().map {
+    val newParams = template.parameterList.parameters.map {
-        val param = factory.createParameter(it.getName()!!, it.getType())
+        val param = factory.createParameter(it.name!!, it.type)
-        copyModifierListItems(it.getModifierList()!!, param.getModifierList()!!)
+        copyModifierListItems(it.modifierList!!, param.modifierList!!)
         param
     }
     ChangeSignatureUtil.synchronizeList(
             targetParamList,
             newParams,
-            { it.getParameters().toList() },
+            { it.parameters.toList() },
-            BooleanArray(newParams.size())
+            BooleanArray(newParams.size)
     )
 
-    if (template.getModifierList().hasModifierProperty(PsiModifier.ABSTRACT) || targetClass.isInterface()) {
+    if (template.modifierList.hasModifierProperty(PsiModifier.ABSTRACT) || targetClass.isInterface) {
-        method.getBody()!!.delete()
+        method.body!!.delete()
     }
-    else if (!template.isConstructor()) {
+    else if (!template.isConstructor) {
         CreateFromUsageUtils.setupMethodBody(method)
     }
 
@@ -542,13 +535,13 @@ fun createJavaField(property: KtProperty, targetClass: PsiClass): PsiField {
     val template = LightClassUtil.getLightClassPropertyMethods(property).getter
                    ?: throw AssertionError("Can't generate light method: ${property.getElementTextWithContext()}")
 
-    val factory = PsiElementFactory.SERVICE.getInstance(template.getProject())
+    val factory = PsiElementFactory.SERVICE.getInstance(template.project)
-    val field = targetClass.add(factory.createField(property.getName()!!, template.getReturnType()!!)) as PsiField
+    val field = targetClass.add(factory.createField(property.name!!, template.returnType!!)) as PsiField
 
-    with(field.getModifierList()!!) {
+    with(field.modifierList!!) {
-        val templateModifiers = template.getModifierList()
+        val templateModifiers = template.modifierList
         setModifierProperty(VisibilityUtil.getVisibilityModifier(templateModifiers), true)
-        if (!property.isVar() || targetClass.isInterface()) {
+        if (!property.isVar || targetClass.isInterface) {
             setModifierProperty(PsiModifier.FINAL, true)
         }
         copyModifierListItems(templateModifiers, this, false)
@@ -558,10 +551,10 @@ fun createJavaField(property: KtProperty, targetClass: PsiClass): PsiField {
 }
 
 fun createJavaClass(klass: KtClass, targetClass: PsiClass?, forcePlainClass: Boolean = false): PsiClass {
-    val kind = if (forcePlainClass) ClassKind.CLASS else (klass.resolveToDescriptor() as ClassDescriptor).getKind()
+    val kind = if (forcePlainClass) ClassKind.CLASS else (klass.resolveToDescriptor() as ClassDescriptor).kind
 
-    val factory = PsiElementFactory.SERVICE.getInstance(klass.getProject())
+    val factory = PsiElementFactory.SERVICE.getInstance(klass.project)
-    val className = klass.getName()!!
+    val className = klass.name!!
     val javaClassToAdd = when (kind) {
         ClassKind.CLASS -> factory.createClass(className)
         ClassKind.INTERFACE -> factory.createInterface(className)
@@ -574,13 +567,13 @@ fun createJavaClass(klass: KtClass, targetClass: PsiClass?, forcePlainClass: Boo
     val template = LightClassUtil.getPsiClass(klass)
                    ?: throw AssertionError("Can't generate light class: ${klass.getElementTextWithContext()}")
 
-    copyModifierListItems(template.getModifierList()!!, javaClass.getModifierList()!!)
+    copyModifierListItems(template.modifierList!!, javaClass.modifierList!!)
-    if (template.isInterface()) {
+    if (template.isInterface) {
-        javaClass.getModifierList()!!.setModifierProperty(PsiModifier.ABSTRACT, false)
+        javaClass.modifierList!!.setModifierProperty(PsiModifier.ABSTRACT, false)
     }
 
     copyTypeParameters(template, javaClass) { klass, typeParameterList ->
-        klass.addAfter(typeParameterList, klass.getNameIdentifier())
+        klass.addAfter(typeParameterList, klass.nameIdentifier)
     }
 
     // Turning interface to class
@@ -605,16 +598,16 @@ fun createJavaClass(klass: KtClass, targetClass: PsiClass?, forcePlainClass: Boo
         implementsList?.let { javaClass.implementsList?.replace(it) }
     }
 
-    for (method in template.getMethods()) {
+    for (method in template.methods) {
-        val hasParams = method.getParameterList().getParametersCount() > 0
+        val hasParams = method.parameterList.parametersCount > 0
-        val needSuperCall = !template.isEnum() &&
+        val needSuperCall = !template.isEnum &&
-                            (template.getSuperClass()?.getConstructors() ?: PsiMethod.EMPTY_ARRAY).all {
+                            (template.superClass?.constructors ?: PsiMethod.EMPTY_ARRAY).all {
-                                it.getParameterList().getParametersCount() > 0
+                                it.parameterList.parametersCount > 0
                             }
-        if (method.isConstructor() && !(hasParams || needSuperCall)) continue
+        if (method.isConstructor && !(hasParams || needSuperCall)) continue
         with(createJavaMethod(method, javaClass)) {
-            if (isConstructor() && needSuperCall) {
+            if (isConstructor && needSuperCall) {
-                getBody()!!.add(factory.createStatementFromText("super();", this))
+                body!!.add(factory.createStatementFromText("super();", this))
             }
         }
     }
@@ -626,7 +619,7 @@ fun PsiElement.j2kText(): String? {
     if (language != JavaLanguage.INSTANCE) return null
 
     val j2kConverter = JavaToKotlinConverter(project,
-                                             ConverterSettings.defaultSettings,
+                                             ConverterSettings.Companion.defaultSettings,
                                              IdeaJavaToKotlinServices)
     return j2kConverter.elementsToKotlin(listOf(this)).results.single()?.text ?: return null //TODO: insert imports
 }
@@ -646,7 +639,7 @@ public fun (() -> Any).runRefactoringWithPostprocessing(
         targetRefactoringId: String,
         finishAction: () -> Unit
 ) {
-    val connection = project.getMessageBus().connect()
+    val connection = project.messageBus.connect()
     connection.subscribe(RefactoringEventListener.REFACTORING_EVENT_TOPIC,
                          object: RefactoringEventListener {
                              override fun undoRefactoring(refactoringId: String) {
@@ -689,7 +682,7 @@ public fun KtElement?.validateElement(errorMessage: String) {
 
 public fun <T : Any> Project.runSynchronouslyWithProgress(progressTitle: String, canBeCanceled: Boolean, action: () -> T): T? {
     var result: T? = null
-    ProgressManager.getInstance().runProcessWithProgressSynchronously( { result = action() }, progressTitle, canBeCanceled, this)
+    ProgressManager.getInstance().runProcessWithProgressSynchronously({ result = action() }, progressTitle, canBeCanceled, this)
     return result
 }
 

idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt

@@ -73,9 +73,7 @@ public fun KotlinMemberInfo.toJavaMemberInfo(): MemberInfo? {
         is KtClassOrObject -> declaration.toLightClass()
         else -> null
     }
-    if (psiMember == null) return null
+    val info = MemberInfo(psiMember ?: return null, isSuperClass, null)
-
-    val info = MemberInfo(psiMember, isSuperClass, null)
     info.isToAbstract = isToAbstract
     return info
 }

idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt

@@ -46,7 +46,7 @@ public class KotlinMemberSelectionTable(
     }
 
     override fun isAbstractColumnEditable(rowIndex: Int): Boolean {
-        val memberInfo = myMemberInfos.get(rowIndex)
+        val memberInfo = myMemberInfos[rowIndex]
 
         if (memberInfo.isStatic()) return false
 

idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/memberInfoUtils.kt

@@ -17,17 +17,13 @@
 package org.jetbrains.kotlin.idea.refactoring.memberInfo
 
 import com.intellij.psi.PsiClass
-import com.intellij.psi.PsiMember
-import com.intellij.psi.PsiModifier
 import com.intellij.psi.PsiNamedElement
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getJavaClassDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
-import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtClassOrObject
-import org.jetbrains.kotlin.psi.KtNamedDeclaration
 import org.jetbrains.kotlin.psi.psiUtil.getElementTextWithContext
 
 fun PsiNamedElement.getClassDescriptorIfAny(resolutionFacade: ResolutionFacade? = null): ClassDescriptor? {
@@ -38,14 +34,6 @@ fun PsiNamedElement.getClassDescriptorIfAny(resolutionFacade: ResolutionFacade?
     }
 }
 
-fun PsiNamedElement.isAbstractMember(): Boolean {
-    return when(this) {
-        is KtNamedDeclaration -> hasModifier(KtTokens.ABSTRACT_KEYWORD)
-        is PsiMember -> hasModifierProperty(PsiModifier.ABSTRACT)
-        else -> false
-    }
-}
-
 // Applies to JetClassOrObject and PsiClass
 public fun PsiNamedElement.qualifiedClassNameForRendering(): String {
     val fqName = when (this) {

idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt

@@ -31,31 +31,31 @@ import org.jetbrains.kotlin.idea.references.mainReference
 
 public class MoveJavaInnerClassKotlinUsagesHandler: MoveInnerClassUsagesHandler {
     override fun correctInnerClassUsage(usage: UsageInfo, outerClass: PsiClass) {
-        val innerCall = usage.getElement()?.getParent() as? KtCallExpression ?: return
+        val innerCall = usage.element?.parent as? KtCallExpression ?: return
 
-        val receiver = (innerCall.getParent() as? KtQualifiedExpression)?.getReceiverExpression()
+        val receiver = (innerCall.parent as? KtQualifiedExpression)?.receiverExpression
         val outerClassRef = when (receiver) {
-            is KtCallExpression -> receiver.getCalleeExpression()
+            is KtCallExpression -> receiver.calleeExpression
             is KtQualifiedExpression -> receiver.getQualifiedElementSelector()
             else -> null
         } as? KtSimpleNameExpression
         if (outerClassRef?.mainReference?.resolve() != outerClass) return
 
-        val outerCall = outerClassRef!!.getParent() as? KtCallExpression ?: return
+        val outerCall = outerClassRef!!.parent as? KtCallExpression ?: return
 
-        val psiFactory = KtPsiFactory(usage.getProject())
+        val psiFactory = KtPsiFactory(usage.project)
 
-        val argumentList = innerCall.getValueArgumentList()
+        val argumentList = innerCall.valueArgumentList
         if (argumentList != null) {
             val newArguments = ArrayList<String>()
-            newArguments.add(outerCall.getText()!!)
+            newArguments.add(outerCall.text!!)
-            argumentList.getArguments().mapTo(newArguments) { it.getText()!! }
+            argumentList.arguments.mapTo(newArguments) { it.text!! }
             argumentList.replace(psiFactory.createCallArguments(newArguments.joinToString(prefix = "(", postfix = ")")))
         }
         else {
-            innerCall.getLambdaArguments().firstOrNull()?.let { lambdaArg ->
+            innerCall.lambdaArguments.firstOrNull()?.let { lambdaArg ->
-                val anchor = PsiTreeUtil.skipSiblingsBackward(lambdaArg, javaClass<PsiWhiteSpace>())
+                val anchor = PsiTreeUtil.skipSiblingsBackward(lambdaArg, PsiWhiteSpace::class.java)
-                innerCall.addAfter(psiFactory.createCallArguments("(${outerCall.getText()})"), anchor)
+                innerCall.addAfter(psiFactory.createCallArguments("(${outerCall.text})"), anchor)
             }
         }
     }

idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageIntention.kt

@@ -24,30 +24,30 @@ import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiDocumentManager
 import org.jetbrains.kotlin.idea.codeInsight.CodeInsightUtils
-import org.jetbrains.kotlin.idea.core.refactoring.hasIdentifiersOnly
+import org.jetbrains.kotlin.idea.refactoring.hasIdentifiersOnly
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingOffsetIndependentIntention
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.FqNameUnsafe
 import org.jetbrains.kotlin.psi.KtPackageDirective
 
-public class ChangePackageIntention: SelfTargetingOffsetIndependentIntention<KtPackageDirective>(javaClass(), "Change package") {
+public class ChangePackageIntention: SelfTargetingOffsetIndependentIntention<KtPackageDirective>(KtPackageDirective::class.java, "Change package") {
     companion object {
         private val PACKAGE_NAME_VAR = "PACKAGE_NAME"
     }
 
-    override fun isApplicableTo(element: KtPackageDirective) = element.getPackageNameExpression() != null
+    override fun isApplicableTo(element: KtPackageDirective) = element.packageNameExpression != null
 
     override fun applyTo(element: KtPackageDirective, editor: Editor) {
-        if (ApplicationManager.getApplication().isUnitTestMode()) {
+        if (ApplicationManager.getApplication().isUnitTestMode) {
             throw UnsupportedOperationException("Do not call applyTo() in the test mode")
         }
 
         val file = element.getContainingKtFile()
-        val project = file.getProject()
+        val project = file.project
 
-        val nameExpression = element.getPackageNameExpression()!!
+        val nameExpression = element.packageNameExpression!!
-        val currentName = element.getQualifiedName()
+        val currentName = element.qualifiedName
 
         val builder = TemplateBuilderImpl(file)
         builder.replaceElement(
@@ -64,7 +64,7 @@ public class ChangePackageIntention: SelfTargetingOffsetIndependentIntention<KtP
         var enteredName: String? = null
         var affectedRange: TextRange? = null
 
-        editor.getCaretModel().moveToOffset(0)
+        editor.caretModel.moveToOffset(0)
         TemplateManager.getInstance(project).startTemplate(
                 editor,
                 builder.buildInlineTemplate(),

idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/ChangePackageToMatchDirectoryIntention.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.idea.refactoring.move.changePackage
 import com.intellij.openapi.editor.Editor
 import org.jetbrains.kotlin.idea.core.getFqNameByDirectory
 import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
-import org.jetbrains.kotlin.idea.core.refactoring.hasIdentifiersOnly
+import org.jetbrains.kotlin.idea.refactoring.hasIdentifiersOnly
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingOffsetIndependentIntention
 import org.jetbrains.kotlin.psi.KtPackageDirective
 

idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/KotlinChangePackageRefactoring.kt

@@ -33,20 +33,20 @@ import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.psi.KtNamedDeclaration
 
 public class KotlinChangePackageRefactoring(val file: KtFile) {
-    private val project = file.getProject()
+    private val project = file.project
 
     fun run(newFqName: FqName) {
-        val packageDirective = file.getPackageDirective() ?: return
+        val packageDirective = file.packageDirective ?: return
-        val currentFqName = packageDirective.getFqName()
+        val currentFqName = packageDirective.fqName
 
         val declarationProcessor = MoveKotlinTopLevelDeclarationsProcessor(
                 project,
                 MoveKotlinTopLevelDeclarationsOptions(
-                        elementsToMove = file.getDeclarations().filterIsInstance<KtNamedDeclaration>(),
+                        elementsToMove = file.declarations.filterIsInstance<KtNamedDeclaration>(),
                         moveTarget = object: KotlinMoveTarget {
-                            override val packageWrapper = PackageWrapper(file.getManager(), newFqName.asString())
+                            override val packageWrapper = PackageWrapper(file.manager, newFqName.asString())
 
-                            override fun getOrCreateTargetPsi(originalPsi: PsiElement) = originalPsi.getContainingFile()
+                            override fun getOrCreateTargetPsi(originalPsi: PsiElement) = originalPsi.containingFile
 
                             override fun getTargetPsiIfExists(originalPsi: PsiElement) = null
 
@@ -61,7 +61,7 @@ public class KotlinChangePackageRefactoring(val file: KtFile) {
         val internalUsages = file.getInternalReferencesToUpdateOnPackageNameChange(PackageNameInfo(currentFqName, newFqName.toUnsafe()))
 
         project.executeWriteCommand("Change file's package to '${newFqName.asString()}'") {
-            packageDirective.setFqName(newFqName)
+            packageDirective.fqName = newFqName
             postProcessMoveUsages(internalUsages)
             project.runWithElementsToShortenIsEmptyIgnored { declarationProcessor.execute(declarationUsages) }
         }

idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/MoveFileToPackageMatchingDirectoryIntention.kt

@@ -19,38 +19,35 @@ package org.jetbrains.kotlin.idea.refactoring.move.changePackage
 import com.intellij.CommonBundle
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.ui.Messages
-import com.intellij.psi.JavaPsiFacade
-import com.intellij.refactoring.RefactoringBundle
 import com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesUtil
 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesUtil
 import com.intellij.refactoring.util.RefactoringMessageUtil
-import org.jetbrains.kotlin.idea.core.refactoring.canRefactor
+import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
 import org.jetbrains.kotlin.idea.intentions.SelfTargetingOffsetIndependentIntention
 import org.jetbrains.kotlin.psi.KtPackageDirective
-import org.jetbrains.kotlin.idea.core.packageMatchesDirectory
 
 public class MoveFileToPackageMatchingDirectoryIntention : SelfTargetingOffsetIndependentIntention<KtPackageDirective>(
-        javaClass(), "", "Move file to package-matching directory"
+        KtPackageDirective::class.java, "", "Move file to package-matching directory"
 ) {
     override fun isApplicableTo(element: KtPackageDirective): Boolean {
         if (element.getContainingKtFile().packageMatchesDirectory()) return false
 
-        val qualifiedName = element.getQualifiedName()
+        val qualifiedName = element.qualifiedName
         val dirName = if (qualifiedName.isEmpty()) "source root" else "'${qualifiedName.replace('.', '/')}'"
-        setText("Move file to $dirName")
+        text = "Move file to $dirName"
         return true
     }
 
     override fun applyTo(element: KtPackageDirective, editor: Editor) {
         val file = element.getContainingKtFile()
-        val project = file.getProject()
+        val project = file.project
         val targetDirectory = MoveClassesOrPackagesUtil.chooseDestinationPackage(
                 project,
-                element.getQualifiedName(),
+                element.qualifiedName,
-                file.getContainingDirectory()
+                file.containingDirectory
         ) ?: return
 
-        RefactoringMessageUtil.checkCanCreateFile(targetDirectory, file.getName())?.let {
+        RefactoringMessageUtil.checkCanCreateFile(targetDirectory, file.name)?.let {
             Messages.showMessageDialog(project, it, CommonBundle.getErrorTitle(), Messages.getErrorIcon())
             return
         }

idea/src/org/jetbrains/kotlin/idea/refactoring/move/changePackage/PackageDirectoryMismatchInspection.kt

@@ -22,5 +22,5 @@ import org.jetbrains.kotlin.psi.KtPackageDirective
 public class PackageDirectoryMismatchInspection: IntentionBasedInspection<KtPackageDirective>(
         listOf(IntentionBasedInspection.IntentionData(MoveFileToPackageMatchingDirectoryIntention()), IntentionBasedInspection.IntentionData(ChangePackageToMatchDirectoryIntention())),
         "Package directive doesn't match file location",
-        javaClass()
+        KtPackageDirective::class.java
 )

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

@@ -26,7 +26,7 @@ import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectori
 import com.intellij.usageView.UsageInfo
 import com.intellij.util.Function
 import org.jetbrains.kotlin.idea.core.getPackage
-import org.jetbrains.kotlin.idea.core.refactoring.invokeOnceOnCommandFinish
+import org.jetbrains.kotlin.idea.refactoring.invokeOnceOnCommandFinish
 import org.jetbrains.kotlin.idea.refactoring.move.moveTopLevelDeclarations.MoveKotlinTopLevelDeclarationsProcessor
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
@@ -54,7 +54,7 @@ public class KotlinMoveDirectoryWithClassesHelper : MoveDirectoryWithClassesHelp
         return fileToMoveContext
                ?: HashMap<PsiFile, MoveContext>().apply {
                    fileToMoveContext = this
-                   invokeOnceOnCommandFinish { fileToMoveContext = null }
+            invokeOnceOnCommandFinish { fileToMoveContext = null }
                }
     }
 

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

@@ -29,8 +29,8 @@ public class KotlinMoveFilesOrDirectoriesHandler : MoveFilesOrDirectoriesHandler
         return elements.map {
             when {
                 it is PsiFile || it is PsiDirectory -> it
-                it is PsiClass && it.getContainingClass() == null -> it.getContainingFile()
+                it is PsiClass && it.containingClass == null -> it.containingFile
-                it is KtClassOrObject && it.getParent() is KtFile -> it.getParent()
+                it is KtClassOrObject && it.parent is KtFile -> it.parent
                 else -> return null
             }
         }.toTypedArray()