From 33d70b1a5716832421e6c5d2df5fd007d576740e Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Thu, 17 Sep 2015 15:36:31 +0200 Subject: [PATCH] MakeOveriddenMembersOpen: J2K, cleanup, de-i18n --- .../kotlin/idea/JetBundle.properties | 1 - .../quickfix/MakeOverriddenMemberOpenFix.kt | 203 +++++++----------- .../kotlin/idea/quickfix/QuickFixRegistrar.kt | 2 +- 3 files changed, 82 insertions(+), 124 deletions(-) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties index cb4bd3012c2..70043c920c1 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/JetBundle.properties @@ -14,7 +14,6 @@ add.init.keyword.in.whole.project=Add 'init' keyword in whole project add.init.keyword.in.whole.project.modal.title=Adding 'init' keyword in whole project add.init.keyword.in.whole.project.family=Add 'init' keyword in whole project insert.delegation.call=Insert ''{0}()'' call -make.element.in.classifiers.open=Make ''{0}'' in {1} open make.class.annotation.class=Make ''{0}'' an annotation class make.class.annotation.class.family=Make Class an Annotation Class add.star.projections=Add ''{0}'' diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt index f4a13250907..d74962a5c79 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeOverriddenMemberOpenFix.kt @@ -14,149 +14,108 @@ * limitations under the License. */ -package org.jetbrains.kotlin.idea.quickfix; +package org.jetbrains.kotlin.idea.quickfix -import com.google.common.collect.Sets; -import com.intellij.codeInsight.intention.IntentionAction; -import com.intellij.openapi.editor.Editor; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Condition; -import com.intellij.psi.PsiElement; -import com.intellij.psi.PsiFile; -import com.intellij.util.IncorrectOperationException; -import com.intellij.util.containers.ContainerUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor; -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; -import org.jetbrains.kotlin.diagnostics.Diagnostic; -import org.jetbrains.kotlin.idea.JetBundle; -import org.jetbrains.kotlin.idea.caches.resolve.ResolutionUtils; -import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil; -import org.jetbrains.kotlin.psi.JetCallableDeclaration; -import org.jetbrains.kotlin.psi.JetDeclaration; -import org.jetbrains.kotlin.psi.JetFile; +import com.intellij.codeInsight.intention.IntentionAction +import com.intellij.openapi.editor.Editor +import com.intellij.openapi.project.Project +import com.intellij.psi.PsiFile +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DECLARATION +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.SYNTHESIZED +import org.jetbrains.kotlin.diagnostics.Diagnostic +import org.jetbrains.kotlin.idea.caches.resolve.resolveToDescriptor +import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil +import org.jetbrains.kotlin.lexer.JetTokens.OPEN_KEYWORD +import org.jetbrains.kotlin.psi.JetCallableDeclaration +import org.jetbrains.kotlin.psi.JetDeclaration +import org.jetbrains.kotlin.psi.JetFile +import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType +import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils +import java.util.* -import java.util.*; +public class MakeOverriddenMemberOpenFix(declaration: JetDeclaration) : JetIntentionAction(declaration) { + private val overriddenNonOverridableMembers = ArrayList() + private val containingDeclarationsNames = ArrayList() -import static org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.*; -import static org.jetbrains.kotlin.lexer.JetTokens.OPEN_KEYWORD; -import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration; - -public class MakeOverriddenMemberOpenFix extends JetIntentionAction { - private final List overriddenNonOverridableMembers = new ArrayList(); - private final List containingDeclarationsNames = new ArrayList(); - - public MakeOverriddenMemberOpenFix(@NotNull JetDeclaration declaration) { - super(declaration); - } - - @Override - public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) { - if (!super.isAvailable(project, editor, file) || !(file instanceof JetFile)) { - return false; + override fun isAvailable(project: Project, editor: Editor, file: PsiFile): Boolean { + if (!super.isAvailable(project, editor, file) || file !is JetFile) { + return false } // When running single test 'isAvailable()' is invoked multiple times, so we need to clear lists. - overriddenNonOverridableMembers.clear(); - containingDeclarationsNames.clear(); + overriddenNonOverridableMembers.clear() + containingDeclarationsNames.clear() - DeclarationDescriptor descriptor = ResolutionUtils.resolveToDescriptor(element); - if (!(descriptor instanceof CallableMemberDescriptor)) return false; + val descriptor = element.resolveToDescriptor() + if (descriptor !is CallableMemberDescriptor) return false - for (CallableMemberDescriptor overriddenDescriptor : getAllDeclaredNonOverridableOverriddenDescriptors( - (CallableMemberDescriptor) descriptor)) { - assert overriddenDescriptor.getKind() == DECLARATION : "Can only be applied to declarations."; - PsiElement overriddenMember = descriptorToDeclaration(overriddenDescriptor); - if (overriddenMember == null || !QuickFixUtil.canModifyElement(overriddenMember) || !(overriddenMember instanceof JetCallableDeclaration)) { - return false; + for (overriddenDescriptor in getAllDeclaredNonOverridableOverriddenDescriptors( + descriptor)) { + assert(overriddenDescriptor.kind == DECLARATION) { "Can only be applied to declarations." } + val overriddenMember = DescriptorToSourceUtils.descriptorToDeclaration(overriddenDescriptor) + if (overriddenMember == null || !QuickFixUtil.canModifyElement(overriddenMember) || overriddenMember !is JetCallableDeclaration) { + return false } - String containingDeclarationName = overriddenDescriptor.getContainingDeclaration().getName().asString(); - overriddenNonOverridableMembers.add((JetCallableDeclaration) overriddenMember); - containingDeclarationsNames.add(containingDeclarationName); + val containingDeclarationName = overriddenDescriptor.containingDeclaration.name.asString() + overriddenNonOverridableMembers.add(overriddenMember) + containingDeclarationsNames.add(containingDeclarationName) } - return overriddenNonOverridableMembers.size() > 0; + return overriddenNonOverridableMembers.size() > 0 } - @NotNull - private static Collection getAllDeclaredNonOverridableOverriddenDescriptors( - @NotNull CallableMemberDescriptor callableMemberDescriptor - ) { - Set result = Sets.newHashSet(); - Collection - nonOverridableOverriddenDescriptors = retainNonOverridableMembers(callableMemberDescriptor.getOverriddenDescriptors()); - for (CallableMemberDescriptor overriddenDescriptor : nonOverridableOverriddenDescriptors) { - CallableMemberDescriptor.Kind kind = overriddenDescriptor.getKind(); - if (kind == DECLARATION) { - result.add(overriddenDescriptor); - } - else if (kind == FAKE_OVERRIDE || kind == DELEGATION) { - result.addAll(getAllDeclaredNonOverridableOverriddenDescriptors(overriddenDescriptor)); - } - else if (kind == SYNTHESIZED) { - // do nothing, final synthesized members can't be made open - } - else { - throw new UnsupportedOperationException("Unexpected callable kind " + kind); - } - } - return result; - } - - @NotNull - private static Collection retainNonOverridableMembers( - @NotNull Collection callableMemberDescriptors - ) { - return ContainerUtil.filter(callableMemberDescriptors, new Condition() { - @Override - public boolean value(CallableMemberDescriptor descriptor) { - return !descriptor.getModality().isOverridable(); - } - }); - } - - @NotNull - @Override - public String getText() { + override fun getText(): String { if (overriddenNonOverridableMembers.size() == 1) { - return JetBundle.message("make.element.modifier", containingDeclarationsNames.get(0) + "." + element.getName(), OPEN_KEYWORD); + val name = containingDeclarationsNames.get(0) + "." + element.name + return "Make $name $OPEN_KEYWORD" } - StringBuilder declarations = new StringBuilder(); - Collections.sort(containingDeclarationsNames); - for (int i = 0; i < containingDeclarationsNames.size() - 2; i++) { - declarations.append(containingDeclarationsNames.get(i)); - declarations.append(", "); - } - declarations.append(containingDeclarationsNames.get(containingDeclarationsNames.size() - 2)); - declarations.append(" and "); - declarations.append(containingDeclarationsNames.get(containingDeclarationsNames.size() - 1)); - return JetBundle.message("make.element.in.classifiers.open", element.getName(), declarations.toString()); + Collections.sort(containingDeclarationsNames) + val declarations = containingDeclarationsNames.subList(0, containingDeclarationsNames.size()-1).join(", ") + " and " + + containingDeclarationsNames.last() + return "Make '${element.name}' in $declarations open" } - @NotNull - @Override - public String getFamilyName() { - return JetBundle.message("add.modifier.family"); - } + override fun getFamilyName(): String = "Add Modifier" - @Override - public void invoke(@NotNull Project project, Editor editor, JetFile file) throws IncorrectOperationException { - for (JetCallableDeclaration overriddenMember : overriddenNonOverridableMembers) { - overriddenMember.addModifier(OPEN_KEYWORD); + override fun invoke(project: Project, editor: Editor?, file: JetFile) { + for (overriddenMember in overriddenNonOverridableMembers) { + overriddenMember.addModifier(OPEN_KEYWORD) } } - @NotNull - public static JetSingleIntentionActionFactory createFactory() { - return new JetSingleIntentionActionFactory() { - @Nullable - @Override - public IntentionAction createAction(@NotNull Diagnostic diagnostic) { - JetDeclaration declaration = QuickFixUtil.getParentElementOfType(diagnostic, JetDeclaration.class); - assert declaration != null; - return new MakeOverriddenMemberOpenFix(declaration); + companion object : JetSingleIntentionActionFactory() { + + private fun getAllDeclaredNonOverridableOverriddenDescriptors( + callableMemberDescriptor: CallableMemberDescriptor): Collection { + val result = hashSetOf() + val nonOverridableOverriddenDescriptors = retainNonOverridableMembers(callableMemberDescriptor.overriddenDescriptors) + for (overriddenDescriptor in nonOverridableOverriddenDescriptors) { + when (overriddenDescriptor.kind) { + DECLARATION -> + result.add(overriddenDescriptor) + + FAKE_OVERRIDE, DELEGATION -> + result.addAll(getAllDeclaredNonOverridableOverriddenDescriptors(overriddenDescriptor)) + + SYNTHESIZED -> {} /* do nothing */ + + else -> throw UnsupportedOperationException("Unexpected callable kind ${overriddenDescriptor.kind}") + } } - }; + return result + } + + private fun retainNonOverridableMembers( + callableMemberDescriptors: Collection): Collection { + return callableMemberDescriptors.filter { !it.modality.isOverridable } + } + + override fun createAction(diagnostic: Diagnostic): IntentionAction? { + val declaration = diagnostic.psiElement.getNonStrictParentOfType()!! + return MakeOverriddenMemberOpenFix(declaration) + } } } diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt index 38a192c52d6..d1f54bae799 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/QuickFixRegistrar.kt @@ -196,7 +196,7 @@ public class QuickFixRegistrar : QuickFixContributor { FINAL_SUPERTYPE.registerFactory(addOpenModifierToClassDeclarationFix) FINAL_UPPER_BOUND.registerFactory(addOpenModifierToClassDeclarationFix) - OVERRIDING_FINAL_MEMBER.registerFactory(MakeOverriddenMemberOpenFix.createFactory()) + OVERRIDING_FINAL_MEMBER.registerFactory(MakeOverriddenMemberOpenFix) PARAMETER_NAME_CHANGED_ON_OVERRIDE.registerFactory(RenameParameterToMatchOverriddenMethodFix.createFactory())