From 540bbce86e441e1b472abf833ee8441dff385fd6 Mon Sep 17 00:00:00 2001 From: Eugene Vigdorchik Date: Fri, 11 Mar 2005 15:56:22 +0300 Subject: [PATCH] (no message) --- .../generation/ui/GenerateEqualsWizard.java | 4 +- .../ExtractInterfaceDialog.java | 2 +- .../ExtractSuperclassHandler.java | 2 +- .../memberPullUp/PullUpHelper.java | 12 ++- .../refactoring/util/RefactoringUtil.java | 25 ++++-- .../util/classMembers/MemberInfo.java | 79 +++++++++++++++---- .../util/classMembers/MemberInfoStorage.java | 2 +- 7 files changed, 89 insertions(+), 37 deletions(-) diff --git a/source/com/intellij/codeInsight/generation/ui/GenerateEqualsWizard.java b/source/com/intellij/codeInsight/generation/ui/GenerateEqualsWizard.java index 3435a1c1256f..d9f041317346 100644 --- a/source/com/intellij/codeInsight/generation/ui/GenerateEqualsWizard.java +++ b/source/com/intellij/codeInsight/generation/ui/GenerateEqualsWizard.java @@ -42,7 +42,7 @@ public class GenerateEqualsWizard extends AbstractWizard { LOG.assertTrue(needEquals || needHashCode); myClass = aClass; - myClassFields = MemberInfo.extractClassMembers(myClass, MEMBER_INFO_FILTER); + myClassFields = MemberInfo.extractClassMembers(myClass, MEMBER_INFO_FILTER, false); for (int i = 0; i < myClassFields.length; i++) { myClassFields[i].setChecked(true); } @@ -152,7 +152,7 @@ public class GenerateEqualsWizard extends AbstractWizard { } private HashMap createFieldToMemberInfoMap(boolean checkedByDefault) { - MemberInfo[] memberInfos = MemberInfo.extractClassMembers(myClass, MEMBER_INFO_FILTER); + MemberInfo[] memberInfos = MemberInfo.extractClassMembers(myClass, MEMBER_INFO_FILTER, false); final HashMap result = new HashMap(); for (int i = 0; i < memberInfos.length; i++) { MemberInfo memberInfo = memberInfos[i]; diff --git a/source/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java b/source/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java index 09ad768f2e6b..c9ca840887c0 100644 --- a/source/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java +++ b/source/com/intellij/refactoring/extractInterface/ExtractInterfaceDialog.java @@ -73,7 +73,7 @@ class ExtractInterfaceDialog extends ExtractSuperBaseDialog { } return false; } - }); + }, true); super.init(); diff --git a/source/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java b/source/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java index 15d10950876e..7814da952e69 100644 --- a/source/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java +++ b/source/com/intellij/refactoring/extractSuperclass/ExtractSuperclassHandler.java @@ -77,7 +77,7 @@ public class ExtractSuperclassHandler implements RefactoringActionHandler, Extra public boolean includeMember(PsiMember element) { return true; } - }); + }, false); final String targetPackageName = (mySubclass.getContainingFile() instanceof PsiJavaFile)? ((PsiJavaFile) mySubclass.getContainingFile()).getPackageName() : null; diff --git a/source/com/intellij/refactoring/memberPullUp/PullUpHelper.java b/source/com/intellij/refactoring/memberPullUp/PullUpHelper.java index 08aec2276483..47f21592a3c5 100644 --- a/source/com/intellij/refactoring/memberPullUp/PullUpHelper.java +++ b/source/com/intellij/refactoring/memberPullUp/PullUpHelper.java @@ -122,13 +122,11 @@ public class PullUpHelper { } else if (info.getMember() instanceof PsiClass) { PsiClass aClass = (PsiClass) info.getMember(); if (Boolean.FALSE.equals(info.getOverrides())) { - final PsiReferenceList sourceReferenceList; - if (!mySourceClass.isInterface()) { - sourceReferenceList = mySourceClass.getImplementsList(); - } else { - sourceReferenceList = mySourceClass.getExtendsList(); - } - PsiJavaCodeReferenceElement ref = RefactoringUtil.removeFromReferenceList(sourceReferenceList, aClass); + final PsiReferenceList sourceReferenceList = info.getSourceReferenceList(); + LOG.assertTrue(sourceReferenceList != null); + PsiJavaCodeReferenceElement ref = mySourceClass.equals(sourceReferenceList.getParent()) ? + RefactoringUtil.removeFromReferenceList(sourceReferenceList, aClass) : + RefactoringUtil.findReferenceToClass(sourceReferenceList, aClass); if (ref != null) { final PsiReferenceList referenceList; if (!myTargetSuperClass.isInterface()) { diff --git a/source/com/intellij/refactoring/util/RefactoringUtil.java b/source/com/intellij/refactoring/util/RefactoringUtil.java index 6ee2f1b8fc4f..10349d8b2c1c 100644 --- a/source/com/intellij/refactoring/util/RefactoringUtil.java +++ b/source/com/intellij/refactoring/util/RefactoringUtil.java @@ -523,14 +523,23 @@ public class RefactoringUtil { public static PsiJavaCodeReferenceElement removeFromReferenceList(PsiReferenceList refList, PsiClass aClass) throws IncorrectOperationException { PsiJavaCodeReferenceElement[] refs = refList.getReferenceElements(); - if (refs != null) { - for (int i = 0; i < refs.length; i++) { - PsiJavaCodeReferenceElement ref = refs[i]; - if (aClass.equals(ref.resolve())) { - PsiJavaCodeReferenceElement refCopy = (PsiJavaCodeReferenceElement)ref.copy(); - ref.delete(); - return refCopy; - } + for (int i = 0; i < refs.length; i++) { + PsiJavaCodeReferenceElement ref = refs[i]; + if (ref.isReferenceTo(aClass)) { + PsiJavaCodeReferenceElement refCopy = (PsiJavaCodeReferenceElement)ref.copy(); + ref.delete(); + return refCopy; + } + } + return null; + } + + public static PsiJavaCodeReferenceElement findReferenceToClass(PsiReferenceList refList, PsiClass aClass) { + PsiJavaCodeReferenceElement[] refs = refList.getReferenceElements(); + for (int i = 0; i < refs.length; i++) { + PsiJavaCodeReferenceElement ref = refs[i]; + if (ref.isReferenceTo(aClass)) { + return ref; } } return null; diff --git a/source/com/intellij/refactoring/util/classMembers/MemberInfo.java b/source/com/intellij/refactoring/util/classMembers/MemberInfo.java index 8bf6018c834e..31a6e9867555 100644 --- a/source/com/intellij/refactoring/util/classMembers/MemberInfo.java +++ b/source/com/intellij/refactoring/util/classMembers/MemberInfo.java @@ -11,14 +11,15 @@ package com.intellij.refactoring.util.classMembers; import com.intellij.openapi.diagnostic.Logger; import com.intellij.psi.*; import com.intellij.psi.util.PsiFormatUtil; -import com.intellij.psi.util.PsiSuperMethodUtil; +import com.intellij.util.containers.HashSet; import java.util.ArrayList; import java.util.List; +import java.util.Set; public class MemberInfo { private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.extractSuperclass.MemberInfo"); - private PsiMember member; + private PsiMember myMember; final private boolean isStatic; final private String displayName; private boolean isChecked = false; @@ -27,6 +28,7 @@ public class MemberInfo { * TRUE if is overriden, FALSE if implemented, null if not implemented or overriden */ final private Boolean overrides; + private final PsiReferenceList mySourceReferenceList; public boolean isStatic() { return isStatic; @@ -64,18 +66,19 @@ public class MemberInfo { } public MemberInfo(PsiMember member) { - this(member, false); + this(member, false, null); } - public MemberInfo(PsiMember member, boolean isSuperClass) { + public MemberInfo(PsiMember member, boolean isSuperClass, PsiReferenceList sourceReferenceList) { LOG.assertTrue(member.isValid()); - this.member = member; + myMember = member; + mySourceReferenceList = sourceReferenceList; if (member instanceof PsiMethod) { PsiMethod method = (PsiMethod) member; displayName = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER | PsiFormatUtil.SHOW_PARAMETERS, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER ); - PsiMethod[] superMethods = PsiSuperMethodUtil.findSuperMethods(method); + PsiMethod[] superMethods = method.findSuperMethods(); if (superMethods.length > 0) { overrides = !superMethods[0].hasModifierProperty(PsiModifier.ABSTRACT) ? Boolean.TRUE : Boolean.FALSE; } @@ -121,8 +124,8 @@ public class MemberInfo { } public PsiMember getMember() { - LOG.assertTrue(member.isValid()); - return member; + LOG.assertTrue(myMember.isValid()); + return myMember; } /** @@ -130,26 +133,35 @@ public class MemberInfo { * @param element */ public void updateMember(PsiMember element) { - member = element; + myMember = element; } + public PsiReferenceList getSourceReferenceList() { + return mySourceReferenceList; + } public static interface Filter { boolean includeMember(PsiMember member); } - public static MemberInfo[] extractClassMembers(PsiClass subclass, Filter filter) { + public static MemberInfo[] extractClassMembers(PsiClass subclass, Filter filter, boolean extractInterfacesDeep) { List members = new ArrayList(); - extractClassMembers(subclass, members, filter); + extractClassMembers(subclass, members, filter, extractInterfacesDeep); return members.toArray(new MemberInfo[members.size()]); } - public static void extractClassMembers(PsiClass subclass, List result, Filter filter) { - PsiClass[] interfaces = subclass.getInterfaces(); - for (int i = 0; i < interfaces.length; i++) { - PsiClass anInterface = interfaces[i]; - if (filter.includeMember(anInterface)) { - result.add(new MemberInfo(anInterface, true)); + public static void extractClassMembers(PsiClass subclass, List result, Filter filter, final boolean extractInterfacesDeep) { + if (extractInterfacesDeep) { + extractSuperInterfaces(subclass, filter, result, new HashSet()); + } + else { + PsiClass[] interfaces = subclass.getInterfaces(); + PsiReferenceList sourceRefList = subclass.isInterface() ? subclass.getExtendsList() : subclass.getImplementsList(); + for (int i = 0; i < interfaces.length; i++) { + PsiClass anInterface = interfaces[i]; + if (filter.includeMember(anInterface)) { + result.add(new MemberInfo(anInterface, true, sourceRefList)); + } } } @@ -174,4 +186,37 @@ public class MemberInfo { } } } + + private static void extractSuperInterfaces(final PsiClass subclass, + final Filter filter, + final List result, + Set processed) { + if (!processed.contains(subclass)) { + processed.add(subclass); + extractSuperInterfacesFromReferenceList(subclass.getExtendsList(), filter, result, processed); + extractSuperInterfacesFromReferenceList(subclass.getImplementsList(), filter, result, processed); + } + } + + private static void extractSuperInterfacesFromReferenceList(final PsiReferenceList referenceList, + final Filter filter, + final List result, + final Set processed) { + if (referenceList != null) { + final PsiClassType[] extendsListTypes = referenceList.getReferencedTypes(); + for (int i = 0; i < extendsListTypes.length; i++) { + final PsiClass aSuper = extendsListTypes[i].resolve(); + if (aSuper != null) { + if (aSuper.isInterface()) { + if (filter.includeMember(aSuper)) { + result.add(new MemberInfo(aSuper, true, referenceList)); + } + } + else { + extractSuperInterfaces(aSuper, filter, result, processed); + } + } + } + } + } } diff --git a/source/com/intellij/refactoring/util/classMembers/MemberInfoStorage.java b/source/com/intellij/refactoring/util/classMembers/MemberInfoStorage.java index 0dc3992dfeba..fc06604594a1 100644 --- a/source/com/intellij/refactoring/util/classMembers/MemberInfoStorage.java +++ b/source/com/intellij/refactoring/util/classMembers/MemberInfoStorage.java @@ -49,7 +49,7 @@ public class MemberInfoStorage { List result = myClassToMemberInfoMap.get(aClass); if(result == null) { ArrayList temp = new ArrayList(); - MemberInfo.extractClassMembers(aClass, temp, myFilter); + MemberInfo.extractClassMembers(aClass, temp, myFilter, false); result = Collections.unmodifiableList(temp); myClassToMemberInfoMap.put(aClass, result); }