diff --git a/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInsight/intention/QuickFixFactory.java b/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInsight/intention/QuickFixFactory.java
index b1e13a34f..d266a3343 100644
--- a/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInsight/intention/QuickFixFactory.java
+++ b/java-analysis-api/src/main/java/com/intellij/java/analysis/codeInsight/intention/QuickFixFactory.java
@@ -18,6 +18,8 @@
 import com.intellij.java.language.LanguageLevel;
 import com.intellij.java.language.psi.*;
 import com.intellij.java.language.psi.util.PropertyMemberType;
+import consulo.annotation.DeprecationInfo;
+import consulo.annotation.access.RequiredReadAction;
 import consulo.annotation.component.ComponentScope;
 import consulo.annotation.component.ServiceAPI;
 import consulo.ide.ServiceManager;
@@ -30,9 +32,9 @@
 import consulo.language.psi.PsiElement;
 import consulo.language.psi.PsiNamedElement;
 import consulo.language.psi.PsiReference;
+import consulo.localize.LocalizeValue;
 import consulo.module.Module;
 import consulo.project.Project;
-import org.jetbrains.annotations.Nls;
 
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
@@ -46,58 +48,31 @@
  */
 @ServiceAPI(ComponentScope.APPLICATION)
 public abstract class QuickFixFactory {
-    public static QuickFixFactory getInstance() {
-        return ServiceManager.getService(QuickFixFactory.class);
-    }
+    public interface ModifierFixBuilder {
+        default ModifierFixBuilder add(@PsiModifier.ModifierConstant String modifier) {
+            return toggle(modifier, true);
+        }
 
-    @Nonnull
-    public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
-        @Nonnull PsiModifierList modifierList,
-        @PsiModifier.ModifierConstant @Nonnull String modifier,
-        boolean shouldHave,
-        final boolean showContainingClass
-    );
-
-    @Nonnull
-    public LocalQuickFixAndIntentionActionOnPsiElement createAddModifierFix(
-        @Nonnull PsiModifierList modifierList,
-        @PsiModifier.ModifierConstant @Nonnull String modifier
-    ) {
-        return createModifierListFix(modifierList, modifier, true, false);
-    }
+        default ModifierFixBuilder remove(@PsiModifier.ModifierConstant String modifier) {
+            return toggle(modifier, false);
+        }
 
-    @Nonnull
-    public LocalQuickFixAndIntentionActionOnPsiElement createRemoveModifierFix(
-        @Nonnull PsiModifierList modifierList,
-        @PsiModifier.ModifierConstant @Nonnull String modifier
-    ) {
-        return createModifierListFix(modifierList, modifier, false, false);
-    }
+        ModifierFixBuilder toggle(@PsiModifier.ModifierConstant String modifier, boolean shouldHave);
 
-    @Nonnull
-    public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
-        @Nonnull PsiModifierListOwner owner,
-        @PsiModifier.ModifierConstant @Nonnull String modifier,
-        boolean shouldHave,
-        final boolean showContainingClass
-    );
+        ModifierFixBuilder showContainingClass();
 
-    @Nonnull
-    public LocalQuickFixAndIntentionActionOnPsiElement createAddModifierFix(
-        @Nonnull PsiModifierListOwner owner,
-        @PsiModifier.ModifierConstant @Nonnull String modifier
-    ) {
-        return createModifierListFix(owner, modifier, true, false);
+        @RequiredReadAction
+        public abstract LocalQuickFixAndIntentionActionOnPsiElement create();
     }
 
-    @Nonnull
-    public LocalQuickFixAndIntentionActionOnPsiElement createRemoveModifierFix(
-        @Nonnull PsiModifierListOwner owner,
-        @PsiModifier.ModifierConstant @Nonnull String modifier
-    ) {
-        return createModifierListFix(owner, modifier, false, false);
+    public static QuickFixFactory getInstance() {
+        return ServiceManager.getService(QuickFixFactory.class);
     }
 
+    public abstract ModifierFixBuilder createModifierFixBuilder(@Nonnull PsiModifierList modifierList);
+
+    public abstract ModifierFixBuilder createModifierFixBuilder(@Nonnull PsiModifierListOwner owner);
+
     @Nonnull
     public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix(
         @Nonnull PsiMethod method,
@@ -472,7 +447,7 @@ public abstract IntentionAction createAddToDependencyInjectionAnnotationsFix(
     public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element);
 
     @Nonnull
-    public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nonnull @Nls String text);
+    public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nonnull LocalizeValue text);
 
     @Nonnull
     public abstract IntentionAction createDeleteSideEffectAwareFix(@Nonnull PsiExpressionStatement statement);
@@ -538,4 +513,37 @@ public abstract LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticVi
     @Nonnull
     public abstract IntentionAction createWrapSwitchRuleStatementsIntoBlockFix(PsiSwitchLabeledRuleStatement rule);
 
+    @Deprecated
+    @DeprecationInfo("Use #fixModifiers()...#build()")
+    @Nonnull
+    @RequiredReadAction
+    public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
+        @Nonnull PsiModifierList modifierList,
+        @PsiModifier.ModifierConstant @Nonnull String modifier,
+        boolean shouldHave,
+        boolean showContainingClass
+    ) {
+        ModifierFixBuilder builder = createModifierFixBuilder(modifierList).toggle(modifier, shouldHave);
+        if (showContainingClass) {
+            builder.showContainingClass();
+        }
+        return builder.create();
+    }
+
+    @Deprecated
+    @DeprecationInfo("Use #fixModifiers()...#build()")
+    @Nonnull
+    @RequiredReadAction
+    public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
+        @Nonnull PsiModifierListOwner owner,
+        @PsiModifier.ModifierConstant @Nonnull String modifier,
+        boolean shouldHave,
+        boolean showContainingClass
+    ) {
+        ModifierFixBuilder builder = createModifierFixBuilder(owner).toggle(modifier, shouldHave);
+        if (showContainingClass) {
+            builder.showContainingClass();
+        }
+        return builder.create();
+    }
 }
