From a69520284627e4e2df95df8605ecf9064790a0bb Mon Sep 17 00:00:00 2001 From: Alexey Sedunov Date: Tue, 28 Jul 2015 19:28:54 +0300 Subject: [PATCH] Pull Up: Minor: Use property access syntax --- .../memberInfo/KotlinMemberInfo.kt | 16 +-- .../memberInfo/KotlinMemberInfoStorage.kt | 18 ++- .../memberInfo/KotlinMemberSelectionPanel.kt | 2 +- .../memberInfo/KotlinMemberSelectionTable.kt | 15 +-- .../idea/refactoring/memberInfo/Utils.kt | 2 +- .../refactoring/pullUp/EmptyPullUpHelper.kt | 10 -- .../refactoring/pullUp/KotlinPullUpData.kt | 21 +-- .../refactoring/pullUp/KotlinPullUpDialog.kt | 16 +-- .../refactoring/pullUp/KotlinPullUpHandler.kt | 18 +-- .../refactoring/pullUp/KotlinPullUpHelper.kt | 122 +++++++++--------- .../pullUp/KotlinPullUpHelperFactory.kt | 8 +- .../pullUp/pullUpConflictsUtils.kt | 47 +++---- .../idea/refactoring/pullUp/pullUpUtils.kt | 2 +- .../refactoring/pullUp/AbstractPullUpTest.kt | 36 +++--- 14 files changed, 154 insertions(+), 179 deletions(-) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt index 35d41512b99..99ed696f41a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfo.kt +++ b/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 } \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt index f1a1bc0dadf..71cf9fe33a6 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt +++ b/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) { 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() .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) } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt index 581646a832b..cbfb45fa2ad 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionPanel.kt +++ b/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) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt index 8b6020e87a5..2cee0e6e9cd 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberSelectionTable.kt +++ b/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()) { diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/Utils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/Utils.kt index 9b836c8c5bc..af1c30a3caf 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/Utils.kt +++ b/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]" \ No newline at end of file +public fun JetClassOrObject.qualifiedNameForRendering(): String = fqName?.asString() ?: name ?: "[Anonymous]" \ No newline at end of file diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/EmptyPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/EmptyPullUpHelper.kt index 364f1192dff..68f78507ff4 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/EmptyPullUpHelper.kt +++ b/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> { diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt index 35a609863ba..3eddc86e306 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt +++ b/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() } @@ -55,17 +56,17 @@ class KotlinPullUpData(val sourceClass: JetClassOrObject, val substitution = LinkedHashMap() 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() 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) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt index 8ac56ed0948..bcd8179877b 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpDialog.kt +++ b/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)) } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt index 7c41ec4714c..cda66d32fa7 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt +++ b/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()) { 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 diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt index f7499a77fa0..c859cb9e10e 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt +++ b/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() 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() ?: 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) { - 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() .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, 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() } } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt index 55241dc4015..27033037d7b 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt +++ b/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 } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt index 3aee9ffda83..ac230fd9b91 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpConflictsUtils.kt +++ b/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() - 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) { 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(targetClass, targetClass.getUseScope()) + HierarchySearchRequest(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) { - 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 ) { 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) diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt index 1352d1c22bc..830e0241c47 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt +++ b/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()) diff --git a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/AbstractPullUpTest.kt b/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/AbstractPullUpTest.kt index 2cfe4dd1a7a..a3f7723e043 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/refactoring/pullUp/AbstractPullUpTest.kt +++ b/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): List { 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 { 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 }