@Override
  protected boolean preprocessUsages(@NotNull Ref<UsageInfo[]> refUsages) {
    if (!myInlineThisOnly && checkReadOnly()) {
      if (!CommonRefactoringUtil.checkReadOnlyStatus(myProject, myMethod)) return false;
    }
    final UsageInfo[] usagesIn = refUsages.get();
    final MultiMap<PsiElement, @DialogMessage String> conflicts = new MultiMap<>();

    if (!ProgressManager.getInstance().runProcessWithProgressSynchronously(
      () -> ReadAction.run(() -> {
        if (!myInlineThisOnly) {
          final PsiMethod[] superMethods = myMethod.findSuperMethods();
          for (PsiMethod method : superMethods) {
            String className = Objects.requireNonNull(method.getContainingClass()).getQualifiedName();
            final String message = method.hasModifierProperty(PsiModifier.ABSTRACT) ?
                                   JavaRefactoringBundle.message("inlined.method.implements.method.from.0", className) :
                                   JavaRefactoringBundle.message("inlined.method.overrides.method.from.0", className);
            conflicts.putValue(method, message);
          }

          for (UsageInfo info : usagesIn) {
            final PsiElement element = info.getElement();
            if (element instanceof PsiDocMethodOrFieldRef && !PsiTreeUtil.isAncestor(myMethod, element, false)) {
              conflicts.putValue(element, JavaRefactoringBundle.message("inline.method.used.in.javadoc"));
            }
            if (element instanceof PsiLiteralExpression &&
                ContainerUtil.or(element.getReferences(), JavaLangClassMemberReference.class::isInstance)) {
              conflicts.putValue(element, JavaRefactoringBundle.message("inline.method.used.in.reflection"));
            }
            if (element instanceof PsiMethodReferenceExpression) {
              processSideEffectsInMethodReferenceQualifier(conflicts, (PsiMethodReferenceExpression)element);
            }
            if (element instanceof PsiReferenceExpression && myTransformerChooser.apply((PsiReference)element).isFallBackTransformer()) {
              conflicts.putValue(element, JavaRefactoringBundle.message("inlined.method.will.be.transformed.to.single.return.form"));
            }

            final String errorMessage = checkUnableToInsertCodeBlock(myMethod.getBody(), element);
            if (errorMessage != null) {
              conflicts.putValue(element, errorMessage);
            }
          }
        }
        else if (myReference != null && myTransformerChooser.apply(myReference).isFallBackTransformer()) {
          conflicts.putValue(myReference.getElement(),
                             JavaRefactoringBundle.message("inlined.method.will.be.transformed.to.single.return.form"));
        }
        else if (myReference instanceof PsiMethodReferenceExpression) {
          processSideEffectsInMethodReferenceQualifier(conflicts, (PsiMethodReferenceExpression)myReference);
        }
        addInaccessibleMemberConflicts(myMethod, usagesIn, new ReferencedElementsCollector(), conflicts);
        addInaccessibleSuperCallsConflicts(usagesIn, conflicts);
      }),
      RefactoringBundle.message("detecting.possible.conflicts"), true, myProject)) {
      return false;
    }

    //kotlin j2k fails badly if moved under progress
    myInliners = GenericInlineHandler.initInliners(myMethod, usagesIn, new InlineHandler.Settings() {
      @Override
      public boolean isOnlyOneReferenceToInline() {
        return myInlineThisOnly;
      }
    }, conflicts, JavaLanguage.INSTANCE);

    return showConflicts(conflicts, usagesIn);
  }
@Override
  protected boolean preprocessUsages(@NotNull Ref<UsageInfo[]> refUsages)