refactoring/impl/com/intellij/refactoring/util/classMembers/MemberInfo.java

   1 /*
   2  * Created by IntelliJ IDEA.
   3  * User: dsl
   4  * Date: 14.06.2002
   5  * Time: 20:31:59
   6  * To change template for new class use
   7  * Code Style | Class Templates options (Tools | IDE Options).
   8  */
   9 package com.intellij.refactoring.util.classMembers;
  10
  11 import com.intellij.psi.*;
  12 import com.intellij.psi.util.PsiFormatUtil;
  13 import com.intellij.refactoring.RefactoringBundle;
  14 import com.intellij.refactoring.classMembers.MemberInfoBase;
  15 import com.intellij.util.containers.HashSet;
  16
  17 import java.util.ArrayList;
  18 import java.util.List;
  19 import java.util.Set;
  20
  21 public class MemberInfo extends MemberInfoBase<PsiMember> {
  22   private final PsiReferenceList mySourceReferenceList;
  23
  24   public MemberInfo(PsiMember member) {
  25     this(member, false, null);
  26   }
  27   public MemberInfo(PsiMember member, boolean isSuperClass, PsiReferenceList sourceReferenceList) {
  28     super(member);
  29     LOG.assertTrue(member.isValid());
  30     mySourceReferenceList = sourceReferenceList;
  31     if (member instanceof PsiMethod) {
  32       PsiMethod method = (PsiMethod) member;
  33       displayName = PsiFormatUtil.formatMethod(method,
  34                                                PsiSubstitutor.EMPTY, PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER | PsiFormatUtil.SHOW_PARAMETERS,
  35                                                PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER
  36       );
  37       PsiMethod[] superMethods = method.findSuperMethods();
  38       if (superMethods.length > 0) {
  39         overrides = !superMethods[0].hasModifierProperty(PsiModifier.ABSTRACT) ? Boolean.TRUE : Boolean.FALSE;
  40       }
  41       else {
  42         overrides = null;
  43       }
  44       isStatic = method.hasModifierProperty(PsiModifier.STATIC);
  45     }
  46     else if (member instanceof PsiField) {
  47       PsiField field = (PsiField) member;
  48       displayName = PsiFormatUtil.formatVariable(
  49               field,
  50               PsiFormatUtil.SHOW_NAME | PsiFormatUtil.SHOW_TYPE | PsiFormatUtil.TYPE_AFTER,
  51               PsiSubstitutor.EMPTY);
  52       isStatic = field.hasModifierProperty(PsiModifier.STATIC);
  53       overrides = null;
  54     }
  55     else if (member instanceof PsiClass) {
  56       PsiClass aClass = (PsiClass) member;
  57
  58       if(isSuperClass) {
  59         if (aClass.isInterface()) {
  60           displayName = RefactoringBundle.message("member.info.implements.0", aClass.getName());
  61           overrides = Boolean.FALSE;
  62         }
  63         else {
  64           displayName = RefactoringBundle.message("member.info.extends.0", aClass.getName());
  65           overrides = Boolean.TRUE;
  66         }
  67       }
  68       else {
  69         displayName = aClass.getName();
  70         overrides = null;
  71       }
  72       isStatic = aClass.hasModifierProperty(PsiModifier.STATIC);
  73     }
  74     else {
  75       LOG.assertTrue(false);
  76       isStatic = false;
  77       displayName = "";
  78       overrides = null;
  79     }
  80   }
  81
  82   public PsiReferenceList getSourceReferenceList() {
  83     return mySourceReferenceList;
  84   }
  85
  86   public static List<MemberInfo> extractClassMembers(PsiClass subclass, Filter<PsiMember> filter, boolean extractInterfacesDeep) {
  87     List<MemberInfo> members = new ArrayList<MemberInfo>();
  88     extractClassMembers(subclass, members, filter, extractInterfacesDeep);
  89     return members;
  90   }
  91
  92   public static void extractClassMembers(PsiClass subclass, List<MemberInfo> result, Filter<PsiMember> filter, final boolean extractInterfacesDeep) {
  93     if (extractInterfacesDeep) {
  94       extractSuperInterfaces(subclass, filter, result, new HashSet<PsiClass>());
  95     }
  96     else {
  97       PsiClass[] interfaces = subclass.getInterfaces();
  98       PsiReferenceList sourceRefList = subclass.isInterface() ? subclass.getExtendsList() : subclass.getImplementsList();
  99       for (PsiClass anInterface : interfaces) {
 100         if (filter.includeMember(anInterface)) {
 101           result.add(new MemberInfo(anInterface, true, sourceRefList));
 102         }
 103       }
 104     }
 105
 106     PsiClass[] innerClasses = subclass.getInnerClasses();
 107     for (PsiClass innerClass : innerClasses) {
 108       if (filter.includeMember(innerClass)) {
 109         result.add(new MemberInfo(innerClass));
 110       }
 111     }
 112     PsiMethod[] methods = subclass.getMethods();
 113     for (PsiMethod method : methods) {
 114       if (!method.isConstructor() && filter.includeMember(method)) {
 115         result.add(new MemberInfo(method));
 116       }
 117     }
 118     PsiField[] fields = subclass.getFields();
 119     for (final PsiField field : fields) {
 120       if (filter.includeMember(field)) {
 121         result.add(new MemberInfo(field));
 122       }
 123     }
 124   }
 125
 126   private static void extractSuperInterfaces(final PsiClass subclass,
 127                                              final Filter<PsiMember> filter,
 128                                              final List<MemberInfo> result,
 129                                              Set<PsiClass> processed) {
 130     if (!processed.contains(subclass)) {
 131       processed.add(subclass);
 132       extractSuperInterfacesFromReferenceList(subclass.getExtendsList(), filter, result, processed);
 133       extractSuperInterfacesFromReferenceList(subclass.getImplementsList(), filter, result, processed);
 134     }
 135   }
 136
 137   private static void extractSuperInterfacesFromReferenceList(final PsiReferenceList referenceList,
 138                                                               final Filter<PsiMember> filter,
 139                                                               final List<MemberInfo> result,
 140                                                               final Set<PsiClass> processed) {
 141     if (referenceList != null) {
 142       final PsiClassType[] extendsListTypes = referenceList.getReferencedTypes();
 143       for (PsiClassType extendsListType : extendsListTypes) {
 144         final PsiClass aSuper = extendsListType.resolve();
 145         if (aSuper != null) {
 146           if (aSuper.isInterface()) {
 147             if (filter.includeMember(aSuper)) {
 148               result.add(new MemberInfo(aSuper, true, referenceList));
 149             }
 150           }
 151           else {
 152             extractSuperInterfaces(aSuper, filter, result, processed);
 153           }
 154         }
 155       }
 156     }
 157   }
 158 }