From 6e973fdbe09d3473646bd830b2c42ab3e717cc3d Mon Sep 17 00:00:00 2001 From: Tagir Valeev Date: Fri, 28 Feb 2025 13:12:23 +0100 Subject: [PATCH] [java-highlighting] HighlightFixUtil: move sink to the first place for every method Part of IDEA-365344 Create a new Java error highlighter with minimal dependencies (PSI only) GitOrigin-RevId: de9726ed7bc805900c7206fc6496ceeadf50bb59 --- .../analysis/AdaptExpressionTypeFixUtil.java | 2 +- .../impl/analysis/HighlightFixUtil.java | 153 +++++++++--------- .../impl/analysis/JavaErrorFixProvider.java | 14 +- .../analysis/JavaErrorQuickFixProvider.java | 2 +- 4 files changed, 87 insertions(+), 84 deletions(-) diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AdaptExpressionTypeFixUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AdaptExpressionTypeFixUtil.java index e99e5ff5564a..294407014642 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AdaptExpressionTypeFixUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/AdaptExpressionTypeFixUtil.java @@ -233,7 +233,7 @@ final class AdaptExpressionTypeFixUtil { @Nullable PsiType expectedType, @Nullable PsiType actualType) { if (actualType == null || expectedType == null) return; - HighlightFixUtil.registerChangeVariableTypeFixes(expression, expectedType, info); + HighlightFixUtil.registerChangeVariableTypeFixes(info, expression, expectedType); if (!(expression.getParent() instanceof PsiConditionalExpression && PsiTypes.voidType().equals(expectedType))) { info.accept(HighlightFixUtil.createChangeReturnTypeFix(expression, expectedType)); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightFixUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightFixUtil.java index e1c713f5b372..e09bb2dea19f 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightFixUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightFixUtil.java @@ -144,13 +144,13 @@ public final class HighlightFixUtil { } } - static void registerChangeVariableTypeFixes(@NotNull PsiExpression expression, - @NotNull PsiType type, - @NotNull Consumer info) { + static void registerChangeVariableTypeFixes(@NotNull Consumer info, + @NotNull PsiExpression expression, + @NotNull PsiType type) { if (!(expression instanceof PsiReferenceExpression ref)) return; if (!(ref.resolve() instanceof PsiVariable variable)) return; - registerChangeVariableTypeFixes(variable, type, info); + registerChangeVariableTypeFixes(info, variable, type); } static void registerUnhandledExceptionFixes(@NotNull PsiElement element, @NotNull Consumer info) { @@ -162,7 +162,8 @@ public final class HighlightFixUtil { info.accept(quickFixFactory.createSurroundWithTryCatchFix(element)); } - static void registerStaticProblemQuickFixAction(@NotNull Consumer info, @NotNull PsiElement refElement, + static void registerStaticProblemQuickFixAction(@NotNull Consumer info, + @NotNull PsiElement refElement, @NotNull PsiJavaCodeReferenceElement place) { if (place instanceof PsiReferenceExpression && place.getParent() instanceof PsiMethodCallExpression) { ReplaceGetClassWithClassLiteralFix.registerFix((PsiMethodCallExpression)place.getParent(), info); @@ -193,9 +194,9 @@ public final class HighlightFixUtil { return qname == null || !Character.isLowerCase(qname.charAt(0)); } - static void registerChangeVariableTypeFixes(@NotNull PsiVariable parameter, - @Nullable PsiType itemType, - @NotNull Consumer info) { + static void registerChangeVariableTypeFixes(@NotNull Consumer info, + @NotNull PsiVariable parameter, + @Nullable PsiType itemType) { for (IntentionAction action : getChangeVariableTypeFixes(parameter, itemType)) { info.accept(action); } @@ -294,9 +295,9 @@ public final class HighlightFixUtil { } } - static void registerChangeParameterClassFix(@NotNull PsiType lType, - @Nullable PsiType rType, - @NotNull Consumer info) { + static void registerChangeParameterClassFix(@NotNull Consumer info, + @NotNull PsiType lType, + @Nullable PsiType rType) { if (rType == null) return; IntentionAction action = getChangeParameterClassFix(lType, rType); if (action != null) { @@ -304,9 +305,9 @@ public final class HighlightFixUtil { } } - private static PsiSwitchStatement findInitializingSwitch(@NotNull PsiVariable variable, - @NotNull PsiElement topBlock, - @NotNull PsiElement readPoint) { + private static @Nullable PsiSwitchStatement findInitializingSwitch(@NotNull PsiVariable variable, + @NotNull PsiElement topBlock, + @NotNull PsiElement readPoint) { PsiSwitchStatement switchForAll = null; for (PsiReferenceExpression reference : VariableAccessUtils.getVariableReferences(variable, topBlock)) { if (PsiUtil.isAccessedForWriting(reference)) { @@ -354,7 +355,8 @@ public final class HighlightFixUtil { return null; } - public static void registerFixesForExpressionStatement(@NotNull PsiElement statement, @NotNull Consumer info) { + public static void registerFixesForExpressionStatement(@NotNull Consumer info, + @NotNull PsiElement statement) { if (!(statement instanceof PsiExpressionStatement)) return; if (!(statement.getParent() instanceof PsiCodeBlock block)) return; PsiExpression expression = ((PsiExpressionStatement)statement).getExpression(); @@ -409,10 +411,10 @@ public final class HighlightFixUtil { }); } - static void registerQualifyMethodCallFix(CandidateInfo @NotNull [] methodCandidates, + static void registerQualifyMethodCallFix(@NotNull Consumer info, + CandidateInfo @NotNull [] methodCandidates, @NotNull PsiMethodCallExpression methodCall, - @NotNull PsiExpressionList exprList, - @NotNull Consumer info) { + @NotNull PsiExpressionList exprList) { if (methodCall.getMethodExpression().getQualifierExpression() != null) return; for (CandidateInfo methodCandidate : methodCandidates) { PsiMethod method = (PsiMethod)methodCandidate.getElement(); @@ -424,20 +426,20 @@ public final class HighlightFixUtil { } } - private static void registerStaticMethodQualifierFixes(@NotNull PsiMethodCallExpression methodCall, - @NotNull Consumer info) { + private static void registerStaticMethodQualifierFixes(@NotNull Consumer info, + @NotNull PsiMethodCallExpression methodCall) { info.accept(QuickFixFactory.getInstance().createStaticImportMethodFix(methodCall)); info.accept(QuickFixFactory.getInstance().createQualifyStaticMethodCallFix(methodCall)); info.accept(QuickFixFactory.getInstance().addMethodQualifierFix(methodCall)); } - private static void registerUsageFixes(@NotNull PsiMethodCallExpression methodCall, - @NotNull Consumer info) { + private static void registerUsageFixes(@NotNull Consumer info, + @NotNull PsiMethodCallExpression methodCall) { QuickFixFactory.getInstance().createCreateMethodFromUsageFixes(methodCall).forEach(info); } - private static void registerThisSuperFixes(@NotNull PsiMethodCallExpression methodCall, - @NotNull Consumer info) { + private static void registerThisSuperFixes(@NotNull Consumer info, + @NotNull PsiMethodCallExpression methodCall) { QuickFixFactory.getInstance().createCreateConstructorFromCallExpressionFixes(methodCall).forEach(info); } @@ -477,31 +479,31 @@ public final class HighlightFixUtil { MethodReturnFixFactory.INSTANCE.registerCastActions(methodCandidates, methodCall, info); WrapExpressionFix.registerWrapAction(methodCandidates, list.getExpressions(), info); QualifyThisArgumentFix.registerQuickFixAction(methodCandidates, methodCall, info); - registerMethodAccessLevelIntentions(methodCandidates, methodCall, list, info); + registerMethodAccessLevelIntentions(info, methodCandidates, methodCall, list); if (!PermuteArgumentsFix.registerFix(info, methodCall, methodCandidates) && !MoveParenthesisFix.registerFix(info, methodCall, methodCandidates)) { - registerChangeMethodSignatureFromUsageIntentions(methodCandidates, list, info); + registerChangeMethodSignatureFromUsageIntentions(info, methodCandidates, list); } QuickFixFactory.getInstance().getVariableTypeFromCallFixes(methodCall, list).forEach(info); if (methodCandidates.length == 0) { - registerStaticMethodQualifierFixes(methodCall, info); + registerStaticMethodQualifierFixes(info, methodCall); } - registerThisSuperFixes(methodCall, info); - registerUsageFixes(methodCall, info); + registerThisSuperFixes(info, methodCall); + registerUsageFixes(info, methodCall); RemoveRedundantArgumentsFix.registerIntentions(methodCandidates, list, info); info.accept(RemoveRepeatingCallFix.createFix(methodCall)); - registerChangeParameterClassFix(methodCall, list, info); + registerChangeParameterClassFix(info, methodCall, list); } - private static void registerMethodAccessLevelIntentions(CandidateInfo @NotNull [] methodCandidates, + private static void registerMethodAccessLevelIntentions(@NotNull Consumer info, + CandidateInfo @NotNull [] methodCandidates, @NotNull PsiMethodCallExpression methodCall, - @NotNull PsiExpressionList exprList, - @NotNull Consumer info) { + @NotNull PsiExpressionList exprList) { for (CandidateInfo methodCandidate : methodCandidates) { PsiMethod method = (PsiMethod)methodCandidate.getElement(); if (!methodCandidate.isAccessible() && PsiUtil.isApplicable(method, methodCandidate.getSubstitutor(), exprList)) { @@ -510,9 +512,9 @@ public final class HighlightFixUtil { } } - static void registerChangeParameterClassFix(@NotNull PsiCall methodCall, - @NotNull PsiExpressionList list, - @NotNull Consumer info) { + static void registerChangeParameterClassFix(@NotNull Consumer info, + @NotNull PsiCall methodCall, + @NotNull PsiExpressionList list) { JavaResolveResult result = methodCall.resolveMethodGenerics(); PsiMethod method = (PsiMethod)result.getElement(); PsiSubstitutor substitutor = result.getSubstitutor(); @@ -547,18 +549,18 @@ public final class HighlightFixUtil { } } - static void registerChangeMethodSignatureFromUsageIntentions(JavaResolveResult @NotNull [] candidates, - @NotNull PsiExpressionList list, - @NotNull Consumer info) { + static void registerChangeMethodSignatureFromUsageIntentions(@NotNull Consumer info, + JavaResolveResult @NotNull [] candidates, + @NotNull PsiExpressionList list) { if (candidates.length == 0) return; PsiExpression[] expressions = list.getExpressions(); for (JavaResolveResult candidate : candidates) { - registerChangeMethodSignatureFromUsageIntention(expressions, info, candidate, list); + registerChangeMethodSignatureFromUsageIntention(info, expressions, candidate, list); } } - private static void registerChangeMethodSignatureFromUsageIntention(PsiExpression @NotNull [] expressions, - @NotNull Consumer info, + private static void registerChangeMethodSignatureFromUsageIntention(@NotNull Consumer info, + PsiExpression @NotNull [] expressions, @NotNull JavaResolveResult candidate, @NotNull PsiElement context) { if (!candidate.isStaticsScopeCorrect()) return; @@ -616,17 +618,17 @@ public final class HighlightFixUtil { PsiExpressionList list = constructorCall.getArgumentList(); if (list == null) return; if (!PermuteArgumentsFix.registerFix(info, constructorCall, toMethodCandidates(results))) { - registerChangeMethodSignatureFromUsageIntentions(results, list, info); + registerChangeMethodSignatureFromUsageIntentions(info, results, list); } QuickFixFactory.getInstance().createCreateConstructorFromUsageFixes(constructorCall).forEach(info); - registerChangeParameterClassFix(constructorCall, list, info); + registerChangeParameterClassFix(info, constructorCall, list); RemoveRedundantArgumentsFix.registerIntentions(results, list, info); } - static void registerTargetTypeFixesBasedOnApplicabilityInference(@NotNull PsiMethodCallExpression methodCall, + static void registerTargetTypeFixesBasedOnApplicabilityInference(@NotNull Consumer info, + @NotNull PsiMethodCallExpression methodCall, @NotNull MethodCandidateInfo resolveResult, - @NotNull PsiMethod resolved, - @NotNull Consumer info) { + @NotNull PsiMethod resolved) { PsiElement parent = PsiUtil.skipParenthesizedExprUp(methodCall.getParent()); PsiVariable variable = null; if (parent instanceof PsiVariable) { @@ -648,13 +650,14 @@ public final class HighlightFixUtil { PsiType expectedTypeByApplicabilityConstraints = resolveResult.getSubstitutor(false).substitute(resolved.getReturnType()); if (expectedTypeByApplicabilityConstraints != null && !variable.getType().isAssignableFrom(expectedTypeByApplicabilityConstraints) && PsiTypesUtil.allTypeParametersResolved(variable, expectedTypeByApplicabilityConstraints)) { - registerChangeVariableTypeFixes(variable, expectedTypeByApplicabilityConstraints, info); + registerChangeVariableTypeFixes(info, variable, expectedTypeByApplicabilityConstraints); } } } } - static void registerCallInferenceFixes(@NotNull PsiMethodCallExpression callExpression, @NotNull Consumer info) { + static void registerCallInferenceFixes(@NotNull Consumer info, + @NotNull PsiMethodCallExpression callExpression) { JavaResolveResult result = callExpression.getMethodExpression().advancedResolve(true); if (!(result instanceof MethodCandidateInfo resolveResult)) return; PsiMethod method = resolveResult.getElement(); @@ -663,7 +666,7 @@ public final class HighlightFixUtil { if (!PsiTypesUtil.mentionsTypeParameters(actualType, Set.of(method.getTypeParameters()))) { registerMethodReturnFixAction(info, resolveResult, callExpression); } - registerTargetTypeFixesBasedOnApplicabilityInference(callExpression, resolveResult, method, info); + registerTargetTypeFixesBasedOnApplicabilityInference(info, callExpression, resolveResult, method); } static void registerImplementsExtendsFix(@NotNull Consumer info, @@ -719,7 +722,7 @@ public final class HighlightFixUtil { } PsiSubstitutor substitutor = factory.createSubstitutor(map); PsiType suggestedType = factory.createType(aClass, substitutor); - registerChangeVariableTypeFixes(variable, suggestedType, info); + registerChangeVariableTypeFixes(info, variable, suggestedType); } } } @@ -777,7 +780,7 @@ public final class HighlightFixUtil { WrapObjectWithOptionalOfNullableFix.REGISTAR.registerCastActions(candidates, methodCall, sink); WrapExpressionFix.registerWrapAction(candidates, list.getExpressions(), sink); PermuteArgumentsFix.registerFix(sink, methodCall, candidates); - registerChangeParameterClassFix(methodCall, list, sink); + registerChangeParameterClassFix(sink, methodCall, list); registerMethodCallIntentions(sink, methodCall, list); } @@ -803,7 +806,7 @@ public final class HighlightFixUtil { sink.accept(factory.createAssignmentToComparisonFix(assignment)); } else if (expression instanceof PsiMethodCallExpression callExpression) { - registerCallInferenceFixes(callExpression, sink); + registerCallInferenceFixes(sink, callExpression); } if (parent instanceof PsiArrayInitializerExpression initializerList) { PsiType sameType = JavaHighlightUtil.sameType(initializerList.getInitializers()); @@ -838,7 +841,7 @@ public final class HighlightFixUtil { } else if (parent instanceof PsiVariable var && PsiUtil.skipParenthesizedExprDown(var.getInitializer()) == expression && rType != null) { - registerChangeVariableTypeFixes(var, rType, sink); + registerChangeVariableTypeFixes(sink, var, rType); } else if (parent instanceof PsiAssignmentExpression assignment && PsiUtil.skipParenthesizedExprDown(assignment.getRExpression()) == expression) { @@ -846,7 +849,7 @@ public final class HighlightFixUtil { sink.accept(factory.createChangeToAppendFix(assignment.getOperationTokenType(), lType, assignment)); if (rType != null) { - registerChangeVariableTypeFixes(lExpr, rType, sink); + registerChangeVariableTypeFixes(sink, lExpr, rType); if (expression instanceof PsiMethodCallExpression call && assignment.getParent() instanceof PsiStatement && PsiTypes.voidType().equals(rType)) { sink.accept(new ReplaceAssignmentFromVoidWithStatementIntentionAction(assignment, call)); @@ -855,7 +858,7 @@ public final class HighlightFixUtil { } } if (anchor instanceof PsiParameter parameter && parent instanceof PsiForeachStatement forEach) { - registerChangeVariableTypeFixes(parameter, lType, sink); + registerChangeVariableTypeFixes(sink, parameter, lType); PsiExpression iteratedValue = forEach.getIteratedValue(); if (iteratedValue != null && rType != null) { PsiType type = iteratedValue.getType(); @@ -864,7 +867,7 @@ public final class HighlightFixUtil { } } } - registerChangeParameterClassFix(lType, rType, sink); + registerChangeParameterClassFix(sink, lType, rType); } private static @NotNull LanguageLevel getApplicableLevel(@NotNull PsiFile file, @NotNull JavaFeature feature) { @@ -897,8 +900,8 @@ public final class HighlightFixUtil { factory.createShowModulePropertiesFix(element)); } - static void registerFixesOnInvalidSelector(@NotNull PsiExpression selector, - @NotNull Consumer sink) { + static void registerFixesOnInvalidSelector(@NotNull Consumer sink, + @NotNull PsiExpression selector) { QuickFixFactory factory = QuickFixFactory.getInstance(); if (selector.getParent() instanceof PsiSwitchStatement switchStatement) { sink.accept(factory.createConvertSwitchToIfIntention(switchStatement)); @@ -1009,12 +1012,12 @@ public final class HighlightFixUtil { } /** - * Registers actions to fix switch block completeness (exhaustiveness) - * + * Registers actions to fix switch block completeness (exhaustiveness) + * + * @param info sink * @param block switch block which is not exhaustive - * @param info sink */ - static void addCompletenessFixes(@NotNull PsiSwitchBlock block, @NotNull Consumer info) { + static void addCompletenessFixes(@NotNull Consumer info, @NotNull PsiSwitchBlock block) { List elements = JavaPsiSwitchUtil.getCaseLabelElements(block); PsiExpression selector = block.getExpression(); if (selector == null) return; @@ -1028,18 +1031,18 @@ public final class HighlightFixUtil { .map(PsiReferenceExpression::resolve) .select(PsiEnumConstant.class) .toSet(); - addEnumCompletenessFixes(block, selectorClass, enumElements, info); + addEnumCompletenessFixes(info, block, selectorClass, enumElements); return; } List sealedTypes = getAbstractSealedTypes(JavaPsiPatternUtil.deconstructSelectorType(selectorType)); if (!sealedTypes.isEmpty()) { - addSealedClassCompletenessFixes(block, selectorType, elements, info); + addSealedClassCompletenessFixes(info, block, selectorType, elements); return; } //records are final; checking intersections are not needed if (selectorClass != null && selectorClass.isRecord()) { if (checkRecordCaseSetNotEmpty(elements)) { - addRecordExhaustivenessFixes(block, elements, selectorType, selectorClass, info); + addRecordExhaustivenessFixes(info, block, elements, selectorType, selectorClass); } } else { @@ -1057,10 +1060,10 @@ public final class HighlightFixUtil { } } - private static void addEnumCompletenessFixes(@NotNull PsiSwitchBlock block, + private static void addEnumCompletenessFixes(@NotNull Consumer info, + @NotNull PsiSwitchBlock block, @NotNull PsiClass selectorClass, - @NotNull Set enumElements, - @NotNull Consumer info) { + @NotNull Set enumElements) { LinkedHashSet missingConstants = StreamEx.of(selectorClass.getFields()).select(PsiEnumConstant.class).remove(enumElements::contains) .map(PsiField::getName) @@ -1080,11 +1083,11 @@ public final class HighlightFixUtil { .toList(); } - private static void addRecordExhaustivenessFixes(@NotNull PsiSwitchBlock block, + private static void addRecordExhaustivenessFixes(@NotNull Consumer info, + @NotNull PsiSwitchBlock block, @NotNull List elements, @NotNull PsiType selectorClassType, - @NotNull PsiClass selectorClass, - @NotNull Consumer info) { + @NotNull PsiClass selectorClass) { JavaPatternExhaustivenessUtil.RecordExhaustivenessResult exhaustivenessResult = checkRecordExhaustiveness(elements, selectorClassType, block); @@ -1124,9 +1127,9 @@ public final class HighlightFixUtil { return missedClasses; } - private static void addSealedClassCompletenessFixes(@NotNull PsiSwitchBlock block, @NotNull PsiType selectorType, - @NotNull List elements, - @NotNull Consumer info) { + private static void addSealedClassCompletenessFixes(@NotNull Consumer info, + @NotNull PsiSwitchBlock block, @NotNull PsiType selectorType, + @NotNull List elements) { Set missedClasses = getMissedClassesInSealedHierarchy(selectorType, elements, block); List allNames = collectLabelElementNames(elements, missedClasses); Set missingCases = ContainerUtil.map2LinkedSet(missedClasses, PsiClass::getQualifiedName); diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorFixProvider.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorFixProvider.java index 120a897b2200..768565754898 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorFixProvider.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorFixProvider.java @@ -251,7 +251,7 @@ final class JavaErrorFixProvider { myFactory.createMethodReturnFix(method, PsiTypes.voidType(), true) : null); fixes(STATEMENT_BAD_EXPRESSION, (error, sink) -> { if (error.psi() instanceof PsiExpressionStatement expressionStatement) { - HighlightFixUtil.registerFixesForExpressionStatement(expressionStatement, sink); + HighlightFixUtil.registerFixesForExpressionStatement(sink, expressionStatement); PsiElement parent = expressionStatement.getParent(); if (parent instanceof PsiCodeBlock || parent instanceof PsiIfStatement || @@ -269,7 +269,7 @@ final class JavaErrorFixProvider { return previousRule == null ? null : myFactory.createWrapSwitchRuleStatementsIntoBlockFix(previousRule); }); fixes(SWITCH_SELECTOR_TYPE_INVALID, (error, sink) -> { - HighlightFixUtil.registerFixesOnInvalidSelector(error.psi(), sink); + HighlightFixUtil.registerFixesOnInvalidSelector(sink, error.psi()); JavaFeature feature = error.context().getFeature(); if (feature != null) { HighlightFixUtil.getIncreaseLanguageLevelFixes(error.psi(), feature).forEach(sink); @@ -767,7 +767,7 @@ final class JavaErrorFixProvider { fix(SWITCH_DEFAULT_AND_BOOLEAN, error -> myFactory.createDeleteDefaultFix(null, error.psi())); JavaFixesPusher switchFixes = (error, sink) -> { sink.accept(myFactory.createAddSwitchDefaultFix(error.psi(), null)); - HighlightFixUtil.addCompletenessFixes(error.psi(), sink); + HighlightFixUtil.addCompletenessFixes(sink, error.psi()); }; fixes(SWITCH_EMPTY, switchFixes); fixes(SWITCH_INCOMPLETE, switchFixes); @@ -798,7 +798,7 @@ final class JavaErrorFixProvider { error.context().lType(), error.context().rType())); fixes(CALL_TYPE_INFERENCE_ERROR, (error, sink) -> { if (error.psi() instanceof PsiMethodCallExpression callExpression) { - HighlightFixUtil.registerCallInferenceFixes(callExpression, sink); + HighlightFixUtil.registerCallInferenceFixes(sink, callExpression); } }); fixes(LAMBDA_INFERENCE_ERROR, (error, sink) -> { @@ -810,7 +810,7 @@ final class JavaErrorFixProvider { if (!PsiTypesUtil.mentionsTypeParameters(((PsiExpression)callExpression.copy()).getType(), Set.of(method.getTypeParameters()))) { HighlightFixUtil.registerMethodReturnFixAction(sink, resolveResult, callExpression); } - HighlightFixUtil.registerTargetTypeFixesBasedOnApplicabilityInference(callExpression, resolveResult, method, sink); + HighlightFixUtil.registerTargetTypeFixesBasedOnApplicabilityInference(sink, callExpression, resolveResult, method); LambdaUtil.getReturnExpressions(error.psi()) .stream().map(PsiExpression::getType).distinct() .map(type -> AdjustFunctionContextFix.createFix(type, error.psi())) @@ -843,10 +843,10 @@ final class JavaErrorFixProvider { AdaptExpressionTypeFixUtil.registerExpectedTypeFixes(sink, methodCall, expectedTypeByParent, actualType); } HighlightFixUtil.registerQualifyMethodCallFix( - resolveHelper.getReferencedMethodCandidates(methodCall, false), methodCall, list, sink); + sink, resolveHelper.getReferencedMethodCandidates(methodCall, false), methodCall, list); HighlightFixUtil.registerMethodCallIntentions(sink, methodCall, list); HighlightFixUtil.registerMethodReturnFixAction(sink, candidate, methodCall); - HighlightFixUtil.registerTargetTypeFixesBasedOnApplicabilityInference(methodCall, candidate, candidate.getElement(), sink); + HighlightFixUtil.registerTargetTypeFixesBasedOnApplicabilityInference(sink, methodCall, candidate, candidate.getElement()); HighlightFixUtil.registerImplementsExtendsFix(sink, methodCall, candidate.getElement()); } if (parent instanceof PsiConstructorCall constructorCall) { diff --git a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorQuickFixProvider.java b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorQuickFixProvider.java index 133d02048b6f..22e78db5529d 100644 --- a/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorQuickFixProvider.java +++ b/java/java-impl/src/com/intellij/codeInsight/daemon/impl/analysis/JavaErrorQuickFixProvider.java @@ -27,7 +27,7 @@ public final class JavaErrorQuickFixProvider implements ErrorQuickFixProvider, D List registrar = new ArrayList<>(); if (description.equals(JavaPsiBundle.message("expected.semicolon"))) { info.registerFix(new InsertMissingTokenFix(";"), null, null, null, null); - HighlightFixUtil.registerFixesForExpressionStatement(parent, action -> registrar.add(action.asIntention())); + HighlightFixUtil.registerFixesForExpressionStatement(action -> registrar.add(action.asIntention()), parent); } if (parent instanceof PsiTryStatement && description.equals(JavaPsiBundle.message("expected.catch.or.finally"))) { registrar.add(new AddExceptionToCatchFix(false).asIntention());