Pull Up: Minor: Use property access syntax

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

@@ -40,34 +40,34 @@ public class KotlinMemberInfo(member: JetNamedDeclaration, val isSuperClass: Boo
 
     init {
         val memberDescriptor = member.resolveToDescriptor()
-        isStatic = member.getParent() is JetFile
+        isStatic = member.parent is JetFile
 
         if (member is JetClass && isSuperClass) {
             if (member.isInterface()) {
-                displayName = RefactoringBundle.message("member.info.implements.0", member.getName())
+                displayName = RefactoringBundle.message("member.info.implements.0", member.name)
                 overrides = false
             }
             else {
-                displayName = RefactoringBundle.message("member.info.extends.0", member.getName())
+                displayName = RefactoringBundle.message("member.info.extends.0", member.name)
                 overrides = true
             }
         }
         else {
             displayName = RENDERER.render(memberDescriptor)
-            if (memberDescriptor is MemberDescriptor && memberDescriptor.getModality() == Modality.ABSTRACT) {
+            if (memberDescriptor is MemberDescriptor && memberDescriptor.modality == Modality.ABSTRACT) {
                 displayName = "abstract $displayName"
             }
 
-            val overriddenDescriptors = (memberDescriptor as? CallableMemberDescriptor)?.getOverriddenDescriptors() ?: emptySet()
+            val overriddenDescriptors = (memberDescriptor as? CallableMemberDescriptor)?.overriddenDescriptors ?: emptySet()
             if (overriddenDescriptors.isNotEmpty()) {
-                overrides = overriddenDescriptors.any { it.getModality() != Modality.ABSTRACT }
+                overrides = overriddenDescriptors.any { it.modality != Modality.ABSTRACT }
             }
         }
     }
 }
 
 public fun KotlinMemberInfo.toJavaMemberInfo(): MemberInfo? {
-    val declaration = getMember()
+    val declaration = member
     val psiMember: PsiMember? = when (declaration) {
         is JetNamedFunction, is JetProperty -> declaration.getRepresentativeLightMethod()
         is JetClassOrObject -> declaration.toLightClass()
@@ -76,6 +76,6 @@ public fun KotlinMemberInfo.toJavaMemberInfo(): MemberInfo? {
     if (psiMember == null) return null
 
     val info = MemberInfo(psiMember, isSuperClass, null)
-    info.setToAbstract(isToAbstract())
+    info.isToAbstract = isToAbstract
     return info
 }

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

@@ -18,12 +18,10 @@ package org.jetbrains.kotlin.idea.refactoring.memberInfo
 
 import com.intellij.refactoring.classMembers.AbstractMemberInfoStorage
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 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.psi.*
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.DescriptorUtils
@@ -39,11 +37,11 @@ public class KotlinMemberInfoStorage(
     override fun memberConflict(member1: JetNamedDeclaration, member: JetNamedDeclaration): Boolean {
         val descriptor1 = member1.resolveToDescriptor()
         val descriptor = member.resolveToDescriptor()
-        if (descriptor1.getName() != descriptor.getName()) return false
+        if (descriptor1.name != descriptor.name) return false
 
         return when {
             descriptor1 is FunctionDescriptor && descriptor is FunctionDescriptor -> {
-                !OverloadUtil.isOverloadable(descriptor1, descriptor).isSuccess()
+                !OverloadUtil.isOverloadable(descriptor1, descriptor).isSuccess
             }
             descriptor1 is PropertyDescriptor && descriptor is PropertyDescriptor,
             descriptor1 is ClassDescriptor && descriptor is ClassDescriptor -> true
@@ -53,9 +51,9 @@ public class KotlinMemberInfoStorage(
 
     override fun buildSubClassesMap(aClass: JetClassOrObject) {
         val classDescriptor = aClass.resolveToDescriptor() as ClassDescriptor
-        val classType = classDescriptor.getDefaultType()
+        val classType = classDescriptor.defaultType
         for (supertype in classType.immediateSupertypes()) {
-            val superClass = supertype.getConstructor().getDeclarationDescriptor()?.getSource()?.getPsi() as? JetClassOrObject
+            val superClass = supertype.constructor.declarationDescriptor?.source?.getPsi() as? JetClassOrObject
                              ?: continue
             getSubclasses(superClass).add(aClass)
             buildSubClassesMap(superClass)
@@ -70,7 +68,7 @@ public class KotlinMemberInfoStorage(
 
     override fun extractClassMembers(aClass: JetClassOrObject, temp: ArrayList<KotlinMemberInfo>) {
         val context = aClass.analyze()
-        aClass.getDeclarations()
+        aClass.declarations
                 .filter { it is JetNamedDeclaration
                           && it !is JetConstructor<*>
                           && !(it is JetObjectDeclaration && it.isCompanion())
@@ -79,9 +77,9 @@ public class KotlinMemberInfoStorage(
         aClass.getDelegationSpecifiers()
                 .filterIsInstance<JetDelegatorToSuperClass>()
                 .map {
-                    val type = context[BindingContext.TYPE, it.getTypeReference()]
-                    val classDescriptor = type?.getConstructor()?.getDeclarationDescriptor() as? ClassDescriptor
-                    classDescriptor?.getSource()?.getPsi() as? JetClass
+                    val type = context[BindingContext.TYPE, it.typeReference]
+                    val classDescriptor = type?.constructor?.declarationDescriptor as? ClassDescriptor
+                    classDescriptor?.source?.getPsi() as? JetClass
                 }
                 .filter { it != null && it.isInterface() }
                 .mapTo(temp) { KotlinMemberInfo(it!!, true) }

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

@@ -29,7 +29,7 @@ public class KotlinMemberSelectionPanel(title: String,
     private val table = createMemberSelectionTable(memberInfo, abstractColumnHeader)
 
     init {
-        setLayout(BorderLayout())
+        layout = BorderLayout()
 
         val scrollPane = ScrollPaneFactory.createScrollPane(table)
         add(SeparatorFactory.createSeparator(title, table), BorderLayout.NORTH)

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

@@ -17,11 +17,8 @@
 package org.jetbrains.kotlin.idea.refactoring.memberInfo
 
 import com.intellij.icons.AllIcons
-import com.intellij.psi.PsiMethod
-import com.intellij.psi.PsiModifier
 import com.intellij.refactoring.classMembers.MemberInfoModel
 import com.intellij.refactoring.ui.AbstractMemberSelectionTable
-import com.intellij.refactoring.ui.MemberSelectionTable
 import com.intellij.ui.RowIcon
 import org.jetbrains.kotlin.idea.JetIconProvider
 import org.jetbrains.kotlin.lexer.JetTokens
@@ -38,13 +35,13 @@ public class KotlinMemberSelectionTable(
     override fun getAbstractColumnValue(memberInfo: KotlinMemberInfo): Any? {
         if (memberInfo.isStatic()) return null
 
-        val member = memberInfo.getMember()
+        val member = memberInfo.member
         if (member !is JetNamedFunction && member !is JetProperty) return null
 
         if (member.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
             myMemberInfoModel.isFixedAbstract(memberInfo)?.let { return it }
         }
-        if (myMemberInfoModel.isAbstractEnabled(memberInfo)) return memberInfo.isToAbstract()
+        if (myMemberInfoModel.isAbstractEnabled(memberInfo)) return memberInfo.isToAbstract
         return myMemberInfoModel.isAbstractWhenDisabled(memberInfo)
     }
 
@@ -53,24 +50,24 @@ public class KotlinMemberSelectionTable(
 
         if (memberInfo.isStatic()) return false
 
-        val member = memberInfo.getMember()
+        val member = memberInfo.member
         if (member !is JetNamedFunction && member !is JetProperty) return false
 
         if (member.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
             myMemberInfoModel.isFixedAbstract(memberInfo)?.let { return false }
         }
 
-        return memberInfo.isChecked() && myMemberInfoModel.isAbstractEnabled(memberInfo)
+        return memberInfo.isChecked && myMemberInfoModel.isAbstractEnabled(memberInfo)
     }
 
     override fun setVisibilityIcon(memberInfo: KotlinMemberInfo, icon: RowIcon) {
-        icon.setIcon(JetIconProvider.getVisibilityIcon(memberInfo.getMember().getModifierList()), 1);
+        icon.setIcon(JetIconProvider.getVisibilityIcon(memberInfo.member.modifierList), 1);
     }
 
     override fun getOverrideIcon(memberInfo: KotlinMemberInfo): Icon? {
         val defaultIcon = AbstractMemberSelectionTable.EMPTY_OVERRIDE_ICON
 
-        val member = memberInfo.getMember()
+        val member = memberInfo.member
         if (member !is JetNamedFunction && member !is JetProperty) return defaultIcon
 
         return when (memberInfo.getOverrides()) {

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

@@ -18,4 +18,4 @@ package org.jetbrains.kotlin.idea.refactoring.memberInfo
 
 import org.jetbrains.kotlin.psi.JetClassOrObject
 
-public fun JetClassOrObject.qualifiedNameForRendering(): String = getFqName()?.asString() ?: getName() ?: "[Anonymous]"
+public fun JetClassOrObject.qualifiedNameForRendering(): String = fqName?.asString() ?: name ?: "[Anonymous]"

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/EmptyPullUpHelper.kt

@@ -21,17 +21,7 @@ import com.intellij.psi.PsiField
 import com.intellij.psi.PsiMember
 import com.intellij.psi.PsiSubstitutor
 import com.intellij.refactoring.classMembers.MemberInfoBase
-import com.intellij.refactoring.memberPullUp.PullUpData
 import com.intellij.refactoring.memberPullUp.PullUpHelper
-import com.intellij.refactoring.memberPullUp.PullUpHelperFactory
-import org.jetbrains.kotlin.asJava.namedUnwrappedElement
-import org.jetbrains.kotlin.asJava.unwrapped
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
-import org.jetbrains.kotlin.psi.JetClassOrObject
-import org.jetbrains.kotlin.psi.JetNamedDeclaration
-import org.jetbrains.kotlin.types.TypeSubstitutor
-import org.jetbrains.kotlin.types.substitutions.getTypeSubstitutor
 import java.util.LinkedHashSet
 
 object EmptyPullUpHelper : PullUpHelper<MemberInfoBase<PsiMember>> {

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt

@@ -16,21 +16,22 @@
 
 package org.jetbrains.kotlin.idea.refactoring.pullUp
 
-import com.intellij.refactoring.memberPullUp.PullUpData
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
-import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor
 import org.jetbrains.kotlin.idea.core.getResolutionScope
 import org.jetbrains.kotlin.psi.JetClass
 import org.jetbrains.kotlin.psi.JetClassOrObject
 import org.jetbrains.kotlin.psi.JetNamedDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
-import org.jetbrains.kotlin.types.*
+import org.jetbrains.kotlin.types.TypeConstructor
+import org.jetbrains.kotlin.types.TypeProjection
+import org.jetbrains.kotlin.types.TypeProjectionImpl
+import org.jetbrains.kotlin.types.TypeSubstitutor
 import org.jetbrains.kotlin.types.substitutions.getTypeSubstitution
 import org.jetbrains.kotlin.utils.keysToMap
-import java.util.*
+import java.util.LinkedHashMap
 
 class KotlinPullUpData(val sourceClass: JetClassOrObject,
                        val targetClass: JetClass,
@@ -46,7 +47,7 @@ class KotlinPullUpData(val sourceClass: JetClassOrObject,
     val targetClassDescriptor = resolutionFacade.resolveToDescriptor(targetClass) as ClassDescriptor
 
     val typeParametersInSourceClassContext by lazy {
-        sourceClassDescriptor.getTypeConstructor().getParameters() + sourceClass.getResolutionScope(sourceClassContext, resolutionFacade)
+        sourceClassDescriptor.typeConstructor.parameters + sourceClass.getResolutionScope(sourceClassContext, resolutionFacade)
                 .getDescriptors(DescriptorKindFilter.NON_SINGLETON_CLASSIFIERS)
                 .filterIsInstance<TypeParameterDescriptor>()
     }
@@ -55,17 +56,17 @@ class KotlinPullUpData(val sourceClass: JetClassOrObject,
         val substitution = LinkedHashMap<TypeConstructor, TypeProjection>()
 
         typeParametersInSourceClassContext.forEach {
-            substitution[it.getTypeConstructor()] = TypeProjectionImpl(it.getUpperBoundsAsType())
+            substitution[it.typeConstructor] = TypeProjectionImpl(it.upperBoundsAsType)
         }
 
-        val superClassSubstitution = getTypeSubstitution(targetClassDescriptor.getDefaultType(), sourceClassDescriptor.getDefaultType())
+        val superClassSubstitution = getTypeSubstitution(targetClassDescriptor.defaultType, sourceClassDescriptor.defaultType)
                                      ?: emptyMap<TypeConstructor, TypeProjection>()
         for ((typeConstructor, typeProjection) in superClassSubstitution) {
-            val subClassTypeParameter = typeProjection.getType().getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor
+            val subClassTypeParameter = typeProjection.type.constructor.declarationDescriptor as? TypeParameterDescriptor
                                         ?: continue
-            val superClassTypeParameter = typeConstructor.getDeclarationDescriptor()
+            val superClassTypeParameter = typeConstructor.declarationDescriptor
                                           ?: continue
-            substitution[subClassTypeParameter.getTypeConstructor()] = TypeProjectionImpl(superClassTypeParameter.getDefaultType())
+            substitution[subClassTypeParameter.typeConstructor] = TypeProjectionImpl(superClassTypeParameter.defaultType)
         }
 
         TypeSubstitutor.create(substitution)

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt

@@ -52,21 +52,21 @@ public class KotlinPullUpDialog(
          * Classes do not have abstractness
          */
         override fun isAbstractEnabled(memberInfo: KotlinMemberInfo): Boolean {
-            val superClass = getSuperClass() ?: return false
+            val superClass = superClass ?: return false
             if (!superClass.isInterface()) return true
 
-            val member = memberInfo.getMember()
+            val member = memberInfo.member
             return member is JetNamedFunction || (member is JetProperty && !member.mustBeAbstractInInterface())
         }
 
         override fun isAbstractWhenDisabled(memberInfo: KotlinMemberInfo): Boolean {
-            return memberInfo.getMember() is JetProperty
+            return memberInfo.member is JetProperty
         }
 
         override fun isMemberEnabled(memberInfo: KotlinMemberInfo): Boolean {
-            val superClass = getSuperClass() ?: return false
+            val superClass = superClass ?: return false
             if (memberInfo in memberInfoStorage.getDuplicatedMemberInfos(superClass)) return false
-            if (memberInfo.getMember() in memberInfoStorage.getExtending(superClass)) return false
+            if (memberInfo.member in memberInfoStorage.getExtending(superClass)) return false
             return true
         }
     }
@@ -75,7 +75,7 @@ public class KotlinPullUpDialog(
 
     protected val sourceClass: JetClassOrObject get() = myClass
 
-    override fun getDimensionServiceKey() = "#" + javaClass.getName()
+    override fun getDimensionServiceKey() = "#" + javaClass.name
 
     override fun getSuperClass() = super.getSuperClass() as? JetClass
 
@@ -87,8 +87,8 @@ public class KotlinPullUpDialog(
             KotlinMemberSelectionTable(infos, null, "Make abstract")
 
     override fun doAction() {
-        val selectedMembers = getSelectedMemberInfos()
-        val targetClass = getSuperClass()!!
+        val selectedMembers = selectedMemberInfos
+        val targetClass = superClass!!
         checkConflicts(getProject(), sourceClass, targetClass, selectedMembers, { close(DialogWrapper.OK_EXIT_CODE) }) {
             invokeRefactoring(createProcessor(sourceClass, targetClass, selectedMembers))
         }

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt

@@ -75,11 +75,11 @@ public class KotlinPullUpHandler : RefactoringActionHandler, ElementsHandler {
     }
 
     override fun invoke(project: Project, editor: Editor, file: PsiFile, dataContext: DataContext?) {
-        val offset = editor.getCaretModel().getOffset()
-        editor.getScrollingModel().scrollToCaret(ScrollType.MAKE_VISIBLE)
+        val offset = editor.caretModel.offset
+        editor.scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE)
 
         val target = (file.findElementAt(offset) ?: return).parentsWithSelf.firstOrNull {
-            it is JetClassOrObject || ((it is JetNamedFunction || it is JetProperty) && it.getParent() is JetClassBody)
+            it is JetClassOrObject || ((it is JetNamedFunction || it is JetProperty) && it.parent is JetClassBody)
         }
 
         if (target == null) {
@@ -119,11 +119,11 @@ public class KotlinPullUpHandler : RefactoringActionHandler, ElementsHandler {
         }
 
         val classDescriptor = classOrObject.resolveToDescriptor() as ClassDescriptor
-        val superClasses = classDescriptor.getDefaultType()
+        val superClasses = classDescriptor.defaultType
                 .supertypes()
                 .asSequence()
                 .map {
-                    val descriptor = it.getConstructor().getDeclarationDescriptor()
+                    val descriptor = it.constructor.declarationDescriptor
                     val declaration = descriptor?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
                     if (declaration is JetClass && declaration.canRefactor()) declaration else null
                 }
@@ -144,7 +144,7 @@ public class KotlinPullUpHandler : RefactoringActionHandler, ElementsHandler {
         val memberInfoStorage = KotlinMemberInfoStorage(classOrObject)
         val members = memberInfoStorage.getClassMemberInfos(classOrObject)
 
-        if (ApplicationManager.getApplication().isUnitTestMode()) {
+        if (ApplicationManager.getApplication().isUnitTestMode) {
             val helper = dataContext?.getData(PULLUP_TEST_HELPER_KEY) as TestHelper
             val selectedMembers = helper.adjustMembers(members)
             val targetClass = helper.chooseSuperClass(superClasses)
@@ -153,8 +153,8 @@ public class KotlinPullUpHandler : RefactoringActionHandler, ElementsHandler {
             }
         }
         else {
-            val manager = classOrObject.getManager()
-            members.filter { manager.areElementsEquivalent(it.getMember(), member) }.forEach { it.setChecked(true) }
+            val manager = classOrObject.manager
+            members.filter { manager.areElementsEquivalent(it.member, member) }.forEach { it.isChecked = true }
 
             KotlinPullUpDialog(project, classOrObject, superClasses, memberInfoStorage).show()
         }
@@ -164,7 +164,7 @@ public class KotlinPullUpHandler : RefactoringActionHandler, ElementsHandler {
         return elements.mapTo(HashSet<PsiElement>()) {
             when (it) {
                 is JetNamedFunction, is JetProperty ->
-                    (it.getParent() as? JetClassBody)?.getParent() as? JetClassOrObject
+                    (it.parent as? JetClassBody)?.parent as? JetClassOrObject
                 is JetClassOrObject -> it
                 else -> null
             } ?: return false

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt

@@ -78,19 +78,19 @@ class KotlinPullUpHelper(
 
                     override fun visitSimpleNameExpression(expression: JetSimpleNameExpression, arg: Nothing?): Boolean {
                         val resolvedCall = expression.getResolvedCall(data.resolutionFacade.analyze(expression)) ?: return true
-                        val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.getExpression()
+                        val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.expression
                         if (receiver != null && receiver !is JetThisExpression && receiver !is JetSuperExpression) return true
 
-                        var descriptor: DeclarationDescriptor = resolvedCall.getResultingDescriptor()
+                        var descriptor: DeclarationDescriptor = resolvedCall.resultingDescriptor
                         if (descriptor is ConstructorDescriptor) {
-                            descriptor = descriptor.getContainingDeclaration()
+                            descriptor = descriptor.containingDeclaration
                         }
                         // todo: local functions
                         if (descriptor is ValueParameterDescriptor) return true
-                        if (descriptor is ClassDescriptor && !descriptor.isInner()) return true
+                        if (descriptor is ClassDescriptor && !descriptor.isInner) return true
                         if (descriptor is MemberDescriptor) {
-                            if (descriptor.getSource().getPsi() in propertiesToMoveInitializers) return true
-                            descriptor = descriptor.getContainingDeclaration()
+                            if (descriptor.source.getPsi() in propertiesToMoveInitializers) return true
+                            descriptor = descriptor.containingDeclaration
                         }
                         return descriptor is PackageFragmentDescriptor
                                || (descriptor is ClassDescriptor && DescriptorUtils.isSubclass(data.targetClassDescriptor, descriptor))
@@ -109,14 +109,14 @@ class KotlinPullUpHelper(
 
         var initializerCandidate: JetExpression? = null
 
-        for (statement in scope.getStatements()) {
+        for (statement in scope.statements) {
             statement.asAssignment()?.let body@ {
-                val lhs = JetPsiUtil.safeDeparenthesize(it.getLeft() ?: return@body)
-                val receiver = (lhs as? JetQualifiedExpression)?.getReceiverExpression()
+                val lhs = JetPsiUtil.safeDeparenthesize(it.left ?: return@body)
+                val receiver = (lhs as? JetQualifiedExpression)?.receiverExpression
                 if (receiver != null && receiver !is JetThisExpression) return@body
 
                 val resolvedCall = lhs.getResolvedCall(data.resolutionFacade.analyze(it)) ?: return@body
-                if (resolvedCall.getResultingDescriptor() != propertyDescriptor) return@body
+                if (resolvedCall.resultingDescriptor != propertyDescriptor) return@body
 
                 if (initializerCandidate == null) {
                     if (currentInitializer == null) {
@@ -152,7 +152,7 @@ class KotlinPullUpHelper(
         val sourceConstructors = targetToSourceConstructors[targetConstructor] ?: return null
         val elementsToRemove = LinkedHashSet<JetElement>()
         val commonInitializer = sourceConstructors.fold(null as JetExpression?) { commonInitializer, constructor ->
-            val body = (constructor as? JetSecondaryConstructor)?.getBodyExpression()
+            val body = (constructor as? JetSecondaryConstructor)?.bodyExpression
             getCommonInitializer(commonInitializer, body, propertyDescriptor, elementsToRemove)
         }
         if (commonInitializer == null) {
@@ -165,9 +165,9 @@ class KotlinPullUpHelper(
             override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
                 val context = data.resolutionFacade.analyze(expression)
                 val resolvedCall = expression.getResolvedCall(context) ?: return
-                val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.getExpression()
+                val receiver = (resolvedCall.getExplicitReceiverValue() as? ExpressionReceiver)?.expression
                 if (receiver != null && receiver !is JetThisExpression) return
-                val target = (resolvedCall.getResultingDescriptor() as? DeclarationDescriptorWithSource)?.getSource()?.getPsi()
+                val target = (resolvedCall.resultingDescriptor as? DeclarationDescriptorWithSource)?.source?.getPsi()
                 when (target) {
                     is JetParameter -> usedParameters.add(target)
                     is JetProperty -> usedProperties.add(target)
@@ -176,7 +176,7 @@ class KotlinPullUpHelper(
         }
         commonInitializer?.accept(visitor)
         if (targetConstructor == data.targetClass.getPrimaryConstructor() ?: data.targetClass) {
-            property.getInitializer()?.accept(visitor)
+            property.initializer?.accept(visitor)
         }
 
         return InitializerInfo(commonInitializer, usedProperties, usedParameters, elementsToRemove)
@@ -198,7 +198,7 @@ class KotlinPullUpHelper(
                     object : JetTreeVisitorVoid() {
                         private fun processConstructorReference(expression: JetReferenceExpression, callingConstructorElement: JetElement) {
                             val descriptor = data.resolutionFacade.analyze(expression)[BindingContext.REFERENCE_TARGET, expression]
-                            val constructorElement = (descriptor as? DeclarationDescriptorWithSource)?.getSource()?.getPsi() ?: return
+                            val constructorElement = (descriptor as? DeclarationDescriptorWithSource)?.source?.getPsi() ?: return
                             if (constructorElement == data.targetClass
                                 || (constructorElement as? JetConstructor<*>)?.getContainingClassOrObject() == data.targetClass) {
                                 result.getOrPut(constructorElement as JetElement, { ArrayList() }).add(callingConstructorElement)
@@ -206,14 +206,14 @@ class KotlinPullUpHelper(
                         }
 
                         override fun visitDelegationToSuperCallSpecifier(specifier: JetDelegatorToSuperCall) {
-                            val constructorRef = specifier.getCalleeExpression().getConstructorReferenceExpression() ?: return
+                            val constructorRef = specifier.calleeExpression.constructorReferenceExpression ?: return
                             val containingClass = specifier.getStrictParentOfType<JetClassOrObject>() ?: return
                             val callingConstructorElement = containingClass.getPrimaryConstructor() ?: containingClass
                             processConstructorReference(constructorRef, callingConstructorElement)
                         }
 
                         override fun visitSecondaryConstructor(constructor: JetSecondaryConstructor) {
-                            val constructorRef = constructor.getDelegationCall().getCalleeExpression() ?: return
+                            val constructorRef = constructor.getDelegationCall().calleeExpression ?: return
                             processConstructorReference(constructorRef, constructor)
                         }
                     }
@@ -250,25 +250,25 @@ class KotlinPullUpHelper(
         if (newMember is JetProperty) {
             // Add dummy light field since PullUpProcessor won't invoke moveFieldInitializations() if no PsiFields are present
             if (dummyField == null) {
-                val factory = JavaPsiFacade.getElementFactory(newMember.getProject())
+                val factory = JavaPsiFacade.getElementFactory(newMember.project)
                 val dummyField = object: LightField(
-                        newMember.getManager(),
+                        newMember.manager,
                         factory.createField("dummy", PsiType.BOOLEAN),
                         factory.createClass("Dummy")
                 ) {
                     // Prevent processing by JavaPullUpHelper
                     override fun getLanguage() = JetLanguage.INSTANCE
                 }
-                javaData.getMovedMembers().add(dummyField)
+                javaData.movedMembers.add(dummyField)
             }
         }
 
         when (newMember) {
             is JetProperty, is JetNamedFunction -> {
-                newMember.getRepresentativeLightMethod()?.let { javaData.getMovedMembers().add(it) }
+                newMember.getRepresentativeLightMethod()?.let { javaData.movedMembers.add(it) }
             }
             is JetClassOrObject -> {
-                newMember.toLightClass()?.let { javaData.getMovedMembers().add(it) }
+                newMember.toLightClass()?.let { javaData.movedMembers.add(it) }
             }
         }
     }
@@ -276,7 +276,7 @@ class KotlinPullUpHelper(
     private fun willBeUsedInSourceClass(member: PsiElement): Boolean {
         return !ReferencesSearch
                 .search(member, LocalSearchScope(data.sourceClass), false)
-                .all { it.getElement().parentsWithSelf.any { it in data.membersToMove } }
+                .all { it.element.parentsWithSelf.any { it in data.membersToMove } }
     }
 
     private fun liftToProtected(declaration: JetNamedDeclaration, ignoreUsages: Boolean = false) {
@@ -285,7 +285,7 @@ class KotlinPullUpHelper(
     }
 
     override fun setCorrectVisibility(info: MemberInfoBase<PsiMember>) {
-        val member = info.getMember().namedUnwrappedElement as? JetNamedDeclaration ?: return
+        val member = info.member.namedUnwrappedElement as? JetNamedDeclaration ?: return
 
         if (data.targetClass.isInterface()) {
             member.removeModifier(JetTokens.PUBLIC_KEYWORD)
@@ -299,10 +299,10 @@ class KotlinPullUpHelper(
                             when (declaration) {
                                 is JetClass -> {
                                     liftToProtected(declaration)
-                                    declaration.getDeclarations().forEach { it.accept(this) }
+                                    declaration.declarations.forEach { it.accept(this) }
                                 }
                                 is JetNamedFunction, is JetProperty -> {
-                                    liftToProtected(declaration, declaration == member && info.isToAbstract())
+                                    liftToProtected(declaration, declaration == member && info.isToAbstract)
                                 }
                             }
                         }
@@ -319,16 +319,16 @@ class KotlinPullUpHelper(
                                                targetMember: JetCallableDeclaration): JetCallableDeclaration? {
         val memberDescriptor = data.memberDescriptors[sourceMember] as CallableMemberDescriptor
 
-        if (memberDescriptor.getOverriddenDescriptors().isEmpty()) {
+        if (memberDescriptor.overriddenDescriptors.isEmpty()) {
             targetMember.removeOverrideModifier()
             return null
         }
 
         val clashingSuperDescriptor = data.getClashingMemberInTargetClass(memberDescriptor) ?: return null
-        if (clashingSuperDescriptor.getOverriddenDescriptors().isEmpty()) {
+        if (clashingSuperDescriptor.overriddenDescriptors.isEmpty()) {
             targetMember.removeOverrideModifier()
         }
-        return clashingSuperDescriptor.getSource().getPsi() as? JetCallableDeclaration
+        return clashingSuperDescriptor.source.getPsi() as? JetCallableDeclaration
     }
 
     private fun makeAbstract(sourceMember: JetCallableDeclaration, targetMember: JetCallableDeclaration) {
@@ -336,14 +336,14 @@ class KotlinPullUpHelper(
             targetMember.addModifierWithSpace(JetTokens.ABSTRACT_KEYWORD)
         }
 
-        if (sourceMember.getTypeReference() == null) {
-            var type = (data.memberDescriptors[sourceMember] as CallableMemberDescriptor).getReturnType()
-            if (type == null || type.isError()) {
-                type = KotlinBuiltIns.getInstance().getNullableAnyType()
+        if (sourceMember.typeReference == null) {
+            var type = (data.memberDescriptors[sourceMember] as CallableMemberDescriptor).returnType
+            if (type == null || type.isError) {
+                type = KotlinBuiltIns.getInstance().nullableAnyType
             }
             else {
                 type = data.sourceToTargetClassSubstitutor.substitute(type, Variance.INVARIANT)
-                       ?: KotlinBuiltIns.getInstance().getNullableAnyType()
+                       ?: KotlinBuiltIns.getInstance().nullableAnyType
             }
 
             if (sourceMember is JetProperty || !type.isUnit()) {
@@ -355,25 +355,25 @@ class KotlinPullUpHelper(
         val deleteFrom = when (sourceMember) {
             is JetProperty -> {
                 targetMember as JetProperty
-                val accessors = targetMember.getAccessors()
-                targetMember.getEqualsToken() ?: targetMember.getDelegate() ?: accessors.firstOrNull()
+                val accessors = targetMember.accessors
+                targetMember.equalsToken ?: targetMember.delegate ?: accessors.firstOrNull()
             }
 
             is JetNamedFunction -> {
                 targetMember as JetNamedFunction
-                targetMember.getEqualsToken() ?: targetMember.getBodyExpression()
+                targetMember.equalsToken ?: targetMember.bodyExpression
             }
 
             else -> null
         }
 
         if (deleteFrom != null) {
-            targetMember.deleteChildRange(deleteFrom, targetMember.getLastChild())
+            targetMember.deleteChildRange(deleteFrom, targetMember.lastChild)
         }
     }
 
     private fun addMemberToTarget(targetMember: JetNamedDeclaration): JetNamedDeclaration {
-        val anchor = data.targetClass.getDeclarations().filterIsInstance(targetMember.javaClass).lastOrNull()
+        val anchor = data.targetClass.declarations.filterIsInstance(targetMember.javaClass).lastOrNull()
         val movedMember = when {
             anchor == null && targetMember is JetProperty -> data.targetClass.addDeclarationBefore(targetMember, null)
             else -> data.targetClass.addDeclarationAfter(targetMember, anchor)
@@ -394,7 +394,7 @@ class KotlinPullUpHelper(
         member.accept(
                 object: JetVisitorVoid() {
                     private fun visitSuperOrThis(expression: JetInstanceExpressionWithLabel) {
-                        val referenceTarget = data.sourceClassContext[BindingContext.REFERENCE_TARGET, expression.getInstanceReference()]
+                        val referenceTarget = data.sourceClassContext[BindingContext.REFERENCE_TARGET, expression.instanceReference]
                         if (referenceTarget == data.targetClassDescriptor) {
                             expression.replaceWithTargetThis = true
                             affectedElements.add(expression)
@@ -409,15 +409,15 @@ class KotlinPullUpHelper(
                         val resolvedCall = expression.getResolvedCall(data.sourceClassContext) ?: return
                         var receiver = resolvedCall.getExplicitReceiverValue()
                         if (!receiver.exists()) {
-                            receiver = resolvedCall.getExtensionReceiver()
+                            receiver = resolvedCall.extensionReceiver
                         }
                         if (!receiver.exists()) {
-                            receiver = resolvedCall.getDispatchReceiver()
+                            receiver = resolvedCall.dispatchReceiver
                         }
                         if (!receiver.exists()) return
 
-                        val implicitThis = receiver.getType().getConstructor().getDeclarationDescriptor() as? ClassDescriptor ?: return
-                        if (implicitThis.isCompanionObject()
+                        val implicitThis = receiver.type.constructor.declarationDescriptor as? ClassDescriptor ?: return
+                        if (implicitThis.isCompanionObject
                             && DescriptorUtils.isAncestor(data.sourceClassDescriptor, implicitThis, true)) {
                             val qualifierFqName = implicitThis.importableFqName ?: return
 
@@ -448,7 +448,7 @@ class KotlinPullUpHelper(
 
     private fun processMarkedElements(member: JetNamedDeclaration) {
         val psiFactory = JetPsiFactory(member)
-        val targetThis = psiFactory.createExpression("this@${data.targetClassDescriptor.getName().asString()}")
+        val targetThis = psiFactory.createExpression("this@${data.targetClassDescriptor.name.asString()}")
         val shorteningOptionsForThis = ShortenReferences.Options(removeThisLabels = true, removeThis = true)
 
         member.accept(
@@ -506,7 +506,7 @@ class KotlinPullUpHelper(
     // TODO: Formatting rules don't apply here for some reason
     private fun JetNamedDeclaration.addModifierWithSpace(modifier: JetModifierKeywordToken) {
         addModifier(modifier)
-        addAfter(JetPsiFactory(this).createWhiteSpace(), getModifierList())
+        addAfter(JetPsiFactory(this).createWhiteSpace(), modifierList)
     }
 
     private fun moveSuperInterface(member: JetClass) {
@@ -518,13 +518,13 @@ class KotlinPullUpHelper(
                 data.sourceClass.getDelegationSpecifiers()
                         .filterIsInstance<JetDelegatorToSuperClass>()
                         .firstOrNull {
-                            val referencedType = data.sourceClassContext[BindingContext.TYPE, it.getTypeReference()]
-                            referencedType?.getConstructor()?.getDeclarationDescriptor() == classDescriptor
+                            val referencedType = data.sourceClassContext[BindingContext.TYPE, it.typeReference]
+                            referencedType?.constructor?.declarationDescriptor == classDescriptor
                         } ?: return
         data.sourceClass.removeDelegationSpecifier(currentSpecifier)
 
         if (!DescriptorUtils.isSubclass(data.targetClassDescriptor, classDescriptor)) {
-            val referencedType = data.sourceClassContext[BindingContext.TYPE, currentSpecifier.getTypeReference()]!!
+            val referencedType = data.sourceClassContext[BindingContext.TYPE, currentSpecifier.typeReference]!!
             val typeInTargetClass = data.sourceToTargetClassSubstitutor.substitute(referencedType, Variance.INVARIANT)
             if (typeInTargetClass != null && !typeInTargetClass.isError) {
                 val renderedType = IdeDescriptorRenderers.SOURCE_CODE.renderType(typeInTargetClass)
@@ -536,9 +536,9 @@ class KotlinPullUpHelper(
     }
 
     override fun move(info: MemberInfoBase<PsiMember>, substitutor: PsiSubstitutor) {
-        val member = info.getMember().namedUnwrappedElement as? JetNamedDeclaration ?: return
+        val member = info.member.namedUnwrappedElement as? JetNamedDeclaration ?: return
 
-        if (member is JetClass && info.getOverrides() != null)  {
+        if (member is JetClass && info.overrides != null)  {
             moveSuperInterface(member)
             return
         }
@@ -561,7 +561,7 @@ class KotlinPullUpHelper(
 
             val originalIsAbstract = member.hasModifier(JetTokens.ABSTRACT_KEYWORD)
             val toAbstract = when {
-                info.isToAbstract() -> true
+                info.isToAbstract -> true
                 !data.targetClass.isInterface() -> false
                 member is JetProperty -> member.mustBeAbstractInInterface()
                 else -> false
@@ -572,8 +572,8 @@ class KotlinPullUpHelper(
                 }
 
                 movedMember = doAddCallableMember(memberCopy, clashingSuper)
-                if (member.getTypeReference() == null) {
-                    movedMember.getTypeReference()?.addToShorteningWaitSet()
+                if (member.typeReference == null) {
+                    movedMember.typeReference?.addToShorteningWaitSet()
                 }
                 if (originalIsAbstract) {
                     member.delete()
@@ -622,20 +622,20 @@ class KotlinPullUpHelper(
         val psiFactory = JetPsiFactory(data.sourceClass)
 
         fun JetClassOrObject.getOrCreateClassInitializer(): JetClassInitializer {
-            getOrCreateBody().getDeclarations().lastOrNull { it is JetClassInitializer }?.let { return it as JetClassInitializer }
+            getOrCreateBody().declarations.lastOrNull { it is JetClassInitializer }?.let { return it as JetClassInitializer }
             return addDeclaration(psiFactory.createAnonymousInitializer()) as JetClassInitializer
         }
 
         fun JetElement.getConstructorBodyBlock(): JetBlockExpression? {
             return when (this) {
                 is JetClassOrObject -> {
-                    getOrCreateClassInitializer().getBody()
+                    getOrCreateClassInitializer().body
                 }
                 is JetPrimaryConstructor -> {
-                    getContainingClassOrObject().getOrCreateClassInitializer().getBody()
+                    getContainingClassOrObject().getOrCreateClassInitializer().body
                 }
                 is JetSecondaryConstructor -> {
-                    getBodyExpression() ?: add(psiFactory.createEmptyBody())
+                    bodyExpression ?: add(psiFactory.createEmptyBody())
                 }
                 else -> null
             } as? JetBlockExpression
@@ -670,9 +670,9 @@ class KotlinPullUpHelper(
                     }
                     else -> null
                 }
-                superCall?.getValueArgumentList()?.let { args ->
+                superCall?.valueArgumentList?.let { args ->
                     info.usedParameters.forEach {
-                        args.addArgument(psiFactory.createArgument(psiFactory.createExpression(it.getName() ?: "_")))
+                        args.addArgument(psiFactory.createArgument(psiFactory.createExpression(it.name ?: "_")))
                     }
                 }
             }
@@ -700,7 +700,7 @@ class KotlinPullUpHelper(
 
                 info.initializer?.let {
                     val body = constructorElement.getConstructorBodyBlock()
-                    body?.addAfter(it, body.getStatements().lastOrNull() ?: body.getLBrace()!!)
+                    body?.addAfter(it, body.statements.lastOrNull() ?: body.lBrace!!)
                 }
                 info.elementsToRemove.forEach { it.delete() }
             }

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt

@@ -28,10 +28,10 @@ import org.jetbrains.kotlin.psi.psiUtil.startOffset
 
 public class KotlinPullUpHelperFactory : PullUpHelperFactory {
     private fun PullUpData.toKotlinPullUpData(): KotlinPullUpData? {
-        if (!getSourceClass().isInheritor(getTargetClass(), true)) return null
-        val sourceClass = getSourceClass().unwrapped as? JetClassOrObject ?: return null
-        val targetClass = getTargetClass().unwrapped as? JetClass ?: return null
-        val membersToMove = getMembersToMove()
+        if (!sourceClass.isInheritor(targetClass, true)) return null
+        val sourceClass = sourceClass.unwrapped as? JetClassOrObject ?: return null
+        val targetClass = targetClass.unwrapped as? JetClass ?: return null
+        val membersToMove = membersToMove
                 .map { it.namedUnwrappedElement as? JetNamedDeclaration }
                 .filterNotNull()
                 .sortBy { it.startOffset }

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt

@@ -19,10 +19,7 @@ package org.jetbrains.kotlin.idea.refactoring.pullUp
 import com.intellij.openapi.project.Project
 import com.intellij.psi.PsiElement
 import com.intellij.refactoring.RefactoringBundle
-import com.intellij.refactoring.util.CommonRefactoringUtil
-import com.intellij.refactoring.util.RefactoringUIUtil
 import com.intellij.util.containers.MultiMap
-import org.jetbrains.kotlin.asJava.toLightClass
 import org.jetbrains.kotlin.asJava.unwrapped
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.idea.core.refactoring.checkConflictsInteractively
@@ -30,18 +27,12 @@ import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
 import org.jetbrains.kotlin.idea.references.JetReference
 import org.jetbrains.kotlin.idea.search.declarationsSearch.HierarchySearchRequest
 import org.jetbrains.kotlin.idea.search.declarationsSearch.searchInheritors
-import org.jetbrains.kotlin.idea.search.usagesSearch.DefaultSearchHelper
-import org.jetbrains.kotlin.idea.search.usagesSearch.UsagesSearchTarget
-import org.jetbrains.kotlin.idea.search.usagesSearch.search
 import org.jetbrains.kotlin.idea.util.IdeDescriptorRenderers
 import org.jetbrains.kotlin.lexer.JetTokens
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.allChildren
-import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType
 import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
-import org.jetbrains.kotlin.resolve.DescriptorUtils
-import org.jetbrains.kotlin.resolve.calls.callUtil.getResolvedCall
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
 import org.jetbrains.kotlin.resolve.source.getPsi
 import org.jetbrains.kotlin.types.TypeSubstitutor
@@ -57,11 +48,11 @@ fun checkConflicts(project: Project,
                    onAccept: () -> Unit) {
     val conflicts = MultiMap<PsiElement, String>()
 
-    val pullUpData = KotlinPullUpData(sourceClass, targetClass, memberInfos.map { it.getMember() })
+    val pullUpData = KotlinPullUpData(sourceClass, targetClass, memberInfos.map { it.member })
 
     with(pullUpData) {
         for (memberInfo in memberInfos) {
-            val member = memberInfo.getMember()
+            val member = memberInfo.member
             val memberDescriptor = resolutionFacade.resolveToDescriptor(member)
 
             checkClashWithSuperDeclaration(member, memberDescriptor, conflicts)
@@ -101,7 +92,7 @@ private fun KotlinPullUpData.checkClashWithSuperDeclaration(
         conflicts: MultiMap<PsiElement, String>) {
     if (memberDescriptor is CallableMemberDescriptor) {
         val clashingSuper = getClashingMemberInTargetClass(memberDescriptor)
-        if (clashingSuper != null && clashingSuper.getModality() != Modality.ABSTRACT) {
+        if (clashingSuper != null && clashingSuper.modality != Modality.ABSTRACT) {
             val message = "${targetClassDescriptor.renderForConflicts()} already contains ${memberDescriptor.renderForConflicts()}"
             conflicts.putValue(member, message.capitalize())
         }
@@ -115,7 +106,7 @@ private fun KotlinPullUpData.checkAccidentalOverrides(
     if (memberDescriptor is CallableDescriptor && !member.hasModifier(JetTokens.PRIVATE_KEYWORD)) {
         val memberDescriptorInTargetClass = memberDescriptor.substitute(sourceToTargetClassSubstitutor)
         if (memberDescriptorInTargetClass != null) {
-            HierarchySearchRequest<PsiElement>(targetClass, targetClass.getUseScope())
+            HierarchySearchRequest<PsiElement>(targetClass, targetClass.useScope)
                     .searchInheritors()
                     .asSequence()
                     .filterNot { it.unwrapped == sourceClass || it.unwrapped == targetClass }
@@ -123,13 +114,13 @@ private fun KotlinPullUpData.checkAccidentalOverrides(
                     .filterNotNull()
                     .forEach {
                         val subClassDescriptor = resolutionFacade.resolveToDescriptor(it) as ClassDescriptor
-                        val substitutor = getTypeSubstitutor(targetClassDescriptor.getDefaultType(),
-                                                             subClassDescriptor.getDefaultType()) ?: TypeSubstitutor.EMPTY
+                        val substitutor = getTypeSubstitutor(targetClassDescriptor.defaultType,
+                                                             subClassDescriptor.defaultType) ?: TypeSubstitutor.EMPTY
                         val memberDescriptorInSubClass =
                                 memberDescriptorInTargetClass.substitute(substitutor) as? CallableMemberDescriptor
                         val clashingMemberDescriptor =
                                 memberDescriptorInSubClass?.let { subClassDescriptor.findCallableMemberBySignature(it) } ?: return
-                        val clashingMember = clashingMemberDescriptor.getSource().getPsi() ?: return
+                        val clashingMember = clashingMemberDescriptor.source.getPsi() ?: return
 
                         val message = memberDescriptor.renderForConflicts() +
                                       " in super class would clash with existing member of " +
@@ -144,7 +135,7 @@ private fun KotlinPullUpData.checkInnerClassToInterface(
         member: JetNamedDeclaration,
         memberDescriptor: DeclarationDescriptor,
         conflicts: MultiMap<PsiElement, String>) {
-    if (targetClass.isInterface() && memberDescriptor is ClassDescriptor && memberDescriptor.isInner()) {
+    if (targetClass.isInterface() && memberDescriptor is ClassDescriptor && memberDescriptor.isInner) {
         val message = "${memberDescriptor.renderForConflicts()} is an inner class. It can not be moved to the interface"
         conflicts.putValue(member, message.capitalize())
     }
@@ -156,7 +147,7 @@ private fun KotlinPullUpData.checkVisibility(
         conflicts: MultiMap<PsiElement, String>
 ) {
     fun reportConflictIfAny(targetDescriptor: DeclarationDescriptor) {
-        val target = (targetDescriptor as? DeclarationDescriptorWithSource)?.getSource()?.getPsi() ?: return
+        val target = (targetDescriptor as? DeclarationDescriptorWithSource)?.source?.getPsi() ?: return
         if (targetDescriptor is DeclarationDescriptorWithVisibility
             && !Visibilities.isVisible(ReceiverValue.IRRELEVANT_RECEIVER, targetDescriptor, targetClassDescriptor)) {
             val message = RefactoringBundle.message(
@@ -168,22 +159,22 @@ private fun KotlinPullUpData.checkVisibility(
         }
     }
 
-    val member = memberInfo.getMember()
+    val member = memberInfo.member
     val childrenToCheck = member.allChildren.toArrayList()
-    if (memberInfo.isToAbstract() && member is JetCallableDeclaration) {
+    if (memberInfo.isToAbstract && member is JetCallableDeclaration) {
         when (member) {
-            is JetNamedFunction -> childrenToCheck.remove(member.getBodyExpression())
+            is JetNamedFunction -> childrenToCheck.remove(member.bodyExpression)
             is JetProperty -> {
-                childrenToCheck.remove(member.getInitializer())
-                childrenToCheck.remove(member.getDelegateExpression())
-                childrenToCheck.removeAll(member.getAccessors())
+                childrenToCheck.remove(member.initializer)
+                childrenToCheck.remove(member.delegateExpression)
+                childrenToCheck.removeAll(member.accessors)
             }
         }
 
-        if (member.getTypeReference() == null) {
-            (memberDescriptor as CallableDescriptor).getReturnType()?.let { returnType ->
+        if (member.typeReference == null) {
+            (memberDescriptor as CallableDescriptor).returnType?.let { returnType ->
                 val typeInTargetClass = sourceToTargetClassSubstitutor.substitute(returnType, Variance.INVARIANT)
-                val descriptorToCheck = typeInTargetClass?.getConstructor()?.getDeclarationDescriptor() as? ClassDescriptor
+                val descriptorToCheck = typeInTargetClass?.constructor?.declarationDescriptor as? ClassDescriptor
                 if (descriptorToCheck != null) {
                     reportConflictIfAny(descriptorToCheck)
                 }
@@ -198,7 +189,7 @@ private fun KotlinPullUpData.checkVisibility(
                         super.visitReferenceExpression(expression)
 
                         val context = resolutionFacade.analyze(expression)
-                        expression.getReferences()
+                        expression.references
                                 .flatMap { (it as? JetReference)?.resolveToDescriptors(context) ?: emptyList() }
                                 .forEach(::reportConflictIfAny)
 

idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt

@@ -19,4 +19,4 @@ package org.jetbrains.kotlin.idea.refactoring.pullUp
 import org.jetbrains.kotlin.psi.JetProperty
 
 fun JetProperty.mustBeAbstractInInterface() =
-        hasInitializer() || hasDelegate() || (!hasInitializer() && !hasDelegate() && getAccessors().isEmpty())
+        hasInitializer() || hasDelegate() || (!hasInitializer() && !hasDelegate() && accessors.isEmpty())

idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/AbstractPullUpTest.kt

@@ -17,23 +17,21 @@
 package org.jetbrains.kotlin.idea.refactoring.pullUp
 
 import com.google.gson.JsonParser
-import com.intellij.openapi.actionSystem.DataContext
 import com.intellij.openapi.util.Key
-import com.intellij.openapi.util.io.FileUtil
 import com.intellij.refactoring.BaseRefactoringProcessor
 import com.intellij.refactoring.util.CommonRefactoringUtil
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase
 import org.jetbrains.kotlin.idea.refactoring.memberInfo.KotlinMemberInfo
-import org.jetbrains.kotlin.idea.stubindex.JetFullClassNameIndex
 import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
 import org.jetbrains.kotlin.idea.test.JetLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
 import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
-import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.JetClass
+import org.jetbrains.kotlin.psi.JetElement
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.psi.NotNullableUserDataProperty
 import org.jetbrains.kotlin.test.InTextDirectivesUtils
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.test.util.findElementByCommentPrefix
 import org.jetbrains.kotlin.test.util.findElementsByCommentPrefix
 import java.io.File
 
@@ -56,37 +54,37 @@ public abstract class AbstractPullUpTest : JetLightCodeInsightFixtureTestCase()
         val afterFile = File("$path.after")
         val conflictFile = File("$path.messages")
 
-        fixture.setTestDataPath("${JetTestUtils.getHomeDirectory()}/${mainFile.getParent()}")
+        fixture.testDataPath = "${JetTestUtils.getHomeDirectory()}/${mainFile.getParent()}"
 
         val mainFileName = mainFile.getName()
         val file = fixture.configureByFile(mainFileName) as JetFile
 
-        val addKotlinRuntime = InTextDirectivesUtils.findStringWithPrefixes(file.getText(), "// WITH_RUNTIME") != null
+        val addKotlinRuntime = InTextDirectivesUtils.findStringWithPrefixes(file.text, "// WITH_RUNTIME") != null
         if (addKotlinRuntime) {
             ConfigLibraryUtil.configureKotlinRuntimeAndSdk(myModule, PluginTestCaseBase.mockJdk())
         }
 
         try {
             for ((element, info) in file.findElementsByCommentPrefix("// INFO: ")) {
-                val parsedInfo = JsonParser().parse(info).getAsJsonObject()
-                element.elementInfo = ElementInfo(parsedInfo["checked"]?.getAsBoolean() ?: false,
-                                                  parsedInfo["toAbstract"]?.getAsBoolean() ?: false)
+                val parsedInfo = JsonParser().parse(info).asJsonObject
+                element.elementInfo = ElementInfo(parsedInfo["checked"]?.asBoolean ?: false,
+                                                  parsedInfo["toAbstract"]?.asBoolean ?: false)
             }
-            val targetClassName = InTextDirectivesUtils.findStringWithPrefixes(file.getText(), "// TARGET_CLASS: ")
+            val targetClassName = InTextDirectivesUtils.findStringWithPrefixes(file.text, "// TARGET_CLASS: ")
 
             val helper = object: KotlinPullUpHandler.TestHelper {
                 override fun adjustMembers(members: List<KotlinMemberInfo>): List<KotlinMemberInfo> {
                     members.forEach {
-                        val info = it.getMember().elementInfo
-                        it.setChecked(info.checked)
-                        it.setToAbstract(info.toAbstract)
+                        val info = it.member.elementInfo
+                        it.isChecked = info.checked
+                        it.isToAbstract = info.toAbstract
                     }
-                    return members.filter { it.isChecked() }
+                    return members.filter { it.isChecked }
                 }
 
                 override fun chooseSuperClass(superClasses: List<JetClass>): JetClass {
                     if (targetClassName != null) {
-                        return superClasses.single { it.getFqName()?.asString() ?: it.getName() == targetClassName }
+                        return superClasses.single { it.fqName?.asString() ?: it.name == targetClassName }
                     }
                     return superClasses.first()
                 }
@@ -96,11 +94,11 @@ public abstract class AbstractPullUpTest : JetLightCodeInsightFixtureTestCase()
             }
 
             assert(!conflictFile.exists()) { "Conflict file $conflictFile should not exist" }
-            JetTestUtils.assertEqualsToFile(afterFile, file.getText()!!)
+            JetTestUtils.assertEqualsToFile(afterFile, file.text!!)
         }
         catch(e: Exception) {
             val message = when (e) {
-                is BaseRefactoringProcessor.ConflictsInTestsException -> e.getMessages().sort().joinToString("\n")
+                is BaseRefactoringProcessor.ConflictsInTestsException -> e.messages.sort().joinToString("\n")
                 is CommonRefactoringUtil.RefactoringErrorHintException -> e.getMessage()!!
                 else -> throw e
             }