Pull Up refactoring

java/java-impl/src/com/intellij/refactoring/inheritanceToDelegation/InheritanceToDelegationHandler.java

@@ -131,7 +131,7 @@ public class InheritanceToDelegationHandler implements RefactoringActionHandler
     final MemberInfoStorage memberInfoStorage = new MemberInfoStorage(baseClass, MEMBER_INFO_FILTER);
 
     ArrayList<MemberInfo> memberInfoList = new ArrayList<MemberInfo>(memberInfoStorage.getClassMemberInfos(deepestBase));
-    List<MemberInfo> memberInfos = memberInfoStorage.getMemberInfosList(deepestBase);
+    List<MemberInfo> memberInfos = memberInfoStorage.getIntermediateMemberInfosList(deepestBase);
     for (final MemberInfo memberInfo : memberInfos) {
       memberInfoList.add(memberInfo);
     }

java/java-impl/src/com/intellij/refactoring/memberPullUp/PullUpDialog.java

@@ -183,7 +183,7 @@ public class PullUpDialog extends RefactoringDialog {
 
   private void updateMemberInfo() {
     final PsiClass targetClass = (PsiClass) myClassCombo.getSelectedItem();
-    myMemberInfos = myMemberInfoStorage.getMemberInfosList(targetClass);
+    myMemberInfos = myMemberInfoStorage.getIntermediateMemberInfosList(targetClass);
     /*Set duplicate = myMemberInfoStorage.getDuplicatedMemberInfos(targetClass);
     for (Iterator iterator = duplicate.getSectionsIterator(); getSectionsIterator.hasNext();) {
       ((MemberInfo) iterator.next()).setChecked(false);

java/java-impl/src/com/intellij/refactoring/util/classMembers/MemberInfoStorage.java

@@ -39,13 +39,13 @@ public class MemberInfoStorage extends AbstractMemberInfoStorage<PsiMember, PsiC
   }
 
   @Override
-  protected boolean memberConflict(PsiElement member1, PsiElement member) {
+  protected boolean memberConflict(PsiMember member1, PsiMember member) {
     if(member instanceof PsiMethod && member1 instanceof PsiMethod) {
       return MethodSignatureUtil.areSignaturesEqual((PsiMethod) member, (PsiMethod) member1);
     }
     else if(member instanceof PsiField && member1 instanceof PsiField
             || member instanceof PsiClass && member1 instanceof PsiClass) {
-      return ((PsiNamedElement) member).getName().equals(((PsiNamedElement) member1).getName());
+      return member.getName().equals(member1.getName());
     }
     return false;
   }

platform/lang-impl/src/com/intellij/refactoring/classMembers/AbstractMemberInfoStorage.java

@@ -30,7 +30,7 @@ public abstract class AbstractMemberInfoStorage<T extends PsiElement, C extends
   private final HashMap<C, List<M>> myClassToMemberInfoMap = new HashMap<C, List<M>>();
   protected final C myClass;
   protected final MemberInfoBase.Filter<T> myFilter;
-  private final HashMap<C, List<M>> myTargetClassToMemberInfosMap = new HashMap<C, List<M>>();
+  private final HashMap<C, List<M>> myTargetClassToIntermediateMemberInfosMap = new HashMap<C, List<M>>();
   private final HashMap<C, LinkedHashSet<M>> myTargetClassToMemberInfosListMap = new HashMap<C, LinkedHashSet<M>>();
   private final HashMap<C, HashSet<M>> myTargetClassToDuplicatedMemberInfosMap = new HashMap<C, HashSet<M>>();
 
@@ -78,13 +78,13 @@ public abstract class AbstractMemberInfoStorage<T extends PsiElement, C extends
 
   protected abstract void extractClassMembers(C aClass, ArrayList<M> temp);
 
-  public List<M> getMemberInfosList(C baseClass) {
-    List<M> result = myTargetClassToMemberInfosMap.get(baseClass);
+  public List<M> getIntermediateMemberInfosList(C baseClass) {
+    List<M> result = myTargetClassToIntermediateMemberInfosMap.get(baseClass);
 
     if (result == null) {
       Set<M> list = getIntermediateClassesMemberInfosList(baseClass);
       result = Collections.unmodifiableList(new ArrayList<M>(list));
-      myTargetClassToMemberInfosMap.put(baseClass, result);
+      myTargetClassToIntermediateMemberInfosMap.put(baseClass, result);
     }
 
     return result;
@@ -128,15 +128,15 @@ public abstract class AbstractMemberInfoStorage<T extends PsiElement, C extends
 
   private HashSet<M> buildDuplicatedMemberInfos(C baseClass) {
     HashSet<M> result = new HashSet<M>();
-    List<M> memberInfos = getMemberInfosList(baseClass);
+    List<M> memberInfos = getIntermediateMemberInfosList(baseClass);
 
     for (int i = 0; i < memberInfos.size(); i++) {
       final M memberInfo = memberInfos.get(i);
-      final PsiElement member = memberInfo.getMember();
+      final T member = memberInfo.getMember();
 
       for(int j = 0; j < i; j++) {
         final M memberInfo1 = memberInfos.get(j);
-        final PsiElement member1 = memberInfo1.getMember();
+        final T member1 = memberInfo1.getMember();
         if(memberConflict(member1,  member)) {
           result.add(memberInfo);
 //        We let the first one be...
@@ -147,5 +147,5 @@ public abstract class AbstractMemberInfoStorage<T extends PsiElement, C extends
     return result;
   }
 
-  protected abstract boolean memberConflict(PsiElement member1, PsiElement member);
+  protected abstract boolean memberConflict(T member1, T member);
 }