private static void checkSuperclassMembers(PsiClass superClass,
                                             MemberInfoBase<? extends PsiMember>[] infos,
                                             MultiMap<PsiElement, @DialogMessage String> conflictsList) {
    for (MemberInfoBase<? extends PsiMember> info : infos) {
      PsiMember member = info.getMember();
      PsiMember superMember = null;
      if (member instanceof PsiField) {
        superMember = superClass.findFieldByName(member.getName(), false);
      }
      else if (member instanceof PsiMethod method) {
        PsiClass aClass = method.getContainingClass();
        if (aClass == null) continue;
        PsiSubstitutor superSubstitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
        MethodSignature signature = method.getSignature(superSubstitutor);
        final PsiMethod superClassMethod = MethodSignatureUtil.findMethodBySignature(superClass, signature, false);
        if (superClassMethod != null && !superClassMethod.hasModifierProperty(PsiModifier.ABSTRACT)) {
          superMember = superClassMethod;
        }
      }

      if (superMember != null) {
        String message = RefactoringBundle.message("0.already.contains.a.1",
                                                   RefactoringUIUtil.getDescription(superClass, false),
                                                   RefactoringUIUtil.getDescription(superMember, false));
        message = StringUtil.capitalize(message);
        conflictsList.putValue(superMember, message);
      }

      if (member instanceof PsiMethod method) {
        final PsiModifierList modifierList = method.getModifierList();
        if (!modifierList.hasModifierProperty(PsiModifier.PRIVATE)) {
          for (PsiClass subClass : ClassInheritorsSearch.search(superClass)) {
            if (method.getContainingClass() != subClass) {
              MethodSignature signature =
                ((PsiMethod)member).getSignature(TypeConversionUtil.getSuperClassSubstitutor(superClass, subClass, PsiSubstitutor.EMPTY));
              final PsiMethod wouldBeOverriden = MethodSignatureUtil.findMethodBySignature(subClass, signature, false);
              if (wouldBeOverriden != null) {
                String modifier = VisibilityUtil.getVisibilityModifier(wouldBeOverriden.getModifierList());
                if (VisibilityUtil.compare(modifier, VisibilityUtil.getVisibilityModifier(modifierList)) > 0) {
                  String message = JavaRefactoringBundle.message("push.up.super.class.signature.conflict",
                                                                 RefactoringUIUtil.getDescription(method, true),
                                                                 RefactoringUIUtil.getDescription(subClass, true),
                                                                 modifier);
                  conflictsList.putValue(wouldBeOverriden, StringUtil.capitalize(message));
                }
              }
            }
          }
        }
      }
    }

  }
private static void checkSuperclassMembers(PsiClass superClass,
                                             MemberInfoBase<? extends PsiMember>[] infos,
                                             MultiMap<PsiElement, @DialogMessage String> conflictsList)