public ExtractClassProcessor(
     PsiClass sourceClass,
     List<PsiField> fields,
     List<PsiMethod> methods,
     List<PsiClass> classes,
     String packageName,
     MoveDestination moveDestination,
     String newClassName,
     String newVisibility,
     boolean generateAccessors,
     List<MemberInfo> enumConstants) {
   super(sourceClass.getProject());
   this.sourceClass = sourceClass;
   this.newPackageName = packageName;
   myMoveDestination = moveDestination;
   myNewVisibility = newVisibility;
   myGenerateAccessors = generateAccessors;
   this.enumConstants = new ArrayList<PsiField>();
   for (MemberInfo constant : enumConstants) {
     if (constant.isChecked()) {
       this.enumConstants.add((PsiField) constant.getMember());
     }
   }
   this.fields = new ArrayList<PsiField>(fields);
   this.methods = new ArrayList<PsiMethod>(methods);
   this.innerClasses = new ArrayList<PsiClass>(classes);
   this.newClassName = newClassName;
   delegateFieldName = calculateDelegateFieldName();
   requiresBackpointer =
       new BackpointerUsageVisitor(fields, innerClasses, methods, sourceClass)
           .backpointerRequired();
   if (requiresBackpointer) {
     ContainerUtil.addAll(typeParams, sourceClass.getTypeParameters());
   } else {
     final Set<PsiTypeParameter> typeParamSet = new HashSet<PsiTypeParameter>();
     final TypeParametersVisitor visitor = new TypeParametersVisitor(typeParamSet);
     for (PsiField field : fields) {
       field.accept(visitor);
     }
     for (PsiMethod method : methods) {
       method.accept(visitor);
       // do not include method's type parameters in class signature
       typeParamSet.removeAll(Arrays.asList(method.getTypeParameters()));
     }
     typeParams.addAll(typeParamSet);
   }
   myClass =
       new WriteCommandAction<PsiClass>(myProject, getCommandName()) {
         @Override
         protected void run(@NotNull Result<PsiClass> result) throws Throwable {
           result.setResult(buildClass());
         }
       }.execute().getResultObject();
   myExtractEnumProcessor = new ExtractEnumProcessor(myProject, this.enumConstants, myClass);
 }
 public void findUsages(@NotNull List<FixableUsageInfo> usages) {
   for (final MemberInfo memberInfo : myDelegateMethodInfos) {
     if (!memberInfo.isChecked()) continue;
     final PsiMethod method = (PsiMethod) memberInfo.getMember();
     final String getterName = GenerateMembersUtil.suggestGetterName(field);
     final int[] paramPermutation = DelegationUtils.getParameterPermutation(method);
     final PsiMethod delegatedMethod = DelegationUtils.getDelegatedMethod(method);
     LOG.assertTrue(!DelegationUtils.isAbstract(method));
     processUsagesForMethod(
         memberInfo.isToAbstract(), method, paramPermutation, getterName, delegatedMethod, usages);
   }
 }
 @Override
 public int checkForProblems(@NotNull MemberInfo member) {
   if (member.isChecked()) return OK;
   PsiClass currentSuperClass = getSuperClass();
   if (currentSuperClass != null && currentSuperClass.isInterface()) {
     PsiMember element = member.getMember();
     if (element.hasModifierProperty(PsiModifier.STATIC)) {
       return super.checkForProblems(member);
     }
     return OK;
   } else {
     return super.checkForProblems(member);
   }
 }
 @Override
 protected boolean preprocessUsages(@NotNull final Ref<UsageInfo[]> refUsages) {
   final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
   for (MemberInfo memberInfo : myDelegateMethodInfos) {
     if (memberInfo.isChecked() && memberInfo.isToAbstract()) {
       final PsiMember psiMember = memberInfo.getMember();
       if (psiMember instanceof PsiMethod
           && ((PsiMethod) psiMember).findDeepestSuperMethods().length > 0) {
         conflicts.putValue(
             psiMember,
             SymbolPresentationUtil.getSymbolPresentableText(psiMember)
                 + " will be deleted. Hierarchy will be broken");
       }
     }
   }
   return showConflicts(conflicts, refUsages.get());
 }
  public PushDownConflicts(PsiClass aClass, MemberInfo[] memberInfos) {
    myClass = aClass;

    myMovedMembers = new HashSet<PsiMember>();
    myAbstractMembers = new HashSet<PsiMethod>();
    for (MemberInfo memberInfo : memberInfos) {
      final PsiMember member = memberInfo.getMember();
      if (memberInfo.isChecked()
          && (!(memberInfo.getMember() instanceof PsiClass) || memberInfo.getOverrides() == null)) {
        myMovedMembers.add(member);
        if (memberInfo.isToAbstract()) {
          myAbstractMembers.add((PsiMethod) member);
        }
      }
    }

    myConflicts = new MultiMap<PsiElement, String>();
  }