\ No newline at end of file
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java
index c9178c70a..a1811ef8a 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/AnnotationsHighlightUtil.java
@@ -329,7 +329,7 @@ private static boolean isAnnotationRepeatedTwice(@Nonnull PsiAnnotationOwner own
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkMissingAttributes(PsiAnnotation annotation) {
+    public static HighlightInfo.Builder checkMissingAttributes(PsiAnnotation annotation) {
         PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
         if (nameRef == null) {
             return null;
@@ -371,8 +371,7 @@ public static HighlightInfo checkMissingAttributes(PsiAnnotation annotation) {
                     .descriptionAndTooltip(JavaErrorLocalize.annotationMissingAttribute(buff))
                     .registerFix(
                         QuickFixFactory.getInstance().createAddMissingRequiredAnnotationParametersFix(annotation, annotationMethods, missed)
-                    )
-                    .create();
+                    );
             }
         }
 
@@ -396,14 +395,13 @@ public static HighlightInfo.Builder checkConstantExpression(PsiExpression expres
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkValidAnnotationType(PsiType type, PsiTypeElement typeElement) {
+    public static HighlightInfo.Builder checkValidAnnotationType(PsiType type, PsiTypeElement typeElement) {
         if (type != null && type.accept(AnnotationReturnTypeVisitor.INSTANCE)) {
             return null;
         }
         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(typeElement)
-            .descriptionAndTooltip(JavaErrorLocalize.annotationInvalidAnnotationMemberType(type != null ? type.getPresentableText() : "?"))
-            .create();
+            .descriptionAndTooltip(JavaErrorLocalize.annotationInvalidAnnotationMemberType(type != null ? type.getPresentableText() : "?"));
     }
 
     private static final ElementPattern<PsiElement> ANY_ANNOTATION_ALLOWED = psiElement().andOr(
@@ -465,8 +463,7 @@ public static HighlightInfo.Builder checkApplicability(
             else if (owner instanceof PsiModifierList modifierList) {
                 PsiElement nextElement =
                     PsiTreeUtil.skipSiblingsForward(modifierList, PsiComment.class, PsiWhiteSpace.class, PsiTypeParameterList.class);
-                if (nextElement instanceof PsiTypeElement) {
-                    PsiTypeElement typeElement = (PsiTypeElement)nextElement;
+                if (nextElement instanceof PsiTypeElement typeElement) {
                     PsiType type = typeElement.getType();
                     if (PsiType.VOID.equals(type)) {
                         return annotationError(annotation, JavaErrorLocalize.annotationNotAllowedVoid());
@@ -526,37 +523,34 @@ private static PsiJavaCodeReferenceElement getOutermostReferenceElement(@Nullabl
             return null;
         }
 
-        PsiElement qualifier;
-        while ((qualifier = ref.getQualifier()) instanceof PsiJavaCodeReferenceElement) {
-            ref = (PsiJavaCodeReferenceElement)qualifier;
+        while (ref.getQualifier() instanceof PsiJavaCodeReferenceElement javaCodeRef) {
+            ref = javaCodeRef;
         }
         return ref;
     }
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkAnnotationType(PsiAnnotation annotation) {
+    public static HighlightInfo.Builder checkAnnotationType(PsiAnnotation annotation) {
         PsiJavaCodeReferenceElement nameRefElem = annotation.getNameReferenceElement();
         if (nameRefElem != null && (!(nameRefElem.resolve() instanceof PsiClass annotationClass) || !annotationClass.isAnnotationType())) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(nameRefElem)
-                .descriptionAndTooltip(JavaErrorLocalize.annotationAnnotationTypeExpected())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.annotationAnnotationTypeExpected());
         }
         return null;
     }
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkCyclicMemberType(PsiTypeElement typeElement, PsiClass aClass) {
+    public static HighlightInfo.Builder checkCyclicMemberType(PsiTypeElement typeElement, PsiClass aClass) {
         LOG.assertTrue(aClass.isAnnotationType());
         PsiType type = typeElement.getType();
         Set<PsiClass> checked = new HashSet<>();
         if (cyclicDependencies(aClass, type, checked, aClass.getManager())) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(typeElement)
-                .descriptionAndTooltip(JavaErrorLocalize.annotationCyclicElementType())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.annotationCyclicElementType());
         }
         return null;
     }
@@ -580,8 +574,9 @@ private static boolean cyclicDependencies(PsiClass aClass, PsiType type, @Nonnul
         return false;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkClashesWithSuperMethods(@Nonnull PsiAnnotationMethod psiMethod) {
+    public static HighlightInfo.Builder checkClashesWithSuperMethods(@Nonnull PsiAnnotationMethod psiMethod) {
         PsiIdentifier nameIdentifier = psiMethod.getNameIdentifier();
         if (nameIdentifier != null) {
             PsiMethod[] methods = psiMethod.findDeepestSuperMethods();
@@ -596,8 +591,7 @@ public static HighlightInfo checkClashesWithSuperMethods(@Nonnull PsiAnnotationM
                             .descriptionAndTooltip(
                                 "@interface member clashes with '" + JavaHighlightUtil.formatMethod(method) +
                                     "' in " + HighlightUtil.formatClass(containingClass)
-                            )
-                            .create();
+                            );
                     }
                 }
             }
@@ -643,7 +637,7 @@ public static HighlightInfo checkPackageAnnotationContainingFile(PsiPackageState
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkTargetAnnotationDuplicates(PsiAnnotation annotation) {
+    public static HighlightInfo.Builder checkTargetAnnotationDuplicates(PsiAnnotation annotation) {
         PsiJavaCodeReferenceElement nameRef = annotation.getNameReferenceElement();
         if (nameRef == null) {
             return null;
@@ -671,8 +665,7 @@ public static HighlightInfo checkTargetAnnotationDuplicates(PsiAnnotation annota
                     if (targets.contains(target)) {
                         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                             .range(initializer)
-                            .descriptionAndTooltip(JavaErrorLocalize.repeatedAnnotationTarget())
-                            .create();
+                            .descriptionAndTooltip(JavaErrorLocalize.repeatedAnnotationTarget());
                     }
                     targets.add(target);
                 }
@@ -683,7 +676,7 @@ public static HighlightInfo checkTargetAnnotationDuplicates(PsiAnnotation annota
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkFunctionalInterface(@Nonnull PsiAnnotation annotation, @Nonnull LanguageLevel languageLevel) {
+    public static HighlightInfo.Builder checkFunctionalInterface(@Nonnull PsiAnnotation annotation, @Nonnull LanguageLevel languageLevel) {
         if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)
             && Comparing.strEqual(annotation.getQualifiedName(), JavaClassNames.JAVA_LANG_FUNCTIONAL_INTERFACE)) {
             PsiAnnotationOwner owner = annotation.getOwner();
@@ -696,8 +689,7 @@ public static HighlightInfo checkFunctionalInterface(@Nonnull PsiAnnotation anno
                 if (errorMessage != null) {
                     return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                         .range(annotation)
-                        .descriptionAndTooltip(errorMessage)
-                        .create();
+                        .descriptionAndTooltip(errorMessage);
                 }
             }
         }
@@ -706,7 +698,7 @@ public static HighlightInfo checkFunctionalInterface(@Nonnull PsiAnnotation anno
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkRepeatableAnnotation(PsiAnnotation annotation) {
+    public static HighlightInfo.Builder checkRepeatableAnnotation(PsiAnnotation annotation) {
         String qualifiedName = annotation.getQualifiedName();
         if (!JavaClassNames.JAVA_LANG_ANNOTATION_REPEATABLE.equals(qualifiedName)) {
             return null;
@@ -718,8 +710,7 @@ public static HighlightInfo checkRepeatableAnnotation(PsiAnnotation annotation)
             if (containerRef != null) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(containerRef)
-                    .descriptionAndTooltip(description)
-                    .create();
+                    .descriptionAndTooltip(description);
             }
         }
 
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java
index bf5314b1a..ae1102291 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/GenericsHighlightUtil.java
@@ -1209,8 +1209,9 @@ private static HighlightInfo isIllegalForInstanceOf(PsiType type, PsiTypeElement
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkClassObjectAccessExpression(PsiClassObjectAccessExpression expression) {
+    public static HighlightInfo.Builder checkClassObjectAccessExpression(PsiClassObjectAccessExpression expression) {
         PsiType type = expression.getOperand().getType();
         if (type instanceof PsiClassType classType) {
             return canSelectFrom(classType, expression.getOperand());
@@ -1224,25 +1225,23 @@ public static HighlightInfo checkClassObjectAccessExpression(PsiClassObjectAcces
 
     @Nullable
     @RequiredReadAction
-    private static HighlightInfo canSelectFrom(PsiClassType type, PsiTypeElement operand) {
+    private static HighlightInfo.Builder canSelectFrom(PsiClassType type, PsiTypeElement operand) {
         if (type.resolve() instanceof PsiTypeParameter) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(operand)
-                .descriptionAndTooltip(JavaErrorLocalize.cannotSelectDotClassFromTypeVariable())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.cannotSelectDotClassFromTypeVariable());
         }
         if (type.getParameters().length > 0) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(operand)
-                .descriptionAndTooltip(JavaErrorLocalize.cannotSelectFromParameterizedType())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.cannotSelectFromParameterizedType());
         }
         return null;
     }
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkOverrideAnnotation(
+    public static HighlightInfo.Builder checkOverrideAnnotation(
         @Nonnull PsiMethod method,
         @Nonnull PsiAnnotation overrideAnnotation,
         @Nonnull LanguageLevel languageLevel
@@ -1260,14 +1259,11 @@ public static HighlightInfo checkOverrideAnnotation(
                 }
             }
             if (superMethod == null) {
-                HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                HighlightInfo.Builder hlBuilder = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(overrideAnnotation)
-                    .descriptionAndTooltip(JavaErrorLocalize.methodDoesNotOverrideSuper())
-                    .create();
-                if (highlightInfo != null) {
-                    QuickFixFactory.getInstance().registerPullAsAbstractUpFixes(method, QuickFixActionRegistrar.create(highlightInfo));
-                }
-                return highlightInfo;
+                    .descriptionAndTooltip(JavaErrorLocalize.methodDoesNotOverrideSuper());
+                QuickFixFactory.getInstance().registerPullAsAbstractUpFixes(method, QuickFixActionRegistrar.create(hlBuilder));
+                return hlBuilder;
             }
             PsiClass superClass = superMethod.getMethod().getContainingClass();
             if (languageLevel.equals(LanguageLevel.JDK_1_5)
@@ -1276,8 +1272,7 @@ public static HighlightInfo checkOverrideAnnotation(
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(overrideAnnotation)
                     .descriptionAndTooltip(JavaErrorBundle.message("override.not.allowed.in.interfaces"))
-                    .registerFix(QuickFixFactory.getInstance().createIncreaseLanguageLevelFix(LanguageLevel.JDK_1_6))
-                    .create();
+                    .registerFix(QuickFixFactory.getInstance().createIncreaseLanguageLevelFix(LanguageLevel.JDK_1_6));
             }
             return null;
         }
@@ -1288,7 +1283,7 @@ public static HighlightInfo checkOverrideAnnotation(
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkSafeVarargsAnnotation(PsiMethod method, LanguageLevel languageLevel) {
+    public static HighlightInfo.Builder checkSafeVarargsAnnotation(PsiMethod method, LanguageLevel languageLevel) {
         PsiModifierList list = method.getModifierList();
         PsiAnnotation safeVarargsAnnotation = list.findAnnotation(JavaClassNames.JAVA_LANG_SAFE_VARARGS);
         if (safeVarargsAnnotation == null) {
@@ -1298,14 +1293,12 @@ public static HighlightInfo checkSafeVarargsAnnotation(PsiMethod method, Languag
             if (!method.isVarArgs()) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(safeVarargsAnnotation)
-                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotAllowedOnMethodsWithFixedArity())
-                    .create();
+                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotAllowedOnMethodsWithFixedArity());
             }
             if (!isSafeVarargsNoOverridingCondition(method, languageLevel)) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(safeVarargsAnnotation)
-                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotAllowedNonFinalInstanceMethods())
-                    .create();
+                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotAllowedNonFinalInstanceMethods());
             }
 
             PsiParameter varParameter = method.getParameterList().getParameters()[method.getParameterList().getParametersCount() - 1];
@@ -1314,8 +1307,7 @@ public static HighlightInfo checkSafeVarargsAnnotation(PsiMethod method, Languag
                 if (reference.getElement() instanceof PsiExpression expression && !PsiUtil.isAccessedForReading(expression)) {
                     return HighlightInfo.newHighlightInfo(HighlightInfoType.WARNING)
                         .range(expression)
-                        .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotSuppressPotentiallyUnsafeOperations())
-                        .create();
+                        .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotSuppressPotentiallyUnsafeOperations());
                 }
             }
 
@@ -1325,8 +1317,7 @@ public static HighlightInfo checkSafeVarargsAnnotation(PsiMethod method, Languag
             if (JavaGenericsUtil.isReifiableType(componentType)) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.WARNING)
                     .range(varParameter.getTypeElement())
-                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotApplicableForReifiableTypes())
-                    .create();
+                    .descriptionAndTooltip(JavaErrorLocalize.safevarargsNotApplicableForReifiableTypes());
             }
             return null;
         }
@@ -1375,7 +1366,7 @@ public static void checkEnumConstantForConstructorProblems(
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkEnumSuperConstructorCall(PsiMethodCallExpression expr) {
+    public static HighlightInfo.Builder checkEnumSuperConstructorCall(PsiMethodCallExpression expr) {
         PsiReferenceExpression methodExpression = expr.getMethodExpression();
         PsiElement refNameElement = methodExpression.getReferenceNameElement();
         if (refNameElement != null && PsiKeyword.SUPER.equals(refNameElement.getText())) {
@@ -1384,8 +1375,7 @@ public static HighlightInfo checkEnumSuperConstructorCall(PsiMethodCallExpressio
                 if (aClass != null && aClass.isEnum()) {
                     return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                         .range(expr)
-                        .descriptionAndTooltip(JavaErrorLocalize.callToSuperIsNotAllowedInEnumConstructor())
-                        .create();
+                        .descriptionAndTooltip(JavaErrorLocalize.callToSuperIsNotAllowedInEnumConstructor());
                 }
             }
         }
@@ -1394,15 +1384,14 @@ public static HighlightInfo checkEnumSuperConstructorCall(PsiMethodCallExpressio
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkVarArgParameterIsLast(@Nonnull PsiParameter parameter) {
+    public static HighlightInfo.Builder checkVarArgParameterIsLast(@Nonnull PsiParameter parameter) {
         if (parameter.getDeclarationScope() instanceof PsiMethod method) {
             PsiParameter[] params = method.getParameterList().getParameters();
             if (params[params.length - 1] != parameter) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(parameter)
                     .descriptionAndTooltip(JavaErrorLocalize.varargNotLastParameter())
-                    .registerFix(QuickFixFactory.getInstance().createMakeVarargParameterLastFix(parameter))
-                    .create();
+                    .registerFix(QuickFixFactory.getInstance().createMakeVarargParameterLastFix(parameter));
             }
         }
         return null;
@@ -1431,14 +1420,13 @@ public static List<HighlightInfo> checkEnumConstantModifierList(PsiModifierList
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkParametersAllowed(PsiReferenceParameterList refParamList) {
+    public static HighlightInfo.Builder checkParametersAllowed(PsiReferenceParameterList refParamList) {
         if (refParamList.getParent() instanceof PsiReferenceExpression refExpr
             && !(refExpr.getParent() instanceof PsiMethodCallExpression)
             && !(refExpr instanceof PsiMethodReferenceExpression)) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(refParamList)
-                .descriptionAndTooltip(JavaErrorLocalize.genericsReferenceParametersNotAllowed())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.genericsReferenceParametersNotAllowed());
         }
 
         return null;
@@ -1446,7 +1434,7 @@ public static HighlightInfo checkParametersAllowed(PsiReferenceParameterList ref
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkParametersOnRaw(PsiReferenceParameterList refParamList) {
+    public static HighlightInfo.Builder checkParametersOnRaw(PsiReferenceParameterList refParamList) {
         JavaResolveResult resolveResult = null;
         PsiElement parent = refParamList.getParent();
         PsiElement qualifier = null;
@@ -1514,26 +1502,26 @@ else if (parent instanceof PsiCallExpression call) {
 
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(refParamList)
-                    .descriptionAndTooltip(message)
-                    .create();
+                    .descriptionAndTooltip(message);
             }
         }
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkCannotInheritFromEnum(PsiClass superClass, PsiElement elementToHighlight) {
+    public static HighlightInfo.Builder checkCannotInheritFromEnum(PsiClass superClass, PsiElement elementToHighlight) {
         if (JavaClassNames.JAVA_LANG_ENUM.equals(superClass.getQualifiedName())) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(elementToHighlight)
-                .descriptionAndTooltip(JavaErrorLocalize.classesExtendsEnum())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.classesExtendsEnum());
         }
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkGenericCannotExtendException(PsiReferenceList list) {
+    public static HighlightInfo.Builder checkGenericCannotExtendException(PsiReferenceList list) {
         PsiElement parent = list.getParent();
         if (!(parent instanceof PsiClass aClass)) {
             return null;
@@ -1558,13 +1546,13 @@ public static HighlightInfo checkGenericCannotExtendException(PsiReferenceList l
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(referenceElement)
                     .descriptionAndTooltip(JavaErrorLocalize.genericExtendException())
-                    .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, classType, false))
-                    .create();
+                    .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, classType, false));
             }
         }
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
     public static HighlightInfo checkEnumMustNotBeLocal(PsiClass aClass) {
         if (!aClass.isEnum()) {
@@ -1581,8 +1569,9 @@ public static HighlightInfo checkEnumMustNotBeLocal(PsiClass aClass) {
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkEnumWithoutConstantsCantHaveAbstractMethods(PsiClass aClass) {
+    public static HighlightInfo.Builder checkEnumWithoutConstantsCantHaveAbstractMethods(PsiClass aClass) {
         if (!aClass.isEnum()) {
             return null;
         }
@@ -1597,15 +1586,15 @@ public static HighlightInfo checkEnumWithoutConstantsCantHaveAbstractMethods(Psi
                     .range(HighlightNamesUtil.getClassDeclarationTextRange(aClass))
                     .descriptionAndTooltip(
                         LocalizeValue.localizeTODO("Enum declaration without enum constants cannot have abstract methods")
-                    )
-                    .create();
+                    );
             }
         }
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkSelectStaticClassFromParameterizedType(PsiElement resolved, PsiJavaCodeReferenceElement ref) {
+    public static HighlightInfo.Builder checkSelectStaticClassFromParameterizedType(PsiElement resolved, PsiJavaCodeReferenceElement ref) {
         if (resolved instanceof PsiClass psiClass && psiClass.isStatic()
             && ref.getQualifier() instanceof PsiJavaCodeReferenceElement javaCodeRef) {
             PsiReferenceParameterList parameterList = javaCodeRef.getParameterList();
@@ -1614,8 +1603,7 @@ public static HighlightInfo checkSelectStaticClassFromParameterizedType(PsiEleme
                     .range(parameterList)
                     .descriptionAndTooltip(JavaErrorLocalize.genericsSelectStaticClassFromParameterizedType(
                         HighlightUtil.formatClass(psiClass)
-                    ))
-                    .create();
+                    ));
             }
         }
         return null;
@@ -1634,8 +1622,9 @@ public static HighlightInfo.Builder checkCannotInheritFromTypeParameter(PsiClass
     /**
      * http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.8
      */
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkRawOnParameterizedType(@Nonnull PsiJavaCodeReferenceElement parent, PsiElement resolved) {
+    public static HighlightInfo.Builder checkRawOnParameterizedType(@Nonnull PsiJavaCodeReferenceElement parent, PsiElement resolved) {
         PsiReferenceParameterList list = parent.getParameterList();
         if (list == null || list.getTypeArguments().length > 0) {
             return null;
@@ -1647,14 +1636,14 @@ public static HighlightInfo checkRawOnParameterizedType(@Nonnull PsiJavaCodeRefe
             && !typeParamListOwner.isStatic()) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(parent)
-                .descriptionAndTooltip(JavaErrorLocalize.textImproperFormedType())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.textImproperFormedType());
         }
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkCannotPassInner(PsiJavaCodeReferenceElement ref) {
+    public static HighlightInfo.Builder checkCannotPassInner(PsiJavaCodeReferenceElement ref) {
         if (!(ref.getParent() instanceof PsiTypeElement)) {
             return null;
         }
@@ -1683,8 +1672,7 @@ public static HighlightInfo checkCannotPassInner(PsiJavaCodeReferenceElement ref
                     || unqualifiedNestedClassReferenceAccessedViaContainingClassInheritance(typeClass, resolvedClass.getImplementsList())) {
                     return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                         .descriptionAndTooltip(LocalizeValue.localizeTODO(resolvedClass.getName() + " is not accessible in current context"))
-                        .range(ref)
-                        .create();
+                        .range(ref);
                 }
             }
         }
@@ -1765,17 +1753,19 @@ public static HighlightInfo.Builder checkInferredIntersections(PsiSubstitutor su
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo areSupersAccessible(@Nonnull PsiClass aClass) {
+    public static HighlightInfo.Builder areSupersAccessible(@Nonnull PsiClass aClass) {
         return areSupersAccessible(aClass, aClass.getResolveScope(), HighlightNamesUtil.getClassDeclarationTextRange(aClass), true);
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo areSupersAccessible(@Nonnull PsiClass aClass, PsiReferenceExpression ref) {
+    public static HighlightInfo.Builder areSupersAccessible(@Nonnull PsiClass aClass, PsiReferenceExpression ref) {
         GlobalSearchScope resolveScope = ref.getResolveScope();
-        HighlightInfo info = areSupersAccessible(aClass, resolveScope, ref.getTextRange(), false);
-        if (info != null) {
-            return info;
+        HighlightInfo.Builder hlBuilder = areSupersAccessible(aClass, resolveScope, ref.getTextRange(), false);
+        if (hlBuilder != null) {
+            return hlBuilder;
         }
 
         String message = null;
@@ -1813,14 +1803,13 @@ else if (ref.resolve() instanceof PsiField field) {
         if (message != null) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .descriptionAndTooltip(message)
-                .range(ref.getTextRange())
-                .create();
+                .range(ref.getTextRange());
         }
 
         return null;
     }
 
-    private static HighlightInfo areSupersAccessible(
+    private static HighlightInfo.Builder areSupersAccessible(
         @Nonnull PsiClass aClass,
         GlobalSearchScope resolveScope,
         TextRange range,
@@ -1832,8 +1821,7 @@ private static HighlightInfo areSupersAccessible(
             if (notAccessibleErrorMessage != null) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .descriptionAndTooltip(notAccessibleErrorMessage)
-                    .range(range)
-                    .create();
+                    .range(range);
             }
         }
         return null;
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightClassUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
index 53bed5dcc..3d893d11c 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightClassUtil.java
@@ -48,6 +48,7 @@
 import consulo.project.Project;
 import consulo.util.io.FileUtil;
 import consulo.util.lang.Comparing;
+import consulo.util.lang.ref.SimpleReference;
 import consulo.virtualFileSystem.VirtualFile;
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
@@ -100,19 +101,24 @@ public static HighlightInfo.Builder checkClassWithAbstractMethods(PsiClass aClas
             .range(range)
             .descriptionAndTooltip(description);
         PsiMethod anyMethodToImplement = ClassUtil.getAnyMethodToImplement(aClass);
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         if (anyMethodToImplement != null) {
             if (!anyMethodToImplement.hasModifierProperty(PsiModifier.PACKAGE_LOCAL)
                 || JavaPsiFacade.getInstance(aClass.getProject()).arePackagesTheSame(aClass, superClass)) {
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createImplementMethodsFix(implementsFixElement));
+                hlBuilder.registerFix(factory.createImplementMethodsFix(implementsFixElement));
             }
             else {
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createModifierListFix(anyMethodToImplement, PsiModifier.PROTECTED, true, true));
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createModifierListFix(anyMethodToImplement, PsiModifier.PUBLIC, true, true));
+                hlBuilder.registerFix(
+                    factory.createModifierFixBuilder(anyMethodToImplement).add(PsiModifier.PROTECTED).showContainingClass().create()
+                );
+                hlBuilder.registerFix(
+                    factory.createModifierFixBuilder(anyMethodToImplement).add(PsiModifier.PUBLIC).showContainingClass().create()
+                );
             }
         }
         if (!(aClass instanceof PsiAnonymousClass)
             && HighlightUtil.getIncompatibleModifier(PsiModifier.ABSTRACT, aClass.getModifierList()) == null) {
-            hlBuilder.registerFix(QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.ABSTRACT));
+            hlBuilder.registerFix(factory.createModifierFixBuilder(aClass).add(PsiModifier.ABSTRACT).create());
         }
         return hlBuilder;
     }
@@ -135,12 +141,13 @@ public static HighlightInfo.Builder checkInstantiationOfAbstractClass(PsiClass a
                 .range(highlightElement)
                 .descriptionAndTooltip(JavaErrorLocalize.abstractCannotBeInstantiated(aClass.getName()));
             PsiMethod anyAbstractMethod = ClassUtil.getAnyAbstractMethod(aClass);
+            QuickFixFactory factory = QuickFixFactory.getInstance();
             if (!aClass.isInterface() && anyAbstractMethod == null) {
                 // suggest to make not abstract only if possible
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(aClass, PsiModifier.ABSTRACT));
+                hlBuilder.registerFix(factory.createModifierFixBuilder(aClass).remove(PsiModifier.ABSTRACT).create());
             }
             if (anyAbstractMethod != null && highlightElement instanceof PsiNewExpression newExpr && newExpr.getClassReference() != null) {
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createImplementAbstractClassMethodsFix(highlightElement));
+                hlBuilder.registerFix(factory.createImplementAbstractClassMethodsFix(highlightElement));
             }
             return hlBuilder;
         }
@@ -262,7 +269,7 @@ public static HighlightInfo checkDuplicateNestedClass(PsiClass aClass) {
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkPublicClassInRightFile(PsiClass aClass) {
+    public static HighlightInfo.Builder checkPublicClassInRightFile(PsiClass aClass) {
         PsiFile containingFile = aClass.getContainingFile();
         if (aClass.getParent() != containingFile || !aClass.isPublic() || !(containingFile instanceof PsiJavaFile)) {
             return null;
@@ -278,7 +285,7 @@ public static HighlightInfo checkPublicClassInRightFile(PsiClass aClass) {
         HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(aClass, range.getStartOffset(), range.getEndOffset())
             .descriptionAndTooltip(JavaErrorLocalize.publicClassShouldBeNamedAfterFile(aClass.getName()))
-            .registerFix(factory.createRemoveModifierFix(psiModifierList, PsiModifier.PUBLIC));
+            .registerFix(factory.createModifierFixBuilder(psiModifierList).remove(PsiModifier.PUBLIC).create());
         PsiClass[] classes = file.getClasses();
         if (classes.length > 1) {
             errorResult.registerFix(factory.createMoveClassToSeparateFileFix(aClass));
@@ -287,24 +294,22 @@ public static HighlightInfo checkPublicClassInRightFile(PsiClass aClass) {
             if (!otherClass.getManager().areElementsEquivalent(otherClass, aClass)
                 && otherClass.isPublic()
                 && otherClass.getName().equals(virtualFile.getNameWithoutExtension())) {
-                return errorResult.create();
+                return errorResult;
             }
         }
         return errorResult.registerFix(factory.createRenameFileFix(aClass.getName() + JavaFileType.DOT_DEFAULT_EXTENSION))
-            .registerFix(factory.createRenameElementFix(aClass))
-            .create();
+            .registerFix(factory.createRenameElementFix(aClass));
     }
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkClassAndPackageConflict(@Nonnull PsiClass aClass) {
+    public static HighlightInfo.Builder checkClassAndPackageConflict(@Nonnull PsiClass aClass) {
         String name = aClass.getQualifiedName();
 
         if (JavaClassNames.DEFAULT_PACKAGE.equals(name)) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(HighlightNamesUtil.getClassDeclarationTextRange(aClass))
-                .descriptionAndTooltip(JavaErrorLocalize.classClashesWithPackage(name))
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.classClashesWithPackage(name));
         }
 
         PsiElement file = aClass.getParent();
@@ -315,8 +320,7 @@ public static HighlightInfo checkClassAndPackageConflict(@Nonnull PsiClass aClas
             if (subDirectory != null && simpleName.equals(subDirectory.getName())) {
                 return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(HighlightNamesUtil.getClassDeclarationTextRange(aClass))
-                    .descriptionAndTooltip(JavaErrorLocalize.classClashesWithPackage(name))
-                    .create();
+                    .descriptionAndTooltip(JavaErrorLocalize.classClashesWithPackage(name));
             }
         }
 
@@ -335,14 +339,15 @@ private static HighlightInfo checkStaticFieldDeclarationInInnerClass(@Nonnull Ps
             return null;
         }
 
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         HighlightInfo.Builder result = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(keyword)
             .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass())
-            .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(field, PsiModifier.STATIC));
+            .registerFix(factory.createModifierFixBuilder(field).remove(PsiModifier.STATIC).create());
 
         PsiClass aClass = field.getContainingClass();
         if (aClass != null) {
-            result.registerFix(QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.STATIC));
+            result.registerFix(factory.createModifierFixBuilder(aClass).add(PsiModifier.STATIC).create());
         }
 
         return result.create();
@@ -362,11 +367,12 @@ private static HighlightInfo checkStaticMethodDeclarationInInnerClass(PsiKeyword
         if (PsiUtilCore.hasErrorElementChild(method)) {
             return null;
         }
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(keyword)
             .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass())
-            .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(method, PsiModifier.STATIC))
-            .registerFix(QuickFixFactory.getInstance().createAddModifierFix((PsiClass)method.getParent(), PsiModifier.STATIC))
+            .registerFix(factory.createModifierFixBuilder(method).remove(PsiModifier.STATIC).create())
+            .registerFix(factory.createModifierFixBuilder((PsiClass)method.getParent()).add(PsiModifier.STATIC).create())
             .create();
     }
 
@@ -381,11 +387,12 @@ private static HighlightInfo checkStaticInitializerDeclarationInInnerClass(PsiKe
             return null;
         }
         PsiClass owner = (PsiClass)keyword.getParent().getParent().getParent();
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(keyword)
             .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass())
-            .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(initializer, PsiModifier.STATIC))
-            .registerFix(QuickFixFactory.getInstance().createAddModifierFix(owner, PsiModifier.STATIC))
+            .registerFix(factory.createModifierFixBuilder(initializer).remove(PsiModifier.STATIC).create())
+            .registerFix(factory.createModifierFixBuilder(owner).add(PsiModifier.STATIC).create())
             .create();
     }
 
@@ -438,11 +445,11 @@ private static HighlightInfo checkStaticClassDeclarationInInnerClass(PsiKeyword
             .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass());
         QuickFixFactory factory = QuickFixFactory.getInstance();
         if (context != keyword) {
-            info.registerFix(factory.createRemoveModifierFix(aClass, PsiModifier.STATIC));
+            info.registerFix(factory.createModifierFixBuilder(aClass).remove(PsiModifier.STATIC).create());
         }
         PsiClass containingClass = aClass.getContainingClass();
         if (containingClass != null) {
-            info.registerFix(factory.createAddModifierFix(containingClass, PsiModifier.STATIC));
+            info.registerFix(factory.createModifierFixBuilder(containingClass).add(PsiModifier.STATIC).create());
         }
         return info.create();
     }
@@ -538,7 +545,7 @@ public static HighlightInfo.Builder checkCannotInheritFromFinal(PsiClass superCl
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(elementToHighlight)
                 .descriptionAndTooltip(JavaErrorLocalize.inheritanceFromFinalClass(superClass.getQualifiedName()))
-                .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(superClass, PsiModifier.FINAL));
+                .registerFix(QuickFixFactory.getInstance().createModifierFixBuilder(superClass).remove(PsiModifier.FINAL).create());
         }
         return null;
     }
@@ -697,7 +704,7 @@ public static PsiClass getCircularClass(PsiClass aClass, Collection<PsiClass> us
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkExtendsDuplicate(
+    public static HighlightInfo.Builder checkExtendsDuplicate(
         PsiJavaCodeReferenceElement element,
         PsiElement resolved,
         @Nonnull PsiFile containingFile
@@ -725,8 +732,7 @@ public static HighlightInfo checkExtendsDuplicate(
         if (dupCount > 1) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(element)
-                .descriptionAndTooltip(JavaErrorLocalize.duplicateClass(HighlightUtil.formatClass(aClass)))
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.duplicateClass(HighlightUtil.formatClass(aClass)));
         }
         return null;
     }
@@ -785,59 +791,54 @@ public static HighlightInfo checkClassExtendsOnlyOneClass(PsiReferenceList list)
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkThingNotAllowedInInterface(PsiElement element, PsiClass aClass) {
+    public static HighlightInfo.Builder checkThingNotAllowedInInterface(PsiElement element, PsiClass aClass) {
         if (aClass == null || !aClass.isInterface()) {
             return null;
         }
         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(element)
-            .descriptionAndTooltip(JavaErrorLocalize.notAllowedInInterface())
-            .create();
+            .descriptionAndTooltip(JavaErrorLocalize.notAllowedInInterface());
     }
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkQualifiedNew(PsiNewExpression expression, PsiType type, PsiClass aClass) {
+    public static HighlightInfo.Builder checkQualifiedNew(PsiNewExpression expression, PsiType type, PsiClass aClass) {
         PsiExpression qualifier = expression.getQualifier();
         if (qualifier == null) {
             return null;
         }
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         if (type instanceof PsiArrayType) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(expression)
                 .descriptionAndTooltip(JavaErrorLocalize.invalidQualifiedNew())
-                .registerFix(QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, null))
-                .create();
+                .registerFix(factory.createRemoveNewQualifierFix(expression, null));
         }
         if (aClass != null) {
-            HighlightInfo.Builder info = null;
             if (aClass.isStatic()) {
-                info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                HighlightInfo.Builder hlBuilder = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(expression)
                     .descriptionAndTooltip(JavaErrorLocalize.qualifiedNewOfStaticClass());
                 if (!aClass.isEnum()) {
-                    info.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(aClass, PsiModifier.STATIC));
+                    hlBuilder.registerFix(factory.createModifierFixBuilder(aClass).remove(PsiModifier.STATIC).create());
                 }
+                hlBuilder.registerFix(factory.createRemoveNewQualifierFix(expression, aClass));
             }
             else if (aClass instanceof PsiAnonymousClass anonymousClass) {
                 PsiClass baseClass = PsiUtil.resolveClassInType(anonymousClass.getBaseClassType());
                 if (baseClass != null && baseClass.isInterface()) {
-                    info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                    return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                         .range(expression)
                         .descriptionAndTooltip(LocalizeValue.localizeTODO(
                             "Anonymous class implements interface; cannot have qualifier for new"
-                        ));
+                        ))
+                        .registerFix(factory.createRemoveNewQualifierFix(expression, aClass));
                 }
             }
-            if (info != null) {
-                info.registerFix(QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, aClass));
-            }
-            return info != null ? info.create() : null;
         }
         return null;
     }
 
-
     /**
      * class c extends foreign.inner {}
      *
@@ -846,7 +847,7 @@ else if (aClass instanceof PsiAnonymousClass anonymousClass) {
      */
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkClassExtendsForeignInnerClass(PsiJavaCodeReferenceElement extendRef, PsiElement resolved) {
+    public static HighlightInfo.Builder checkClassExtendsForeignInnerClass(PsiJavaCodeReferenceElement extendRef, PsiElement resolved) {
         if (!(extendRef.getParent() instanceof PsiReferenceList referenceList
             && referenceList.getParent() instanceof PsiClass aClass)) {
             return null;
@@ -868,14 +869,13 @@ public static HighlightInfo checkClassExtendsForeignInnerClass(PsiJavaCodeRefere
         if (!(resolved instanceof PsiClass)) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(extendRef)
-                .descriptionAndTooltip(JavaErrorLocalize.classNameExpected())
-                .create();
+                .descriptionAndTooltip(JavaErrorLocalize.classNameExpected());
         }
-        HighlightInfo[] infos = new HighlightInfo[1];
+        SimpleReference<HighlightInfo.Builder> infos = SimpleReference.create();
         extendRef.accept(new JavaRecursiveElementWalkingVisitor() {
             @Override
             public void visitElement(PsiElement element) {
-                if (infos[0] != null) {
+                if (!infos.isNull()) {
                     return;
                 }
                 super.visitElement(element);
@@ -888,13 +888,14 @@ public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference
                 if (reference.resolve() instanceof PsiClass base) {
                     PsiClass baseClass = base.getContainingClass();
                     if (baseClass != null && base.isPrivate() && baseClass == containerClass) {
-                        infos[0] = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
-                            .range(extendRef)
-                            .descriptionAndTooltip(JavaErrorLocalize.privateSymbol(
-                                HighlightUtil.formatClass(base),
-                                HighlightUtil.formatClass(baseClass)
-                            ))
-                            .create();
+                        infos.set(
+                            HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                                .range(extendRef)
+                                .descriptionAndTooltip(JavaErrorLocalize.privateSymbol(
+                                    HighlightUtil.formatClass(base),
+                                    HighlightUtil.formatClass(baseClass)
+                                ))
+                        );
                         return;
                     }
 
@@ -905,23 +906,19 @@ public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement reference
 
                     if (base == resolved && baseClass != null
                         && (!PsiTreeUtil.isAncestor(baseClass, extendRef, true) || aClass.isStatic())
-                        && !InheritanceUtil.hasEnclosingInstanceInScope(
-                        baseClass,
-                        extendRef,
-                        !aClass.isStatic(),
-                        true
-                    )
+                        && !InheritanceUtil.hasEnclosingInstanceInScope(baseClass, extendRef, !aClass.isStatic(), true)
                         && !qualifiedNewCalledInConstructors(aClass)) {
-                        infos[0] = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
-                            .range(extendRef)
-                            .descriptionAndTooltip(JavaErrorLocalize.noEnclosingInstanceInScope(HighlightUtil.formatClass(baseClass)))
-                            .create();
+                        infos.set(
+                            HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                                .range(extendRef)
+                                .descriptionAndTooltip(JavaErrorLocalize.noEnclosingInstanceInScope(HighlightUtil.formatClass(baseClass)))
+                        );
                     }
                 }
             }
         });
 
-        return infos[0];
+        return infos.get();
     }
 
     /**
@@ -1087,14 +1084,15 @@ public static HighlightInfo reportIllegalEnclosingUsage(
         if (staticParent != null) {
             String element = outerClass == null ? "" : HighlightUtil.formatClass(outerClass) + "." +
                 (place instanceof PsiSuperExpression ? PsiKeyword.SUPER : PsiKeyword.THIS);
+            QuickFixFactory factory = QuickFixFactory.getInstance();
             HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(elementToHighlight)
                 .descriptionAndTooltip(JavaErrorLocalize.cannotBeReferencedFromStaticContext(element))
                 // make context not static or referenced class static
-                .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(staticParent, PsiModifier.STATIC));
+                .registerFix(factory.createModifierFixBuilder(staticParent).remove(PsiModifier.STATIC).create());
             if (aClass != null
                 && HighlightUtil.getIncompatibleModifier(PsiModifier.STATIC, aClass.getModifierList()) == null) {
-                highlightInfo.registerFix(QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.STATIC));
+                highlightInfo.registerFix(factory.createModifierFixBuilder(aClass).add(PsiModifier.STATIC).create());
             }
             return highlightInfo.create();
         }
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java
index d23be25f7..3d240f75e 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightControlFlowUtil.java
@@ -28,7 +28,7 @@
 import consulo.annotation.access.RequiredReadAction;
 import consulo.application.dumb.IndexNotReadyException;
 import consulo.document.util.TextRange;
-import consulo.java.analysis.impl.JavaQuickFixBundle;
+import consulo.java.analysis.impl.localize.JavaQuickFixLocalize;
 import consulo.java.language.impl.localize.JavaErrorLocalize;
 import consulo.language.ast.IElementType;
 import consulo.language.editor.rawHighlight.HighlightInfo;
@@ -100,7 +100,7 @@ private static ControlFlow getControlFlow(@Nonnull PsiElement context) throws An
     }
 
     @RequiredReadAction
-    public static HighlightInfo checkUnreachableStatement(@Nullable PsiCodeBlock codeBlock) {
+    public static HighlightInfo.Builder checkUnreachableStatement(@Nullable PsiCodeBlock codeBlock) {
         if (codeBlock == null) {
             return null;
         }
@@ -123,9 +123,8 @@ public static HighlightInfo checkUnreachableStatement(@Nullable PsiCodeBlock cod
                     .descriptionAndTooltip(JavaErrorLocalize.unreachableStatement())
                     .registerFix(QuickFixFactory.getInstance().createDeleteFix(
                         unreachableStatement,
-                        JavaQuickFixBundle.message("delete.unreachable.statement.fix.text")
-                    ))
-                    .create();
+                        JavaQuickFixLocalize.deleteUnreachableStatementFixText()
+                    ));
             }
         }
         catch (AnalysisCanceledException | IndexNotReadyException e) {
@@ -277,22 +276,23 @@ public static HighlightInfo checkFinalFieldInitialized(@Nonnull PsiField field)
         }
 
         TextRange range = HighlightNamesUtil.getFieldDeclarationTextRange(field);
+        QuickFixFactory factory = QuickFixFactory.getInstance();
         HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(range)
             .descriptionAndTooltip(JavaErrorLocalize.variableNotInitialized(field.getName()))
             .registerFix(
-                QuickFixFactory.getInstance().createCreateConstructorParameterFromFieldFix(field),
+                factory.createCreateConstructorParameterFromFieldFix(field),
                 HighlightMethodUtil.getFixRange(field)
             )
             .registerFix(
-                QuickFixFactory.getInstance().createInitializeFinalFieldInConstructorFix(field),
+                factory.createInitializeFinalFieldInConstructorFix(field),
                 HighlightMethodUtil.getFixRange(field)
             );
         PsiClass containingClass = field.getContainingClass();
         if (containingClass != null && !containingClass.isInterface()) {
-            highlightInfo.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(field, PsiModifier.FINAL));
+            highlightInfo.registerFix(factory.createModifierFixBuilder(field).remove(PsiModifier.FINAL).create());
         }
-        return highlightInfo.registerFix(QuickFixFactory.getInstance().createAddVariableInitializerFix(field))
+        return highlightInfo.registerFix(factory.createAddVariableInitializerFix(field))
             .create();
     }
 
@@ -496,17 +496,18 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers()))
         }
         if (codeBlockProblems.contains(expression)) {
             String name = expression.getElement().getText();
-            HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+            QuickFixFactory factory = QuickFixFactory.getInstance();
+            HighlightInfo.Builder hlBuilder = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(expression)
                 .descriptionAndTooltip(JavaErrorLocalize.variableNotInitialized(name))
-                .registerFix(QuickFixFactory.getInstance().createAddVariableInitializerFix(variable));
+                .registerFix(factory.createAddVariableInitializerFix(variable));
             if (variable instanceof PsiLocalVariable) {
                 //highlightInfo.registerFix(HighlightFixUtil.createInsertSwitchDefaultFix(variable, topBlock, expression));
             }
             if (variable instanceof PsiField) {
-                highlightInfo.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(variable, PsiModifier.FINAL));
+                hlBuilder.registerFix(factory.createModifierFixBuilder(variable).remove(PsiModifier.FINAL).create());
             }
-            return highlightInfo.create();
+            return hlBuilder.create();
         }
 
         return null;
@@ -677,7 +678,7 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo(
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(expression)
                 .descriptionAndTooltip(JavaErrorLocalize.variableAlreadyAssigned(variable.getName()))
-                .registerFix(factory.createRemoveModifierFix(variable, PsiModifier.FINAL))
+                .registerFix(factory.createModifierFixBuilder(variable).remove(PsiModifier.FINAL).create())
                 .registerFix(factory.createDeferFinalAssignmentFix(variable, expression))
                 .create();
         }
@@ -715,7 +716,7 @@ public static HighlightInfo checkFinalVariableInitializedInLoop(
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(expression)
                 .descriptionAndTooltip(JavaErrorLocalize.variableAssignedInLoop(((PsiVariable)resolved).getName()))
-                .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix((PsiVariable)resolved, PsiModifier.FINAL))
+                .registerFix(QuickFixFactory.getInstance().createModifierFixBuilder((PsiVariable)resolved).remove(PsiModifier.FINAL).create())
                 .create();
         }
         return null;
@@ -761,13 +762,14 @@ else if (expression instanceof PsiPrefixExpression prefixExpr) {
                 ? JavaErrorLocalize.variableNotInitialized(name)
                 : JavaErrorLocalize.assignmentToFinalVariable(name);
             PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression);
+            QuickFixFactory factory = QuickFixFactory.getInstance();
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(reference.getTextRange())
                 .descriptionAndTooltip(description)
                 .registerFix(
                     innerClass == null || variable instanceof PsiField
-                        ? QuickFixFactory.getInstance().createRemoveModifierFix(variable, PsiModifier.FINAL)
-                        : QuickFixFactory.getInstance().createVariableAccessFromInnerClassFix(variable, innerClass)
+                        ? factory.createModifierFixBuilder(variable).remove(PsiModifier.FINAL).create()
+                        : factory.createVariableAccessFromInnerClassFix(variable, innerClass)
                 )
                 .create();
         }
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java
index c20743169..6e109eda6 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java
@@ -154,6 +154,7 @@ private static HighlightInfo.Builder isWeaker(
             else {
                 textRange = TextRange.EMPTY_RANGE;
             }
+            QuickFixFactory factory = QuickFixFactory.getInstance();
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(textRange)
                 .descriptionAndTooltip(JavaErrorLocalize.weakerPrivileges(
@@ -161,7 +162,7 @@ private static HighlightInfo.Builder isWeaker(
                     VisibilityUtil.toPresentableText(accessModifier),
                     PsiUtil.getAccessModifier(superAccessLevel)
                 ))
-                .registerFix(QuickFixFactory.getInstance().createAddModifierFix(method, PsiUtil.getAccessModifier(superAccessLevel)));
+                .registerFix(factory.createModifierFixBuilder(method).add(PsiUtil.getAccessModifier(superAccessLevel)).create());
         }
         return null;
     }
@@ -314,6 +315,7 @@ public static HighlightInfo.Builder checkMethodOverridesFinal(
     private static HighlightInfo.Builder checkSuperMethodIsFinal(PsiMethod method, PsiMethod superMethod) {
         // strange things happen when super method is from Object and method from interface
         if (superMethod.isFinal()) {
+            QuickFixFactory factory = QuickFixFactory.getInstance();
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(HighlightNamesUtil.getMethodDeclarationTextRange(method))
                 .descriptionAndTooltip(JavaErrorLocalize.finalMethodOverride(
@@ -321,12 +323,7 @@ private static HighlightInfo.Builder checkSuperMethodIsFinal(PsiMethod method, P
                     JavaHighlightUtil.formatMethod(superMethod),
                     HighlightUtil.formatClass(superMethod.getContainingClass())
                 ))
-                .registerFix(QuickFixFactory.getInstance().createModifierListFix(
-                    superMethod,
-                    PsiModifier.FINAL,
-                    false,
-                    true
-                ));
+                .registerFix(factory.createModifierFixBuilder(superMethod).remove(PsiModifier.FINAL).showContainingClass().create());
         }
         return null;
     }
@@ -1038,7 +1035,7 @@ private static void registerMethodCallIntentions(
         QuickFixFactory factory = QuickFixFactory.getInstance();
         if (methodCall.getMethodExpression().getQualifierExpression() instanceof PsiReferenceExpression qualifierExpr
             && qualifierExpr.resolve() instanceof PsiClass psiClass && psiClass.getContainingClass() != null && !psiClass.isStatic()) {
-            hlBuilder.registerFix(factory.createAddModifierFix(psiClass, PsiModifier.STATIC));
+            hlBuilder.registerFix(factory.createModifierFixBuilder(psiClass).add(PsiModifier.STATIC).create());
         }
 
         hlBuilder.registerFix(factory.createCreateMethodFromUsageFix(methodCall), fixRange)
@@ -1363,7 +1360,7 @@ public static HighlightInfo checkMethodMustHaveBody(PsiMethod method, PsiClass a
                 .range(start, end)
                 .descriptionAndTooltip(JavaErrorLocalize.missingMethodBody());
             if (HighlightUtil.getIncompatibleModifier(PsiModifier.ABSTRACT, method.getModifierList()) == null) {
-                errorResult.registerFix(factory.createAddModifierFix(method, PsiModifier.ABSTRACT));
+                errorResult.registerFix(factory.createModifierFixBuilder(method).add(PsiModifier.ABSTRACT).create());
             }
             return errorResult.registerFix(factory.createAddMethodBodyFix(method))
                 .create();
@@ -1381,10 +1378,10 @@ public static HighlightInfo checkAbstractMethodInConcreteClass(PsiMethod method,
                 .range(elementToHighlight)
                 .descriptionAndTooltip(JavaErrorLocalize.abstractMethodInNonAbstractClass());
             if (method.getBody() != null) {
-                errorResult.registerFix(factory.createRemoveModifierFix(method, PsiModifier.ABSTRACT));
+                errorResult.registerFix(factory.createModifierFixBuilder(method).remove(PsiModifier.ABSTRACT).create());
             }
             return errorResult.registerFix(factory.createAddMethodBodyFix(method))
-                .registerFix(factory.createAddModifierFix(aClass, PsiModifier.ABSTRACT))
+                .registerFix(factory.createModifierFixBuilder(aClass).add(PsiModifier.ABSTRACT).create())
                 .create();
         }
         return null;
@@ -1480,8 +1477,8 @@ else if (isInterface) {
             if (!isExtension && !isStatic && !isPrivate) {
                 description = JavaErrorLocalize.interfaceMethodsCannotHaveBody();
                 if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)) {
-                    additionalFixes.add(factory.createAddModifierFix(method, PsiModifier.DEFAULT));
-                    additionalFixes.add(factory.createAddModifierFix(method, PsiModifier.STATIC));
+                    additionalFixes.add(factory.createModifierFixBuilder(method).add(PsiModifier.DEFAULT).create());
+                    additionalFixes.add(factory.createModifierFixBuilder(method).add(PsiModifier.STATIC).create());
                 }
             }
             else {
@@ -1508,7 +1505,7 @@ else if (method.hasModifierProperty(PsiModifier.NATIVE)) {
             info.registerFix(factory.createDeleteMethodBodyFix(method));
         }
         if (method.isAbstract() && !isInterface) {
-            info.registerFix(factory.createRemoveModifierFix(method, PsiModifier.ABSTRACT));
+            info.registerFix(factory.createModifierFixBuilder(method).remove(PsiModifier.ABSTRACT).create());
         }
         for (IntentionAction intentionAction : additionalFixes) {
             info.registerFix(intentionAction);
@@ -1677,21 +1674,22 @@ private static HighlightInfo.Builder checkStaticMethodOverride(
                 .range(HighlightNamesUtil.getMethodDeclarationTextRange(method))
                 .descriptionAndTooltip(description);
             if (!isSuperMethodStatic || HighlightUtil.getIncompatibleModifier(PsiModifier.STATIC, modifierList) == null) {
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createModifierListFix(
-                    method,
-                    PsiModifier.STATIC,
-                    isSuperMethodStatic,
-                    false
-                ));
+                hlBuilder.registerFix(
+                    QuickFixFactory.getInstance()
+                        .createModifierFixBuilder(method)
+                        .toggle(PsiModifier.STATIC, isSuperMethodStatic)
+                        .create()
+                );
             }
             if (manager.isInProject(superMethod)
                 && (!isMethodStatic || HighlightUtil.getIncompatibleModifier(PsiModifier.STATIC, superModifierList) == null)) {
-                hlBuilder.registerFix(QuickFixFactory.getInstance().createModifierListFix(
-                    superMethod,
-                    PsiModifier.STATIC,
-                    isMethodStatic,
-                    true
-                ));
+                hlBuilder.registerFix(
+                    QuickFixFactory.getInstance()
+                        .createModifierFixBuilder(superMethod)
+                        .toggle(PsiModifier.STATIC, isMethodStatic)
+                        .showContainingClass()
+                        .create()
+                );
             }
             return hlBuilder;
         }
@@ -1868,8 +1866,9 @@ public static HighlightInfo checkOverrideEquivalentInheritedMethods(
         return null;
     }
 
+    @Nullable
     @RequiredReadAction
-    public static HighlightInfo checkConstructorHandleSuperClassExceptions(PsiMethod method) {
+    public static HighlightInfo.Builder checkConstructorHandleSuperClassExceptions(PsiMethod method) {
         if (!method.isConstructor()) {
             return null;
         }
@@ -1899,18 +1898,17 @@ public static HighlightInfo checkConstructorHandleSuperClassExceptions(PsiMethod
                 )
             ));
         }
-        return highlightInfo.create();
+        return highlightInfo;
     }
 
     @RequiredReadAction
-    public static HighlightInfo checkRecursiveConstructorInvocation(@Nonnull PsiMethod method) {
+    public static HighlightInfo.Builder checkRecursiveConstructorInvocation(@Nonnull PsiMethod method) {
         if (!HighlightControlFlowUtil.isRecursivelyCalledConstructor(method)) {
             return null;
         }
         return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
             .range(HighlightNamesUtil.getMethodDeclarationTextRange(method))
-            .descriptionAndTooltip(JavaErrorLocalize.recursiveConstructorInvocation())
-            .create();
+            .descriptionAndTooltip(JavaErrorLocalize.recursiveConstructorInvocation());
     }
 
     @Nonnull
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java
index ad57839b8..529e5754e 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightNamesUtil.java
@@ -266,16 +266,14 @@ private static HighlightInfoType getClassNameHighlightType(@Nullable PsiClass aC
 
     @Nullable
     @RequiredReadAction
-    public static HighlightInfo highlightReassignedVariable(@Nonnull PsiVariable variable, @Nonnull PsiElement elementToHighlight) {
+    public static HighlightInfo.Builder highlightReassignedVariable(@Nonnull PsiVariable variable, @Nonnull PsiElement elementToHighlight) {
         if (variable instanceof PsiLocalVariable) {
             return HighlightInfo.newHighlightInfo(JavaHighlightInfoTypes.REASSIGNED_LOCAL_VARIABLE)
-                .range(elementToHighlight)
-                .create();
+                .range(elementToHighlight);
         }
         if (variable instanceof PsiParameter) {
             return HighlightInfo.newHighlightInfo(JavaHighlightInfoTypes.REASSIGNED_PARAMETER)
-                .range(elementToHighlight)
-                .create();
+                .range(elementToHighlight);
         }
         return null;
     }
@@ -290,7 +288,7 @@ private static TextAttributes getScopeAttributes(@Nonnull PsiElement element, @N
         List<Pair<NamedScope, NamedScopesHolder>> scopes = validationManager.getScopeBasedHighlightingCachedScopes();
         for (Pair<NamedScope, NamedScopesHolder> scope : scopes) {
             NamedScope namedScope = scope.getFirst();
-            TextAttributesKey scopeKey = ScopeAttributesUtil.getScopeTextAttributeKey(namedScope.getName());
+            TextAttributesKey scopeKey = ScopeAttributesUtil.getScopeTextAttributeKey(namedScope);
             TextAttributes attributes = colorsScheme.getAttributes(scopeKey);
             if (attributes == null || attributes.isEmpty()) {
                 continue;
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightUtil.java
index ab308eea4..0ff50f685 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightUtil.java
@@ -311,9 +311,13 @@ public static void registerAccessQuickFixAction(
 
         PsiClass packageLocalClassInTheMiddle = getPackageLocalClassInTheMiddle(place);
         if (packageLocalClassInTheMiddle != null) {
-            IntentionAction fix = QuickFixFactory.getInstance()
-                .createModifierListFix(packageLocalClassInTheMiddle, PsiModifier.PUBLIC, true, true);
-            hlBuilder.registerFix(fix);
+            hlBuilder.registerFix(
+                QuickFixFactory.getInstance()
+                    .createModifierFixBuilder(packageLocalClassInTheMiddle)
+                    .add(PsiModifier.PUBLIC)
+                    .showContainingClass()
+                    .create()
+            );
             return;
         }
 
@@ -343,13 +347,15 @@ public static void registerAccessQuickFixAction(
                 String modifier = modifiers[i];
                 modifierListCopy.setModifierProperty(modifier, true);
                 if (facade.getResolveHelper().isAccessible(refElement, modifierListCopy, place, accessObjectClass, fileResolveScope)) {
-                    IntentionAction fix = QuickFixFactory.getInstance().createModifierListFix(refElement, modifier, true, true);
                     TextRange fixRange = hlRange;
                     PsiElement ref = place.getReferenceNameElement();
                     if (ref != null) {
                         fixRange = fixRange.union(ref.getTextRange());
                     }
-                    hlBuilder.registerFix(fix, fixRange);
+                    hlBuilder.registerFix(
+                        QuickFixFactory.getInstance().createModifierFixBuilder(refElement).add(modifier).showContainingClass().create(),
+                        fixRange
+                    );
                 }
             }
         }
@@ -1045,7 +1051,7 @@ public static HighlightInfo checkIllegalModifierCombination(@Nonnull PsiKeyword
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(keyword)
                 .descriptionAndTooltip(JavaErrorLocalize.incompatibleModifiers(modifier, incompatible))
-                .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(modifierList, modifier))
+                .registerFix(QuickFixFactory.getInstance().createModifierFixBuilder(modifierList).remove(modifier).create())
                 .create();
         }
 
@@ -1189,7 +1195,7 @@ else if (modifierOwner instanceof PsiReceiverParameter) {
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(keyword)
                 .descriptionAndTooltip(JavaErrorLocalize.modifierNotAllowed(modifier))
-                .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(modifierList, modifier))
+                .registerFix(QuickFixFactory.getInstance().createModifierFixBuilder(modifierList).remove(modifier).create())
                 .create();
         }
 
@@ -2125,12 +2131,12 @@ public static void registerStaticProblemQuickFixAction(
     ) {
         QuickFixFactory factory = QuickFixFactory.getInstance();
         if (refElement instanceof PsiModifierListOwner modifierListOwner) {
-            hlBuilder.registerFix(factory.createAddModifierFix(modifierListOwner, PsiModifier.STATIC));
+            hlBuilder.registerFix(factory.createModifierFixBuilder(modifierListOwner).add(PsiModifier.STATIC).create());
         }
         // make context non static
         PsiModifierListOwner staticParent = PsiUtil.getEnclosingStaticElement(place, null);
         if (staticParent != null && isInstanceReference(place)) {
-            hlBuilder.registerFix(factory.createRemoveModifierFix(staticParent, PsiModifier.STATIC));
+            hlBuilder.registerFix(factory.createModifierFixBuilder(staticParent).remove(PsiModifier.STATIC).create());
         }
         if (place instanceof PsiReferenceExpression placeRefExpr && refElement instanceof PsiField) {
             hlBuilder.registerFix(factory.createCreateFieldFromUsageFix(placeRefExpr));
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
index 5f2d7c252..8044888be 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java
@@ -44,7 +44,6 @@
 import consulo.java.language.module.util.JavaClassNames;
 import consulo.language.editor.DaemonCodeAnalyzer;
 import consulo.language.editor.Pass;
-import consulo.language.editor.intention.QuickFixAction;
 import consulo.language.editor.rawHighlight.HighlightInfo;
 import consulo.language.editor.rawHighlight.HighlightInfoHolder;
 import consulo.language.editor.rawHighlight.HighlightInfoType;
@@ -266,28 +265,28 @@ public void visitAnnotation(@Nonnull PsiAnnotation annotation) {
             add(AnnotationsHighlightUtil.checkApplicability(annotation, myLanguageLevel, myFile));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(AnnotationsHighlightUtil.checkAnnotationType(annotation));
+            add(AnnotationsHighlightUtil.checkAnnotationType(annotation));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(AnnotationsHighlightUtil.checkMissingAttributes(annotation));
+            add(AnnotationsHighlightUtil.checkMissingAttributes(annotation));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(AnnotationsHighlightUtil.checkTargetAnnotationDuplicates(annotation));
+            add(AnnotationsHighlightUtil.checkTargetAnnotationDuplicates(annotation));
         }
         if (!myHolder.hasErrorResults()) {
             add(AnnotationsHighlightUtil.checkDuplicateAnnotations(annotation, myLanguageLevel));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(AnnotationsHighlightUtil.checkFunctionalInterface(annotation, myLanguageLevel));
+            add(AnnotationsHighlightUtil.checkFunctionalInterface(annotation, myLanguageLevel));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(AnnotationsHighlightUtil.checkRepeatableAnnotation(annotation));
+            add(AnnotationsHighlightUtil.checkRepeatableAnnotation(annotation));
         }
         if (JavaClassNames.JAVA_LANG_OVERRIDE.equals(annotation.getQualifiedName())) {
             PsiAnnotationOwner owner = annotation.getOwner();
             PsiElement parent = owner instanceof PsiModifierList modifierList ? modifierList.getParent() : null;
             if (parent instanceof PsiMethod method) {
-                myHolder.add(GenericsHighlightUtil.checkOverrideAnnotation(method, annotation, myLanguageLevel));
+                add(GenericsHighlightUtil.checkOverrideAnnotation(method, annotation, myLanguageLevel));
             }
         }
     }
@@ -329,10 +328,10 @@ public void visitAnnotationMethod(PsiAnnotationMethod method) {
             myHolder.add(AnnotationsHighlightUtil.checkMemberValueType(value, returnType));
         }
 
-        myHolder.add(AnnotationsHighlightUtil.checkValidAnnotationType(method.getReturnType(), method.getReturnTypeElement()));
+        add(AnnotationsHighlightUtil.checkValidAnnotationType(method.getReturnType(), method.getReturnTypeElement()));
         PsiClass aClass = method.getContainingClass();
-        myHolder.add(AnnotationsHighlightUtil.checkCyclicMemberType(method.getReturnTypeElement(), aClass));
-        myHolder.add(AnnotationsHighlightUtil.checkClashesWithSuperMethods(method));
+        add(AnnotationsHighlightUtil.checkCyclicMemberType(method.getReturnTypeElement(), aClass));
+        add(AnnotationsHighlightUtil.checkClashesWithSuperMethods(method));
 
         if (!myHolder.hasErrorResults() && aClass != null) {
             myHolder.add(HighlightMethodUtil.checkDuplicateMethod(aClass, method, getDuplicateMethods(aClass)));
@@ -454,7 +453,7 @@ else if (returnErrors != null) {
         }
 
         if (!myHolder.hasErrorResults() && expression.getBody() instanceof PsiCodeBlock bodyCodeBlock) {
-            myHolder.add(HighlightControlFlowUtil.checkUnreachableStatement(bodyCodeBlock));
+            add(HighlightControlFlowUtil.checkUnreachableStatement(bodyCodeBlock));
         }
     }
 
@@ -481,7 +480,7 @@ public void visitClass(@Nonnull PsiClass aClass) {
             myHolder.add(GenericsHighlightUtil.checkInterfaceMultipleInheritance(aClass));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.areSupersAccessible(aClass));
+            add(GenericsHighlightUtil.areSupersAccessible(aClass));
         }
         if (!myHolder.hasErrorResults()) {
             myHolder.add(HighlightClassUtil.checkDuplicateTopLevelClass(aClass));
@@ -490,16 +489,16 @@ public void visitClass(@Nonnull PsiClass aClass) {
             myHolder.add(GenericsHighlightUtil.checkEnumMustNotBeLocal(aClass));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkEnumWithoutConstantsCantHaveAbstractMethods(aClass));
+            add(GenericsHighlightUtil.checkEnumWithoutConstantsCantHaveAbstractMethods(aClass));
         }
         if (!myHolder.hasErrorResults()) {
             add(HighlightUtil.checkImplicitThisReferenceBeforeSuper(aClass, myJavaSdkVersion));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkClassAndPackageConflict(aClass));
+            add(HighlightClassUtil.checkClassAndPackageConflict(aClass));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkPublicClassInRightFile(aClass));
+            add(HighlightClassUtil.checkPublicClassInRightFile(aClass));
         }
         if (!myHolder.hasErrorResults()) {
             myHolder.add(GenericsHighlightUtil.checkTypeParameterOverrideEquivalentMethods(aClass, myLanguageLevel));
@@ -514,10 +513,10 @@ public void visitClassInitializer(@Nonnull PsiClassInitializer initializer) {
             myHolder.add(HighlightControlFlowUtil.checkInitializerCompleteNormally(initializer));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightControlFlowUtil.checkUnreachableStatement(initializer.getBody()));
+            add(HighlightControlFlowUtil.checkUnreachableStatement(initializer.getBody()));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkThingNotAllowedInInterface(initializer, initializer.getContainingClass()));
+            add(HighlightClassUtil.checkThingNotAllowedInInterface(initializer, initializer.getContainingClass()));
         }
     }
 
@@ -526,7 +525,7 @@ public void visitClassInitializer(@Nonnull PsiClassInitializer initializer) {
     public void visitClassObjectAccessExpression(@Nonnull PsiClassObjectAccessExpression expression) {
         super.visitClassObjectAccessExpression(expression);
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkClassObjectAccessExpression(expression));
+            add(GenericsHighlightUtil.checkClassObjectAccessExpression(expression));
         }
     }
 
@@ -781,7 +780,7 @@ public void visitIdentifier(PsiIdentifier identifier) {
             }
             // method params are highlighted in visitMethod since we should make sure the method body was visited before
             else if (HighlightControlFlowUtil.isReassigned(variable, myFinalVarProblems)) {
-                myHolder.add(HighlightNamesUtil.highlightReassignedVariable(variable, identifier));
+                add(HighlightNamesUtil.highlightReassignedVariable(variable, identifier));
             }
             else {
                 myHolder.add(HighlightNamesUtil.highlightVariableName(variable, identifier, colorsScheme));
@@ -1003,21 +1002,21 @@ public void visitLiteralExpression(@Nonnull PsiLiteralExpression expression) {
     public void visitMethod(@Nonnull PsiMethod method) {
         super.visitMethod(method);
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightControlFlowUtil.checkUnreachableStatement(method.getBody()));
+            add(HighlightControlFlowUtil.checkUnreachableStatement(method.getBody()));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightMethodUtil.checkConstructorHandleSuperClassExceptions(method));
+            add(HighlightMethodUtil.checkConstructorHandleSuperClassExceptions(method));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightMethodUtil.checkRecursiveConstructorInvocation(method));
+            add(HighlightMethodUtil.checkRecursiveConstructorInvocation(method));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkSafeVarargsAnnotation(method, myLanguageLevel));
+            add(GenericsHighlightUtil.checkSafeVarargsAnnotation(method, myLanguageLevel));
         }
 
         PsiClass aClass = method.getContainingClass();
         if (!myHolder.hasErrorResults() && method.isConstructor()) {
-            myHolder.add(HighlightClassUtil.checkThingNotAllowedInInterface(method, aClass));
+            add(HighlightClassUtil.checkThingNotAllowedInInterface(method, aClass));
         }
         if (!myHolder.hasErrorResults() && method.hasModifierProperty(PsiModifier.DEFAULT)) {
             add(checkFeature(method, JavaFeature.EXTENSION_METHODS));
@@ -1042,7 +1041,7 @@ public void visitMethod(@Nonnull PsiMethod method) {
             PsiIdentifier nameIdentifier = parameter.getNameIdentifier();
             if (nameIdentifier != null) {
                 if (info == 2) { // reassigned
-                    myHolder.add(HighlightNamesUtil.highlightReassignedVariable(parameter, nameIdentifier));
+                    add(HighlightNamesUtil.highlightReassignedVariable(parameter, nameIdentifier));
                 }
                 else {
                     myHolder.add(HighlightNamesUtil.highlightVariableName(parameter, nameIdentifier, colorsScheme));
@@ -1098,7 +1097,7 @@ else if (resolved instanceof PsiClass psiClass) {
     @RequiredReadAction
     public void visitMethodCallExpression(@Nonnull PsiMethodCallExpression expression) {
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkEnumSuperConstructorCall(expression));
+            add(GenericsHighlightUtil.checkEnumSuperConstructorCall(expression));
         }
         if (!myHolder.hasErrorResults()) {
             add(HighlightClassUtil.checkSuperQualifierType(myFile.getProject(), expression));
@@ -1245,7 +1244,7 @@ public void visitNewExpression(PsiNewExpression expression) {
             add(HighlightClassUtil.checkAnonymousInheritFinal(expression));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkQualifiedNew(expression, type, aClass));
+            add(HighlightClassUtil.checkQualifiedNew(expression, type, aClass));
         }
         if (!myHolder.hasErrorResults()) {
             myHolder.add(HighlightClassUtil.checkCreateInnerClassFromStaticContext(expression, type, aClass));
@@ -1301,7 +1300,7 @@ public void visitParameter(@Nonnull PsiParameter parameter) {
                 add(checkFeature(parameter, JavaFeature.VARARGS));
             }
             if (!myHolder.hasErrorResults()) {
-                myHolder.add(GenericsHighlightUtil.checkVarArgParameterIsLast(parameter));
+                add(GenericsHighlightUtil.checkVarArgParameterIsLast(parameter));
             }
         }
         else if (parent instanceof PsiCatchSection) {
@@ -1368,7 +1367,7 @@ public void visitReferenceElement(@Nonnull PsiJavaCodeReferenceElement ref) {
         if (result != null) {
             PsiElement resolved = result.getElement();
             if (!myHolder.hasErrorResults()) {
-                myHolder.add(GenericsHighlightUtil.checkRawOnParameterizedType(ref, resolved));
+                add(GenericsHighlightUtil.checkRawOnParameterizedType(ref, resolved));
             }
             if (!myHolder.hasErrorResults() && resolved != null && myJavaModule != null) {
                 myHolder.add(ModuleHighlightUtil.checkPackageAccessibility(ref, resolved, myJavaModule));
@@ -1417,13 +1416,13 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE
             add(HighlightClassUtil.checkAbstractInstantiation(ref));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkExtendsDuplicate(ref, resolved, myFile));
+            add(HighlightClassUtil.checkExtendsDuplicate(ref, resolved, myFile));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(HighlightClassUtil.checkClassExtendsForeignInnerClass(ref, resolved));
+            add(HighlightClassUtil.checkClassExtendsForeignInnerClass(ref, resolved));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkSelectStaticClassFromParameterizedType(resolved, ref));
+            add(GenericsHighlightUtil.checkSelectStaticClassFromParameterizedType(resolved, ref));
         }
         if (!myHolder.hasErrorResults()) {
             add(GenericsHighlightUtil.checkParameterizedReferenceTypeArguments(
@@ -1434,7 +1433,7 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE
             ));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkCannotPassInner(ref));
+            add(GenericsHighlightUtil.checkCannotPassInner(ref));
         }
 
         if (resolved != null && parent instanceof PsiReferenceList referenceList && !myHolder.hasErrorResults()) {
@@ -1464,7 +1463,7 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE
 
             TextAttributesScheme colorsScheme = myHolder.getColorsScheme();
             if (!variable.hasModifierProperty(PsiModifier.FINAL) && isReassigned(variable)) {
-                myHolder.add(HighlightNamesUtil.highlightReassignedVariable(variable, ref));
+                add(HighlightNamesUtil.highlightReassignedVariable(variable, ref));
             }
             else {
                 PsiElement nameElement = ref.getReferenceNameElement();
@@ -1480,11 +1479,10 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE
 
         if (parent instanceof PsiNewExpression newExpr && !(resolved instanceof PsiClass) && resolved instanceof PsiNamedElement namedElem
             && newExpr.getClassOrAnonymousClassReference() == ref) {
-            myHolder.add(
+            add(
                 HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(ref)
                     .descriptionAndTooltip(JavaErrorLocalize.cannotResolveSymbol(namedElem.getName()))
-                    .create()
             );
         }
 
@@ -1669,7 +1667,7 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression)
             }
             PsiClass psiClass = PsiUtil.resolveClassInType(type);
             if (psiClass != null) {
-                myHolder.add(GenericsHighlightUtil.areSupersAccessible(psiClass, expression));
+                add(GenericsHighlightUtil.areSupersAccessible(psiClass, expression));
             }
         }
 
@@ -1725,10 +1723,11 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression
         }
 
         if (!LambdaUtil.isValidLambdaContext(parent)) {
-            myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
-                .range(expression)
-                .descriptionAndTooltip(LocalizeValue.localizeTODO("Method reference expression is not expected here"))
-                .create());
+            add(
+                HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                    .range(expression)
+                    .descriptionAndTooltip(LocalizeValue.localizeTODO("Method reference expression is not expected here"))
+            );
         }
 
         PsiType functionalInterfaceType = expression.getFunctionalInterfaceType();
@@ -1736,27 +1735,31 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression
             if (functionalInterfaceType != null) {
                 boolean notFunctional = !LambdaUtil.isFunctionalType(functionalInterfaceType);
                 if (notFunctional) {
-                    myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                    add(
+                        HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                         .range(expression)
                         .descriptionAndTooltip(LocalizeValue.localizeTODO(
                             functionalInterfaceType.getPresentableText() + " is not a functional interface"
                         ))
-                        .create());
+                    );
                 }
             }
         }
+
         if (!myHolder.hasErrorResults()) {
             PsiElement referenceNameElement = expression.getReferenceNameElement();
             if (referenceNameElement instanceof PsiKeyword && !PsiMethodReferenceUtil.isValidQualifier(expression)) {
                 PsiElement qualifier = expression.getQualifier();
                 if (qualifier != null) {
-                    myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
-                        .range(qualifier)
-                        .descriptionAndTooltip(LocalizeValue.localizeTODO("Cannot find class " + qualifier.getText()))
-                        .create());
+                    add(
+                        HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                            .range(qualifier)
+                            .descriptionAndTooltip(LocalizeValue.localizeTODO("Cannot find class " + qualifier.getText()))
+                    );
                 }
             }
         }
+
         if (!myHolder.hasErrorResults()) {
             checkFunctionalInterfaceTypeAccessible(expression, functionalInterfaceType);
         }
@@ -1769,12 +1772,12 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression
                     .descriptionAndTooltip(errorMessage);
                 if (method instanceof PsiMethod method1 && !method1.isConstructor() && !method1.isAbstract()) {
                     boolean shouldHave = !method1.isStatic();
-                    info.registerFix(QuickFixFactory.getInstance().createModifierListFix(
-                        (PsiModifierListOwner)method,
-                        PsiModifier.STATIC,
-                        shouldHave,
-                        false
-                    ));
+                    info.registerFix(
+                        QuickFixFactory.getInstance()
+                            .createModifierFixBuilder((PsiModifierListOwner)method)
+                            .toggle(PsiModifier.STATIC, shouldHave)
+                            .create()
+                    );
                 }
                 myHolder.add(info.create());
             }
@@ -1789,16 +1792,17 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression
             else {
                 String wildcardMessage = PsiMethodReferenceUtil.checkTypeArguments(typeElem, psiType);
                 if (wildcardMessage != null) {
-                    myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
-                        .range(typeElem)
-                        .descriptionAndTooltip(wildcardMessage)
-                        .create());
+                    add(
+                        HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                            .range(typeElem)
+                            .descriptionAndTooltip(wildcardMessage)
+                    );
                 }
             }
         }
 
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(PsiMethodReferenceHighlightingUtil.checkRawConstructorReference(expression));
+            add(PsiMethodReferenceHighlightingUtil.checkRawConstructorReference(expression));
         }
 
         if (!myHolder.hasErrorResults()) {
@@ -1839,17 +1843,14 @@ else if (description == null) {
                 if (description != null) {
                     PsiElement referenceNameElement = notNull(expression.getReferenceNameElement(), expression);
                     HighlightInfoType type = results.length == 0 ? HighlightInfoType.WRONG_REF : HighlightInfoType.ERROR;
-                    HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(type)
+                    HighlightInfo.Builder hlBuilder = HighlightInfo.newHighlightInfo(type)
                         .descriptionAndTooltip(description)
                         .range(referenceNameElement)
-                        .create();
-                    myHolder.add(highlightInfo);
-                    TextRange fixRange = HighlightMethodUtil.getFixRange(referenceNameElement);
-                    QuickFixAction.registerQuickFixAction(
-                        highlightInfo,
-                        fixRange,
-                        QuickFixFactory.getInstance().createCreateMethodFromUsageFix(expression)
-                    );
+                        .registerFix(
+                            QuickFixFactory.getInstance().createCreateMethodFromUsageFix(expression),
+                            HighlightMethodUtil.getFixRange(referenceNameElement)
+                        );
+                    myHolder.add(hlBuilder.create());
                 }
             }
         }
@@ -1898,7 +1899,7 @@ public void visitReferenceList(PsiReferenceList list) {
                 myHolder.add(HighlightClassUtil.checkClassExtendsOnlyOneClass(list));
             }
             if (!myHolder.hasErrorResults()) {
-                myHolder.add(GenericsHighlightUtil.checkGenericCannotExtendException(list));
+                add(GenericsHighlightUtil.checkGenericCannotExtendException(list));
             }
         }
     }
@@ -1912,10 +1913,10 @@ public void visitReferenceParameterList(PsiReferenceParameterList list) {
 
         add(checkFeature(list, JavaFeature.GENERICS));
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkParametersAllowed(list));
+            add(GenericsHighlightUtil.checkParametersAllowed(list));
         }
         if (!myHolder.hasErrorResults()) {
-            myHolder.add(GenericsHighlightUtil.checkParametersOnRaw(list));
+            add(GenericsHighlightUtil.checkParametersOnRaw(list));
         }
         if (!myHolder.hasErrorResults()) {
             for (PsiTypeElement typeElement : list.getTypeParameterElements()) {
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java
index 00b975f5f..a7d679904 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/ModuleHighlightUtil.java
@@ -306,7 +306,7 @@ public static HighlightInfo checkHostModuleStrength(@Nonnull PsiPackageAccessibi
             return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                 .range(statement)
                 .descriptionAndTooltip(JavaErrorLocalize.moduleOpensInWeakModule())
-                .registerFix(factory().createRemoveModifierFix(javaModule, PsiModifier.OPEN))
+                .registerFix(factory().createModifierFixBuilder(javaModule).remove(PsiModifier.OPEN).create())
                 .registerFix(factory().createDeleteFix(statement))
                 .create();
         }
@@ -361,7 +361,7 @@ public static List<HighlightInfo> checkPackageAccessTargets(@Nonnull PsiPackageA
                 HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(refElement)
                     .descriptionAndTooltip(message)
-                    .registerFix(factory().createDeleteFix(refElement, JavaQuickFixLocalize.deleteReferenceFixText().get()))
+                    .registerFix(factory().createDeleteFix(refElement, JavaQuickFixLocalize.deleteReferenceFixText()))
                     .create();
                 results.add(info);
             }
@@ -417,7 +417,7 @@ public static List<HighlightInfo> checkServiceImplementations(@Nonnull PsiProvid
                 HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                     .range(implRef)
                     .descriptionAndTooltip(JavaErrorLocalize.moduleDuplicateImpl(refText))
-                    .registerFix(factory().createDeleteFix(implRef, JavaQuickFixLocalize.deleteReferenceFixText().get()))
+                    .registerFix(factory().createDeleteFix(implRef, JavaQuickFixLocalize.deleteReferenceFixText()))
                     .create();
                 results.add(info);
                 continue;
diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java
index 8a4e47a00..99f27c3e5 100644
--- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java
+++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/PsiMethodReferenceHighlightingUtil.java
@@ -19,28 +19,25 @@
 import com.intellij.java.language.psi.PsiMethodReferenceExpression;
 import com.intellij.java.language.psi.PsiReferenceExpression;
 import com.intellij.java.language.psi.PsiType;
+import consulo.annotation.access.RequiredReadAction;
 import consulo.language.editor.rawHighlight.HighlightInfo;
 import consulo.language.editor.rawHighlight.HighlightInfoType;
-import consulo.language.psi.PsiElement;
 
 import jakarta.annotation.Nonnull;
 
 public class PsiMethodReferenceHighlightingUtil {
-  public static HighlightInfo checkRawConstructorReference(@Nonnull PsiMethodReferenceExpression expression) {
-    if (expression.isConstructor()) {
-      PsiType[] typeParameters = expression.getTypeParameters();
-      if (typeParameters.length > 0) {
-        PsiElement qualifier = expression.getQualifier();
-        if (qualifier instanceof PsiReferenceExpression) {
-          PsiElement resolve = ((PsiReferenceExpression) qualifier).resolve();
-          if (resolve instanceof PsiClass && ((PsiClass) resolve).hasTypeParameters()) {
-            return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression)
-                .descriptionAndTooltip("Raw constructor reference with explicit type parameters for " +
-                    "constructor").create();
-          }
+    @RequiredReadAction
+    public static HighlightInfo.Builder checkRawConstructorReference(@Nonnull PsiMethodReferenceExpression expression) {
+        if (expression.isConstructor()) {
+            PsiType[] typeParameters = expression.getTypeParameters();
+            if (typeParameters.length > 0
+                && expression.getQualifier() instanceof PsiReferenceExpression qualifierRefExpr
+                && qualifierRefExpr.resolve() instanceof PsiClass psiClass && psiClass.hasTypeParameters()) {
+                return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
+                    .range(expression)
+                    .descriptionAndTooltip("Raw constructor reference with explicit type parameters for constructor");
+            }
         }
-      }
+        return null;
     }
-    return null;
-  }
 }
diff --git a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaQuickFixLocalize.yaml b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaQuickFixLocalize.yaml
index 6355da31d..2a0c4bf48 100644
--- a/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaQuickFixLocalize.yaml
+++ b/java-analysis-impl/src/main/resources/LOCALIZE-LIB/en_US/consulo.java.analysis.impl.JavaQuickFixLocalize.yaml
@@ -530,3 +530,5 @@ extract.side.effects.multiple:
   text: Extract side effects
 extract.side.effects.family.name:
   text: Delete statement extracting side effects
+delete.unreachable.statement.fix.text:
+  text: Delete unreachable statement
\ No newline at end of file
diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java
index 52c58b5d8..5c9f2a2ec 100644
--- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java
+++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/intention/impl/config/QuickFixFactoryImpl.java
@@ -37,7 +37,6 @@
 import com.intellij.java.language.psi.util.PropertyMemberType;
 import consulo.annotation.access.RequiredReadAction;
 import consulo.annotation.component.ServiceImpl;
-import consulo.application.Application;
 import consulo.codeEditor.Editor;
 import consulo.document.Document;
 import consulo.document.util.TextRange;
@@ -60,6 +59,7 @@
 import consulo.language.psi.*;
 import consulo.language.util.AttachmentFactoryUtil;
 import consulo.language.util.IncorrectOperationException;
+import consulo.localize.LocalizeValue;
 import consulo.logging.Logger;
 import consulo.module.Module;
 import consulo.project.DumbService;
@@ -71,7 +71,6 @@
 import jakarta.annotation.Nonnull;
 import jakarta.annotation.Nullable;
 import jakarta.inject.Singleton;
-import org.jetbrains.annotations.Nls;
 
 import java.util.*;
 
@@ -81,30 +80,78 @@
 @Singleton
 @ServiceImpl
 public class QuickFixFactoryImpl extends QuickFixFactory {
+    private final class ModifierFixBuilderImpl implements ModifierFixBuilder {
+        private final PsiModifierList myModifierList;
+        private final PsiModifierListOwner myOwner;
+        private @PsiModifier.ModifierConstant String myModifier = null;
+        private boolean myShouldHave;
+        private boolean myShowContainingClass;
+
+        public ModifierFixBuilderImpl(@Nonnull PsiModifierListOwner owner) {
+            myModifierList = null;
+            myOwner = owner;
+        }
+
+        public ModifierFixBuilderImpl(@Nonnull PsiModifierList modifierList) {
+            myModifierList = modifierList;
+            myOwner = null;
+        }
+
+        @Override
+        public ModifierFixBuilder add(@PsiModifier.ModifierConstant String modifier) {
+            return toggle(modifier, true);
+        }
+
+        @Override
+        public ModifierFixBuilder remove(@PsiModifier.ModifierConstant String modifier) {
+            return toggle(modifier, false);
+        }
+
+        @Override
+        public ModifierFixBuilder toggle(@PsiModifier.ModifierConstant String modifier, boolean shouldHave) {
+            if (myModifier != null) {
+                throw new IllegalStateException();
+            }
+            myModifier = modifier;
+            myShouldHave = shouldHave;
+            return this;
+        }
+
+        @Override
+        public ModifierFixBuilder showContainingClass() {
+            if (myShowContainingClass) {
+                throw new IllegalStateException();
+            }
+            myShowContainingClass = true;
+            return this;
+        }
+
+        @Override
+        @RequiredReadAction
+        public LocalQuickFixAndIntentionActionOnPsiElement create() {
+            if (myModifier == null) {
+                throw new IllegalStateException("Should have called add/remove/toggle() to specify modifier");
+            }
+            if (myOwner != null) {
+                return new ModifierFix(myOwner, myModifier, myShouldHave, myShowContainingClass);
+            }
+            else {
+                assert myModifierList != null;
+                return new ModifierFix(myModifierList, myModifier, myShouldHave, myShowContainingClass);
+            }
+        }
+    }
+
     private static final Logger LOG = Logger.getInstance(QuickFixFactoryImpl.class);
 
-    @Nonnull
     @Override
-    @RequiredReadAction
-    public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
-        @Nonnull PsiModifierList modifierList,
-        @Nonnull String modifier,
-        boolean shouldHave,
-        boolean showContainingClass
-    ) {
-        return new ModifierFix(modifierList, modifier, shouldHave, showContainingClass);
+    public ModifierFixBuilder createModifierFixBuilder(@Nonnull PsiModifierList modifierList) {
+        return new ModifierFixBuilderImpl(modifierList);
     }
 
-    @Nonnull
     @Override
-    @RequiredReadAction
-    public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(
-        @Nonnull PsiModifierListOwner owner,
-        @Nonnull final String modifier,
-        final boolean shouldHave,
-        final boolean showContainingClass
-    ) {
-        return new ModifierFix(owner, modifier, shouldHave, showContainingClass);
+    public ModifierFixBuilder createModifierFixBuilder(@Nonnull PsiModifierListOwner owner) {
+        return new ModifierFixBuilderImpl(owner);
     }
 
     @Nonnull
@@ -743,7 +790,7 @@ public void registerFixesForUnusedParameter(@Nonnull PsiParameter parameter, @No
         InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile();
         UnusedDeclarationInspectionBase unusedParametersInspection =
             (UnusedDeclarationInspectionBase)profile.getUnwrappedTool(UnusedSymbolLocalInspectionBase.SHORT_NAME, parameter);
-        LOG.assertTrue(Application.get().isUnitTestMode() || unusedParametersInspection != null);
+        LOG.assertTrue(parameter.getApplication().isUnitTestMode() || unusedParametersInspection != null);
         List<IntentionAction> options = new ArrayList<>();
         HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME);
         options.addAll(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter));
@@ -808,9 +855,8 @@ public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiE
     }
 
     @Nonnull
-    @Override
-    public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nls @Nonnull String text) {
-        return new DeleteElementFix(element, text);
+    public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nonnull LocalizeValue text) {
+        return new DeleteElementFix(element, text.get());
     }
 
     @Nonnull