From f824d17205aec72fbcff1bbb5e2f0e95975a2099 Mon Sep 17 00:00:00 2001 From: UNV Date: Sun, 4 May 2025 15:34:44 +0300 Subject: [PATCH 1/3] Reformatting ModifierFix, RefCountHolder, QuickFixFactory and QuickFixFactoryImpl. --- .../intention/QuickFixFactory.java | 654 +++--- .../daemon/impl/analysis/RefCountHolder.java | 586 +++--- .../daemon/impl/quickfix/ModifierFix.java | 339 ++-- .../impl/config/QuickFixFactoryImpl.java | 1801 +++++++++-------- 4 files changed, 1784 insertions(+), 1596 deletions(-) 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 ef55fc8d1a..f6e3a04cf9 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 @@ -36,6 +36,7 @@ import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Collection; import java.util.List; import java.util.Set; @@ -45,373 +46,464 @@ */ @ServiceAPI(ComponentScope.APPLICATION) public abstract class QuickFixFactory { - public static QuickFixFactory getInstance() { - return ServiceManager.getService(QuickFixFactory.class); - } - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@Nonnull PsiModifierList modifierList, - @PsiModifier.ModifierConstant @Nonnull String modifier, - boolean shouldHave, - final boolean showContainingClass); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@Nonnull PsiModifierListOwner owner, - @PsiModifier.ModifierConstant @Nonnull String modifier, - boolean shouldHave, - final boolean showContainingClass); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix(@Nonnull PsiMethod method, @Nonnull PsiType toReturn, boolean fixWholeHierarchy); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull PsiMethod method, @Nonnull PsiClass toClass); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull String methodText, @Nonnull PsiClass toClass, @Nonnull String... exceptions); - - /** - * @param psiElement psiClass or enum constant without class initializer - */ - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiElement psiElement); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAssignmentToComparisonFix(PsiAssignmentExpression expr); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiClass psiElement); - - @Nonnull - public abstract LocalQuickFixOnPsiElement createMethodThrowsFix(@Nonnull PsiMethod method, @Nonnull PsiClassType exceptionClass, boolean shouldThrow, boolean showContainingClass); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFix(@Nonnull PsiClass aClass); - - @Nullable - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix(@Nonnull PsiClass aClass, @PsiModifier.ModifierConstant @Nonnull String modifier); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodParameterTypeFix(@Nonnull PsiMethod method, int index, @Nonnull PsiType newType, boolean fixWholeHierarchy); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass, final boolean makeInterface); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createExtendsListFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType typeToExtendFrom, boolean toAdd); - - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createRemoveUnusedParameterFix(@Nonnull PsiParameter parameter); - - @Nonnull - public abstract IntentionAction createRemoveUnusedVariableFix(@Nonnull PsiVariable variable); - - @Nullable - public abstract IntentionAction createCreateClassOrPackageFix(@Nonnull PsiElement context, @Nonnull String qualifiedName, final boolean createClass, final String superClass); - - @Nullable - public abstract IntentionAction createCreateClassOrInterfaceFix(@Nonnull PsiElement context, @Nonnull String qualifiedName, final boolean createClass, final String superClass); - - @Nonnull - public abstract IntentionAction createCreateFieldOrPropertyFix(@Nonnull PsiClass aClass, - @Nonnull String name, - @Nonnull PsiType type, - @Nonnull PropertyMemberType targetMember, - @Nonnull PsiAnnotation... annotations); - - @Nonnull - public abstract IntentionAction createSetupJDKFix(); - - @Nonnull - public abstract IntentionAction createAddExceptionToCatchFix(); - - @Nonnull - public abstract IntentionAction createAddExceptionToThrowsFix(@Nonnull PsiElement element); - - @Nonnull - public abstract IntentionAction createAddExceptionFromFieldInitializerToConstructorThrowsFix(@Nonnull PsiElement element); - - @Nonnull - public abstract IntentionAction createSurroundWithTryCatchFix(@Nonnull PsiElement element); - - @Nonnull - public abstract IntentionAction createGeneralizeCatchFix(@Nonnull PsiElement element, @Nonnull PsiClassType type); - - @Nonnull - public abstract IntentionAction createChangeToAppendFix(@Nonnull IElementType sign, @Nonnull PsiType type, @Nonnull PsiAssignmentExpression assignment); + public static QuickFixFactory getInstance() { + return ServiceManager.getService(QuickFixFactory.class); + } + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( + @Nonnull PsiModifierList modifierList, + @PsiModifier.ModifierConstant @Nonnull String modifier, + boolean shouldHave, + final boolean showContainingClass + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( + @Nonnull PsiModifierListOwner owner, + @PsiModifier.ModifierConstant @Nonnull String modifier, + boolean shouldHave, + final boolean showContainingClass + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix( + @Nonnull PsiMethod method, + @Nonnull PsiType toReturn, + boolean fixWholeHierarchy + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull PsiMethod method, @Nonnull PsiClass toClass); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix( + @Nonnull String methodText, + @Nonnull PsiClass toClass, + @Nonnull String... exceptions + ); + + /** + * @param psiElement psiClass or enum constant without class initializer + */ + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiElement psiElement); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAssignmentToComparisonFix(PsiAssignmentExpression expr); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiClass psiElement); + + @Nonnull + public abstract LocalQuickFixOnPsiElement createMethodThrowsFix( + @Nonnull PsiMethod method, + @Nonnull PsiClassType exceptionClass, + boolean shouldThrow, + boolean showContainingClass + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFix(@Nonnull PsiClass aClass); + + @Nullable + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix( + @Nonnull PsiClass aClass, + @PsiModifier.ModifierConstant @Nonnull String modifier + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodParameterTypeFix( + @Nonnull PsiMethod method, + int index, + @Nonnull PsiType newType, + boolean fixWholeHierarchy + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix( + @Nonnull PsiClass aClass, + final boolean makeInterface + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createExtendsListFix( + @Nonnull PsiClass aClass, + @Nonnull PsiClassType typeToExtendFrom, + boolean toAdd + ); + + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createRemoveUnusedParameterFix(@Nonnull PsiParameter parameter); + + @Nonnull + public abstract IntentionAction createRemoveUnusedVariableFix(@Nonnull PsiVariable variable); + + @Nullable + public abstract IntentionAction createCreateClassOrPackageFix( + @Nonnull PsiElement context, + @Nonnull String qualifiedName, + final boolean createClass, + final String superClass + ); + + @Nullable + public abstract IntentionAction createCreateClassOrInterfaceFix( + @Nonnull PsiElement context, + @Nonnull String qualifiedName, + final boolean createClass, + final String superClass + ); + + @Nonnull + public abstract IntentionAction createCreateFieldOrPropertyFix( + @Nonnull PsiClass aClass, + @Nonnull String name, + @Nonnull PsiType type, + @Nonnull PropertyMemberType targetMember, + @Nonnull PsiAnnotation... annotations + ); + + @Nonnull + public abstract IntentionAction createSetupJDKFix(); + + @Nonnull + public abstract IntentionAction createAddExceptionToCatchFix(); + + @Nonnull + public abstract IntentionAction createAddExceptionToThrowsFix(@Nonnull PsiElement element); + + @Nonnull + public abstract IntentionAction createAddExceptionFromFieldInitializerToConstructorThrowsFix(@Nonnull PsiElement element); + + @Nonnull + public abstract IntentionAction createSurroundWithTryCatchFix(@Nonnull PsiElement element); + + @Nonnull + public abstract IntentionAction createGeneralizeCatchFix(@Nonnull PsiElement element, @Nonnull PsiClassType type); + + @Nonnull + public abstract IntentionAction createChangeToAppendFix( + @Nonnull IElementType sign, + @Nonnull PsiType type, + @Nonnull PsiAssignmentExpression assignment + ); - @Nonnull - public abstract IntentionAction createAddTypeCastFix(@Nonnull PsiType type, @Nonnull PsiExpression expression); + @Nonnull + public abstract IntentionAction createAddTypeCastFix(@Nonnull PsiType type, @Nonnull PsiExpression expression); - @Nonnull - public abstract IntentionAction createWrapExpressionFix(@Nonnull PsiType type, @Nonnull PsiExpression expression); + @Nonnull + public abstract IntentionAction createWrapExpressionFix(@Nonnull PsiType type, @Nonnull PsiExpression expression); - @Nonnull - public abstract IntentionAction createReuseVariableDeclarationFix(@Nonnull PsiLocalVariable variable); + @Nonnull + public abstract IntentionAction createReuseVariableDeclarationFix(@Nonnull PsiLocalVariable variable); - @Nonnull - public abstract IntentionAction createConvertToStringLiteralAction(); + @Nonnull + public abstract IntentionAction createConvertToStringLiteralAction(); - @Nonnull - public abstract IntentionAction createDeleteCatchFix(@Nonnull PsiParameter parameter); + @Nonnull + public abstract IntentionAction createDeleteCatchFix(@Nonnull PsiParameter parameter); - @Nonnull - public abstract IntentionAction createDeleteMultiCatchFix(@Nonnull PsiTypeElement element); + @Nonnull + public abstract IntentionAction createDeleteMultiCatchFix(@Nonnull PsiTypeElement element); - @Nonnull - public abstract IntentionAction createConvertSwitchToIfIntention(@Nonnull PsiSwitchStatement statement); + @Nonnull + public abstract IntentionAction createConvertSwitchToIfIntention(@Nonnull PsiSwitchStatement statement); - @Nonnull - public abstract IntentionAction createNegationBroadScopeFix(@Nonnull PsiPrefixExpression expr); + @Nonnull + public abstract IntentionAction createNegationBroadScopeFix(@Nonnull PsiPrefixExpression expr); - @Nonnull - public abstract IntentionAction createCreateFieldFromUsageFix(@Nonnull PsiReferenceExpression place); + @Nonnull + public abstract IntentionAction createCreateFieldFromUsageFix(@Nonnull PsiReferenceExpression place); - @Nonnull - public abstract IntentionAction createReplaceWithListAccessFix(@Nonnull PsiArrayAccessExpression expression); + @Nonnull + public abstract IntentionAction createReplaceWithListAccessFix(@Nonnull PsiArrayAccessExpression expression); - @Nonnull - public abstract IntentionAction createAddNewArrayExpressionFix(@Nonnull PsiArrayInitializerExpression expression); + @Nonnull + public abstract IntentionAction createAddNewArrayExpressionFix(@Nonnull PsiArrayInitializerExpression expression); - @Nonnull - public abstract IntentionAction createMoveCatchUpFix(@Nonnull PsiCatchSection section, @Nonnull PsiCatchSection section1); + @Nonnull + public abstract IntentionAction createMoveCatchUpFix(@Nonnull PsiCatchSection section, @Nonnull PsiCatchSection section1); - @Nonnull - public abstract IntentionAction createRenameWrongRefFix(@Nonnull PsiReferenceExpression ref); + @Nonnull + public abstract IntentionAction createRenameWrongRefFix(@Nonnull PsiReferenceExpression ref); - @Nonnull - public abstract IntentionAction createRemoveQualifierFix(@Nonnull PsiExpression qualifier, @Nonnull PsiReferenceExpression expression, @Nonnull PsiClass resolved); + @Nonnull + public abstract IntentionAction createRemoveQualifierFix( + @Nonnull PsiExpression qualifier, + @Nonnull PsiReferenceExpression expression, + @Nonnull PsiClass resolved + ); - @Nonnull - public abstract IntentionAction createRemoveParameterListFix(@Nonnull PsiMethod parent); + @Nonnull + public abstract IntentionAction createRemoveParameterListFix(@Nonnull PsiMethod parent); - @Nonnull - public abstract IntentionAction createShowModulePropertiesFix(@Nonnull PsiElement element); + @Nonnull + public abstract IntentionAction createShowModulePropertiesFix(@Nonnull PsiElement element); - @Nonnull - public abstract IntentionAction createShowModulePropertiesFix(@Nonnull Module module); + @Nonnull + public abstract IntentionAction createShowModulePropertiesFix(@Nonnull Module module); - @Nonnull - public abstract IntentionAction createIncreaseLanguageLevelFix(@Nonnull LanguageLevel level); + @Nonnull + public abstract IntentionAction createIncreaseLanguageLevelFix(@Nonnull LanguageLevel level); - @Nonnull - public abstract IntentionAction createChangeParameterClassFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type); + @Nonnull + public abstract IntentionAction createChangeParameterClassFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type); - @Nonnull - public abstract IntentionAction createReplaceInaccessibleFieldWithGetterSetterFix(@Nonnull PsiElement element, @Nonnull PsiMethod getter, boolean isSetter); + @Nonnull + public abstract IntentionAction createReplaceInaccessibleFieldWithGetterSetterFix( + @Nonnull PsiElement element, + @Nonnull PsiMethod getter, + boolean isSetter + ); - @Nonnull - public abstract IntentionAction createSurroundWithArrayFix(@Nullable PsiCall methodCall, @Nullable PsiExpression expression); + @Nonnull + public abstract IntentionAction createSurroundWithArrayFix(@Nullable PsiCall methodCall, @Nullable PsiExpression expression); - @Nonnull - public abstract IntentionAction createImplementAbstractClassMethodsFix(@Nonnull PsiElement elementToHighlight); + @Nonnull + public abstract IntentionAction createImplementAbstractClassMethodsFix(@Nonnull PsiElement elementToHighlight); - @Nonnull - public abstract IntentionAction createMoveClassToSeparateFileFix(@Nonnull PsiClass aClass); + @Nonnull + public abstract IntentionAction createMoveClassToSeparateFileFix(@Nonnull PsiClass aClass); - @Nonnull - public abstract IntentionAction createRenameFileFix(@Nonnull String newName); + @Nonnull + public abstract IntentionAction createRenameFileFix(@Nonnull String newName); - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element); + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element); - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element, @Nonnull String newName); + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix( + @Nonnull PsiNamedElement element, + @Nonnull String newName + ); - @Nonnull - public abstract IntentionAction createChangeExtendsToImplementsFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType classToExtendFrom); + @Nonnull + public abstract IntentionAction createChangeExtendsToImplementsFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType classToExtendFrom); - @Nonnull - public abstract IntentionAction createCreateConstructorMatchingSuperFix(@Nonnull PsiClass aClass); + @Nonnull + public abstract IntentionAction createCreateConstructorMatchingSuperFix(@Nonnull PsiClass aClass); - @Nonnull - public abstract IntentionAction createRemoveNewQualifierFix(@Nonnull PsiNewExpression expression, @Nullable PsiClass aClass); + @Nonnull + public abstract IntentionAction createRemoveNewQualifierFix(@Nonnull PsiNewExpression expression, @Nullable PsiClass aClass); - @Nonnull - public abstract IntentionAction createSuperMethodReturnFix(@Nonnull PsiMethod superMethod, @Nonnull PsiType superMethodType); + @Nonnull + public abstract IntentionAction createSuperMethodReturnFix(@Nonnull PsiMethod superMethod, @Nonnull PsiType superMethodType); - @Nonnull - public abstract IntentionAction createInsertNewFix(@Nonnull PsiMethodCallExpression call, @Nonnull PsiClass aClass); + @Nonnull + public abstract IntentionAction createInsertNewFix(@Nonnull PsiMethodCallExpression call, @Nonnull PsiClass aClass); - @Nonnull - public abstract IntentionAction createAddMethodBodyFix(@Nonnull PsiMethod method); + @Nonnull + public abstract IntentionAction createAddMethodBodyFix(@Nonnull PsiMethod method); - @Nonnull - public abstract IntentionAction createDeleteMethodBodyFix(@Nonnull PsiMethod method); + @Nonnull + public abstract IntentionAction createDeleteMethodBodyFix(@Nonnull PsiMethod method); - @Nonnull - public abstract IntentionAction createInsertSuperFix(@Nonnull PsiMethod constructor); + @Nonnull + public abstract IntentionAction createInsertSuperFix(@Nonnull PsiMethod constructor); - @Nonnull - public abstract IntentionAction createInsertThisFix(@Nonnull PsiMethod constructor); + @Nonnull + public abstract IntentionAction createInsertThisFix(@Nonnull PsiMethod constructor); - @Nonnull - public abstract IntentionAction createChangeMethodSignatureFromUsageFix(@Nonnull PsiMethod targetMethod, - @Nonnull PsiExpression[] expressions, - @Nonnull PsiSubstitutor substitutor, - @Nonnull PsiElement context, - boolean changeAllUsages, - int minUsagesNumberToShowDialog); + @Nonnull + public abstract IntentionAction createChangeMethodSignatureFromUsageFix( + @Nonnull PsiMethod targetMethod, + @Nonnull PsiExpression[] expressions, + @Nonnull PsiSubstitutor substitutor, + @Nonnull PsiElement context, + boolean changeAllUsages, + int minUsagesNumberToShowDialog + ); - @Nonnull - public abstract IntentionAction createChangeMethodSignatureFromUsageReverseOrderFix(@Nonnull PsiMethod targetMethod, - @Nonnull PsiExpression[] expressions, - @Nonnull PsiSubstitutor substitutor, - @Nonnull PsiElement context, - boolean changeAllUsages, - int minUsagesNumberToShowDialog); + @Nonnull + public abstract IntentionAction createChangeMethodSignatureFromUsageReverseOrderFix( + @Nonnull PsiMethod targetMethod, + @Nonnull PsiExpression[] expressions, + @Nonnull PsiSubstitutor substitutor, + @Nonnull PsiElement context, + boolean changeAllUsages, + int minUsagesNumberToShowDialog + ); - @Nonnull - public abstract IntentionAction createCreateMethodFromUsageFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreateMethodFromUsageFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreateMethodFromUsageFix(PsiMethodReferenceExpression methodReferenceExpression); + @Nonnull + public abstract IntentionAction createCreateMethodFromUsageFix(PsiMethodReferenceExpression methodReferenceExpression); - @Nonnull - public abstract IntentionAction createCreateAbstractMethodFromUsageFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreateAbstractMethodFromUsageFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreatePropertyFromUsageFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreatePropertyFromUsageFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreateConstructorFromSuperFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreateConstructorFromSuperFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreateConstructorFromThisFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreateConstructorFromThisFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreateGetterSetterPropertyFromUsageFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createCreateGetterSetterPropertyFromUsageFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createStaticImportMethodFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createStaticImportMethodFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createReplaceAddAllArrayToCollectionFix(@Nonnull PsiMethodCallExpression call); + @Nonnull + public abstract IntentionAction createReplaceAddAllArrayToCollectionFix(@Nonnull PsiMethodCallExpression call); - @Nonnull - public abstract IntentionAction createCreateConstructorFromCallFix(@Nonnull PsiConstructorCall call); + @Nonnull + public abstract IntentionAction createCreateConstructorFromCallFix(@Nonnull PsiConstructorCall call); - @Nonnull - public abstract List getVariableTypeFromCallFixes(@Nonnull PsiMethodCallExpression call, @Nonnull PsiExpressionList list); + @Nonnull + public abstract List getVariableTypeFromCallFixes( + @Nonnull PsiMethodCallExpression call, + @Nonnull PsiExpressionList list + ); - @Nonnull - public abstract IntentionAction createAddReturnFix(@Nonnull PsiMethod method); + @Nonnull + public abstract IntentionAction createAddReturnFix(@Nonnull PsiMethod method); - @Nonnull - public abstract IntentionAction createAddVariableInitializerFix(@Nonnull PsiVariable variable); + @Nonnull + public abstract IntentionAction createAddVariableInitializerFix(@Nonnull PsiVariable variable); - @Nonnull - public abstract IntentionAction createDeferFinalAssignmentFix(@Nonnull PsiVariable variable, @Nonnull PsiReferenceExpression expression); + @Nonnull + public abstract IntentionAction createDeferFinalAssignmentFix( + @Nonnull PsiVariable variable, + @Nonnull PsiReferenceExpression expression + ); - @Nonnull - public abstract IntentionAction createVariableAccessFromInnerClassFix(@Nonnull PsiVariable variable, @Nonnull PsiElement scope); + @Nonnull + public abstract IntentionAction createVariableAccessFromInnerClassFix(@Nonnull PsiVariable variable, @Nonnull PsiElement scope); - @Nonnull - public abstract IntentionAction createCreateConstructorParameterFromFieldFix(@Nonnull PsiField field); + @Nonnull + public abstract IntentionAction createCreateConstructorParameterFromFieldFix(@Nonnull PsiField field); - @Nonnull - public abstract IntentionAction createInitializeFinalFieldInConstructorFix(@Nonnull PsiField field); + @Nonnull + public abstract IntentionAction createInitializeFinalFieldInConstructorFix(@Nonnull PsiField field); - @Nonnull - public abstract IntentionAction createRemoveTypeArgumentsFix(@Nonnull PsiElement variable); + @Nonnull + public abstract IntentionAction createRemoveTypeArgumentsFix(@Nonnull PsiElement variable); - @Nonnull - public abstract IntentionAction createChangeClassSignatureFromUsageFix(@Nonnull PsiClass owner, @Nonnull PsiReferenceParameterList parameterList); + @Nonnull + public abstract IntentionAction createChangeClassSignatureFromUsageFix( + @Nonnull PsiClass owner, + @Nonnull PsiReferenceParameterList parameterList + ); - @Nonnull - public abstract IntentionAction createReplacePrimitiveWithBoxedTypeAction(@Nonnull PsiTypeElement element, @Nonnull String typeName, @Nonnull String boxedTypeName); + @Nonnull + public abstract IntentionAction createReplacePrimitiveWithBoxedTypeAction( + @Nonnull PsiTypeElement element, + @Nonnull String typeName, + @Nonnull String boxedTypeName + ); - @Nonnull - public abstract IntentionAction createMakeVarargParameterLastFix(@Nonnull PsiParameter parameter); + @Nonnull + public abstract IntentionAction createMakeVarargParameterLastFix(@Nonnull PsiParameter parameter); - @Nonnull - public abstract IntentionAction createMoveBoundClassToFrontFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type); + @Nonnull + public abstract IntentionAction createMoveBoundClassToFrontFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type); - public abstract void registerPullAsAbstractUpFixes(@Nonnull PsiMethod method, @Nonnull QuickFixActionRegistrar registrar); + public abstract void registerPullAsAbstractUpFixes(@Nonnull PsiMethod method, @Nonnull QuickFixActionRegistrar registrar); - @Nonnull - public abstract IntentionAction createCreateAnnotationMethodFromUsageFix(@Nonnull PsiNameValuePair pair); + @Nonnull + public abstract IntentionAction createCreateAnnotationMethodFromUsageFix(@Nonnull PsiNameValuePair pair); - @Nonnull - public abstract IntentionAction createOptimizeImportsFix(boolean onTheFly); + @Nonnull + public abstract IntentionAction createOptimizeImportsFix(boolean onTheFly); - public abstract void registerFixesForUnusedParameter(@Nonnull PsiParameter parameter, @Nonnull Object highlightInfo); + public abstract void registerFixesForUnusedParameter(@Nonnull PsiParameter parameter, @Nonnull Object highlightInfo); - @Nonnull - public abstract IntentionAction createAddToDependencyInjectionAnnotationsFix(@Nonnull Project project, @Nonnull String qualifiedName, @Nonnull String element); + @Nonnull + public abstract IntentionAction createAddToDependencyInjectionAnnotationsFix( + @Nonnull Project project, + @Nonnull String qualifiedName, + @Nonnull String element + ); - @Nonnull - public abstract IntentionAction createAddToImplicitlyWrittenFieldsFix(Project project, @Nonnull String qualifiedName); + @Nonnull + public abstract IntentionAction createAddToImplicitlyWrittenFieldsFix(Project project, @Nonnull String qualifiedName); - @Nonnull - public abstract IntentionAction createCreateGetterOrSetterFix(boolean createGetter, boolean createSetter, @Nonnull PsiField field); + @Nonnull + public abstract IntentionAction createCreateGetterOrSetterFix(boolean createGetter, boolean createSetter, @Nonnull PsiField field); - @Nonnull - public abstract IntentionAction createRenameToIgnoredFix(@Nonnull PsiNamedElement namedElement); + @Nonnull + public abstract IntentionAction createRenameToIgnoredFix(@Nonnull PsiNamedElement namedElement); - @Nonnull - public abstract IntentionAction createEnableOptimizeImportsOnTheFlyFix(); + @Nonnull + public abstract IntentionAction createEnableOptimizeImportsOnTheFlyFix(); - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element); + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element); - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nonnull @Nls String text); + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nonnull @Nls String text); - @Nonnull - public abstract IntentionAction createDeleteSideEffectAwareFix(@Nonnull PsiExpressionStatement statement); + @Nonnull + public abstract IntentionAction createDeleteSideEffectAwareFix(@Nonnull PsiExpressionStatement statement); - @Nonnull - public abstract IntentionAction createSafeDeleteFix(@Nonnull PsiElement element); + @Nonnull + public abstract IntentionAction createSafeDeleteFix(@Nonnull PsiElement element); - @Nullable - public abstract List registerOrderEntryFixes(@Nonnull PsiReference reference); + @Nullable + public abstract List registerOrderEntryFixes(@Nonnull PsiReference reference); - @Nonnull - public abstract IntentionAction createAddMissingRequiredAnnotationParametersFix(@Nonnull PsiAnnotation annotation, - @Nonnull PsiMethod[] annotationMethods, - @Nonnull Collection missedElements); + @Nonnull + public abstract IntentionAction createAddMissingRequiredAnnotationParametersFix( + @Nonnull PsiAnnotation annotation, + @Nonnull PsiMethod[] annotationMethods, + @Nonnull Collection missedElements + ); - @Nonnull - public abstract IntentionAction createSurroundWithQuotesAnnotationParameterValueFix(@Nonnull PsiAnnotationMemberValue value, @Nonnull PsiType expectedType); + @Nonnull + public abstract IntentionAction createSurroundWithQuotesAnnotationParameterValueFix( + @Nonnull PsiAnnotationMemberValue value, + @Nonnull PsiType expectedType + ); - @Nonnull - public abstract IntentionAction addMethodQualifierFix(@Nonnull PsiMethodCallExpression methodCall); + @Nonnull + public abstract IntentionAction addMethodQualifierFix(@Nonnull PsiMethodCallExpression methodCall); - @Nonnull - public abstract IntentionAction createWrapWithAdapterFix(@Nullable PsiType type, @Nonnull PsiExpression expression); + @Nonnull + public abstract IntentionAction createWrapWithAdapterFix(@Nullable PsiType type, @Nonnull PsiExpression expression); - @Nonnull - public abstract IntentionAction createWrapWithOptionalFix(@Nullable PsiType type, @Nonnull PsiExpression expression); + @Nonnull + public abstract IntentionAction createWrapWithOptionalFix(@Nullable PsiType type, @Nonnull PsiExpression expression); - @Nullable - public abstract IntentionAction createNotIterableForEachLoopFix(@Nonnull PsiExpression expression); + @Nullable + public abstract IntentionAction createNotIterableForEachLoopFix(@Nonnull PsiExpression expression); - @Nonnull - public abstract List createAddAnnotationAttributeNameFixes(@Nonnull PsiNameValuePair pair); + @Nonnull + public abstract List createAddAnnotationAttributeNameFixes(@Nonnull PsiNameValuePair pair); - @Nonnull - public abstract IntentionAction createCollectionToArrayFix(@Nonnull PsiExpression collectionExpression, @Nonnull PsiArrayType arrayType); + @Nonnull + public abstract IntentionAction createCollectionToArrayFix( + @Nonnull PsiExpression collectionExpression, + @Nonnull PsiArrayType arrayType + ); - @Nonnull - public abstract IntentionAction createInsertMethodCallFix(@Nonnull PsiMethodCallExpression call, PsiMethod method); + @Nonnull + public abstract IntentionAction createInsertMethodCallFix(@Nonnull PsiMethodCallExpression call, PsiMethod method); - @Nonnull - public abstract LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticViaInstanceFix(PsiReferenceExpression methodRef, JavaResolveResult result); + @Nonnull + public abstract LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticViaInstanceFix( + PsiReferenceExpression methodRef, + JavaResolveResult result + ); - @Nonnull - public abstract IntentionAction createWrapStringWithFileFix(@Nullable PsiType type, @Nonnull PsiExpression expression); + @Nonnull + public abstract IntentionAction createWrapStringWithFileFix(@Nullable PsiType type, @Nonnull PsiExpression expression); - @Nonnull - public abstract IntentionAction createAddMissingEnumBranchesFix(@Nonnull PsiSwitchBlock switchBlock, @Nonnull Set missingCases); + @Nonnull + public abstract IntentionAction createAddMissingEnumBranchesFix(@Nonnull PsiSwitchBlock switchBlock, @Nonnull Set missingCases); - @Nonnull - public abstract IntentionAction createAddSwitchDefaultFix(@Nonnull PsiSwitchBlock switchBlock, @Nullable String message); + @Nonnull + public abstract IntentionAction createAddSwitchDefaultFix(@Nonnull PsiSwitchBlock switchBlock, @Nullable String message); - @Nonnull - public abstract IntentionAction createWrapSwitchRuleStatementsIntoBlockFix(PsiSwitchLabeledRuleStatement rule); + @Nonnull + public abstract IntentionAction createWrapSwitchRuleStatementsIntoBlockFix(PsiSwitchLabeledRuleStatement rule); } \ No newline at end of file diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java index 81d45cc379..ace92e04f2 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java @@ -37,312 +37,352 @@ import java.util.concurrent.ConcurrentHashMap; final class RefCountHolder { - private final PsiFile myFile; - // resolved elements -> list of their references in this file - private final - @Nonnull - MultiMap myLocalRefsMap; - - private final Set myDclsUsedMap; - // reference -> import statement the reference has come from - private final Map myImportStatements; - - private static final Key> REF_COUNT_HOLDER_IN_FILE_KEY = Key.create("REF_COUNT_HOLDER_IN_FILE_KEY"); - private volatile boolean ready; // true when analysis completed and inner maps can be queried - - static RefCountHolder get(@Nonnull PsiFile file, @Nonnull TextRange dirtyScope) { - Reference ref = file.getUserData(REF_COUNT_HOLDER_IN_FILE_KEY); - RefCountHolder storedHolder = consulo.util.lang.ref.SoftReference.dereference(ref); - boolean wholeFile = dirtyScope.equals(file.getTextRange()); - if (storedHolder == null && !wholeFile) { - // RefCountHolder was GCed and queried for subrange of the file, can't return anything meaningful - return null; + private final PsiFile myFile; + // resolved elements -> list of their references in this file + @Nonnull + private final MultiMap myLocalRefsMap; + + private final Set myDclsUsedMap; + // reference -> import statement the reference has come from + private final Map myImportStatements; + + private static final Key> REF_COUNT_HOLDER_IN_FILE_KEY = Key.create("REF_COUNT_HOLDER_IN_FILE_KEY"); + private volatile boolean ready; // true when analysis completed and inner maps can be queried + + static RefCountHolder get(@Nonnull PsiFile file, @Nonnull TextRange dirtyScope) { + Reference ref = file.getUserData(REF_COUNT_HOLDER_IN_FILE_KEY); + RefCountHolder storedHolder = consulo.util.lang.ref.SoftReference.dereference(ref); + boolean wholeFile = dirtyScope.equals(file.getTextRange()); + if (storedHolder == null && !wholeFile) { + // RefCountHolder was GCed and queried for subrange of the file, can't return anything meaningful + return null; + } + return storedHolder == null || wholeFile + ? new RefCountHolder( + file, + MultiMap.createConcurrentSet(), + Sets.newConcurrentHashSet(HashingStrategy.canonical()), + new ConcurrentHashMap<>() + ) + : storedHolder.removeInvalidRefs(); } - return storedHolder == null || wholeFile ? - new RefCountHolder(file, MultiMap.createConcurrentSet(), Sets.newConcurrentHashSet(HashingStrategy.canonical()), new ConcurrentHashMap<>()) - : storedHolder.removeInvalidRefs(); - } - - void storeReadyHolder(@Nonnull PsiFile file) { - ready = true; - file.putUserData(REF_COUNT_HOLDER_IN_FILE_KEY, new SoftReference<>(this)); - } - - private RefCountHolder(@Nonnull PsiFile file, - @Nonnull MultiMap myLocalRefsMap, - @Nonnull Set myDclsUsedMap, - @Nonnull Map myImportStatements) { - myFile = file; - this.myLocalRefsMap = myLocalRefsMap; - this.myDclsUsedMap = myDclsUsedMap; - this.myImportStatements = myImportStatements; - log("c: created for ", file); - } - - @Nonnull - GlobalUsageHelper getGlobalUsageHelper(@Nonnull PsiFile file, - @Nullable UnusedDeclarationInspectionBase deadCodeInspection, - UnusedDeclarationInspectionState deadCodeState) { - FileViewProvider viewProvider = file.getViewProvider(); - Project project = file.getProject(); - - ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex(); - VirtualFile virtualFile = viewProvider.getVirtualFile(); - boolean inLibrary = fileIndex.isInLibrary(virtualFile); - - boolean isDeadCodeEnabled = deadCodeInspection != null && deadCodeInspection.isGlobalEnabledInEditor(); - if (isDeadCodeEnabled && !inLibrary) { - return new GlobalUsageHelperBase() { - final Map myEntryPointCache = FactoryMap.create((PsiMember member) -> { - if (deadCodeInspection.isEntryPoint(member, deadCodeState)) return true; - if (member instanceof PsiClass) { - return !JBTreeTraverser - .from(m -> m instanceof PsiClass - ? JBIterable.from(PsiTreeUtil.getStubChildrenOfTypeAsList(m, PsiMember.class)) - : JBIterable.empty()) - .withRoot(member) - .traverse() - .skip(1) - .processEach(this::shouldCheckUsages); - } - return false; - }); - @Override - public boolean shouldCheckUsages(@Nonnull PsiMember member) { - return !myEntryPointCache.get(member); + void storeReadyHolder(@Nonnull PsiFile file) { + ready = true; + file.putUserData(REF_COUNT_HOLDER_IN_FILE_KEY, new SoftReference<>(this)); + } + + private RefCountHolder( + @Nonnull PsiFile file, + @Nonnull MultiMap myLocalRefsMap, + @Nonnull Set myDclsUsedMap, + @Nonnull Map myImportStatements + ) { + myFile = file; + this.myLocalRefsMap = myLocalRefsMap; + this.myDclsUsedMap = myDclsUsedMap; + this.myImportStatements = myImportStatements; + log("c: created for ", file); + } + + @Nonnull + GlobalUsageHelper getGlobalUsageHelper( + @Nonnull PsiFile file, + @Nullable UnusedDeclarationInspectionBase deadCodeInspection, + UnusedDeclarationInspectionState deadCodeState + ) { + FileViewProvider viewProvider = file.getViewProvider(); + Project project = file.getProject(); + + ProjectFileIndex fileIndex = ProjectRootManager.getInstance(project).getFileIndex(); + VirtualFile virtualFile = viewProvider.getVirtualFile(); + boolean inLibrary = fileIndex.isInLibrary(virtualFile); + + boolean isDeadCodeEnabled = deadCodeInspection != null && deadCodeInspection.isGlobalEnabledInEditor(); + if (isDeadCodeEnabled && !inLibrary) { + return new GlobalUsageHelperBase() { + final Map myEntryPointCache = FactoryMap.create((PsiMember member) -> { + if (deadCodeInspection.isEntryPoint(member, deadCodeState)) { + return true; + } + if (member instanceof PsiClass) { + return !JBTreeTraverser.from( + m -> m instanceof PsiClass + ? JBIterable.from(PsiTreeUtil.getStubChildrenOfTypeAsList(m, PsiMember.class)) + : JBIterable.empty() + ) + .withRoot(member) + .traverse() + .skip(1) + .processEach(this::shouldCheckUsages); + } + return false; + }); + + @Override + public boolean shouldCheckUsages(@Nonnull PsiMember member) { + return !myEntryPointCache.get(member); + } + }; } - }; + return new GlobalUsageHelperBase(); } - return new GlobalUsageHelperBase(); - } - - void registerLocallyReferenced(@Nonnull PsiNamedElement result) { - myDclsUsedMap.add(PsiAnchor.create(result)); - } - - void registerReference(@Nonnull PsiReference ref, @Nonnull JavaResolveResult resolveResult) { - PsiElement refElement = resolveResult.getElement(); - PsiFile psiFile = refElement == null ? null : refElement.getContainingFile(); - if (psiFile != null) - psiFile = (PsiFile) psiFile.getNavigationElement(); // look at navigation elements because all references resolve into Cls elements when highlighting library source - if (refElement != null && psiFile != null && myFile.getViewProvider().equals(psiFile.getViewProvider())) { - registerLocalRef(ref, refElement.getNavigationElement()); + + void registerLocallyReferenced(@Nonnull PsiNamedElement result) { + myDclsUsedMap.add(PsiAnchor.create(result)); } - PsiElement resolveScope = resolveResult.getCurrentFileResolveScope(); - if (resolveScope instanceof PsiImportStatementBase) { - registerImportStatement(ref, (PsiImportStatementBase) resolveScope); - } else if (refElement == null && ref instanceof PsiJavaReference) { - for (JavaResolveResult result : ((PsiJavaReference) ref).multiResolve(true)) { - resolveScope = result.getCurrentFileResolveScope(); + void registerReference(@Nonnull PsiReference ref, @Nonnull JavaResolveResult resolveResult) { + PsiElement refElement = resolveResult.getElement(); + PsiFile psiFile = refElement == null ? null : refElement.getContainingFile(); + if (psiFile != null) { + // look at navigation elements because all references resolve into Cls elements when highlighting library source + psiFile = (PsiFile)psiFile.getNavigationElement(); + } + if (refElement != null && psiFile != null && myFile.getViewProvider().equals(psiFile.getViewProvider())) { + registerLocalRef(ref, refElement.getNavigationElement()); + } + + PsiElement resolveScope = resolveResult.getCurrentFileResolveScope(); if (resolveScope instanceof PsiImportStatementBase) { - registerImportStatement(ref, (PsiImportStatementBase) resolveScope); - break; + registerImportStatement(ref, (PsiImportStatementBase)resolveScope); + } + else if (refElement == null && ref instanceof PsiJavaReference) { + for (JavaResolveResult result : ((PsiJavaReference)ref).multiResolve(true)) { + resolveScope = result.getCurrentFileResolveScope(); + if (resolveScope instanceof PsiImportStatementBase) { + registerImportStatement(ref, (PsiImportStatementBase)resolveScope); + break; + } + } } - } } - } - - private void registerImportStatement(@Nonnull PsiReference ref, @Nonnull PsiImportStatementBase importStatement) { - myImportStatements.put(ref, importStatement); - } - - boolean isRedundant(@Nonnull PsiImportStatementBase importStatement) { - assert ready; - return !myImportStatements.containsValue(importStatement); - } - - private void registerLocalRef(@Nonnull PsiReference ref, PsiElement refElement) { - PsiElement element = ref.getElement(); - if (refElement instanceof PsiMethod && PsiTreeUtil.isAncestor(refElement, element, true)) - return; // filter self-recursive calls - if (refElement instanceof PsiClass) { - if (PsiTreeUtil.isAncestor(refElement, element, true)) { - return; // filter inner use of itself - } + + private void registerImportStatement(@Nonnull PsiReference ref, @Nonnull PsiImportStatementBase importStatement) { + myImportStatements.put(ref, importStatement); } - myLocalRefsMap.putValue(refElement, ref); - } - - @Nonnull - private RefCountHolder removeInvalidRefs() { - assert ready; - boolean changed = false; - MultiMap newLocalRefsMap = MultiMap.createConcurrentSet(); - for (Map.Entry> entry : myLocalRefsMap.entrySet()) { - PsiElement element = entry.getKey(); - for (PsiReference ref : entry.getValue()) { - if (ref.getElement().isValid()) { - newLocalRefsMap.putValue(element, ref); - } else { - changed = true; - } - } + + boolean isRedundant(@Nonnull PsiImportStatementBase importStatement) { + assert ready; + return !myImportStatements.containsValue(importStatement); } - Set newDclsUsedMap = Sets.newConcurrentHashSet(HashingStrategy.canonical()); - for (PsiAnchor element : myDclsUsedMap) { - if (element.retrieve() != null) { - newDclsUsedMap.add(element); - } else { - changed = true; - } + + private void registerLocalRef(@Nonnull PsiReference ref, PsiElement refElement) { + PsiElement element = ref.getElement(); + if (refElement instanceof PsiMethod && PsiTreeUtil.isAncestor(refElement, element, true)) { + return; // filter self-recursive calls + } + if (refElement instanceof PsiClass) { + if (PsiTreeUtil.isAncestor(refElement, element, true)) { + return; // filter inner use of itself + } + } + myLocalRefsMap.putValue(refElement, ref); } - Map newImportStatements = new ConcurrentHashMap<>(); - for (Map.Entry entry : myImportStatements.entrySet()) { - PsiReference key = entry.getKey(); - PsiImportStatementBase value = entry.getValue(); - if (value.isValid() && key.getElement().isValid()) { - newImportStatements.put(key, value); - } else { - changed = true; - } + + @Nonnull + private RefCountHolder removeInvalidRefs() { + assert ready; + boolean changed = false; + MultiMap newLocalRefsMap = MultiMap.createConcurrentSet(); + for (Map.Entry> entry : myLocalRefsMap.entrySet()) { + PsiElement element = entry.getKey(); + for (PsiReference ref : entry.getValue()) { + if (ref.getElement().isValid()) { + newLocalRefsMap.putValue(element, ref); + } + else { + changed = true; + } + } + } + Set newDclsUsedMap = Sets.newConcurrentHashSet(HashingStrategy.canonical()); + for (PsiAnchor element : myDclsUsedMap) { + if (element.retrieve() != null) { + newDclsUsedMap.add(element); + } + else { + changed = true; + } + } + Map newImportStatements = new ConcurrentHashMap<>(); + for (Map.Entry entry : myImportStatements.entrySet()) { + PsiReference key = entry.getKey(); + PsiImportStatementBase value = entry.getValue(); + if (value.isValid() && key.getElement().isValid()) { + newImportStatements.put(key, value); + } + else { + changed = true; + } + } + return changed ? new RefCountHolder(myFile, newLocalRefsMap, newDclsUsedMap, newImportStatements) : this; } - return changed ? new RefCountHolder(myFile, newLocalRefsMap, newDclsUsedMap, newImportStatements) : this; - } - - @RequiredReadAction - boolean isReferenced(@Nonnull PsiElement element) { - assert ready; - Collection array = myLocalRefsMap.get(element); - if (!array.isEmpty() && - !isParameterUsedRecursively(element, array) && - !isClassUsedForInnerImports(element, array)) { - for (PsiReference reference : array) { - if (reference.isReferenceTo(element)) return true; - } + + @RequiredReadAction + boolean isReferenced(@Nonnull PsiElement element) { + assert ready; + Collection array = myLocalRefsMap.get(element); + if (!array.isEmpty() && !isParameterUsedRecursively(element, array) && !isClassUsedForInnerImports(element, array)) { + for (PsiReference reference : array) { + if (reference.isReferenceTo(element)) { + return true; + } + } + } + + return myDclsUsedMap.contains(PsiAnchor.create(element)); } - return myDclsUsedMap.contains(PsiAnchor.create(element)); - } + private boolean isClassUsedForInnerImports(@Nonnull PsiElement element, @Nonnull Collection array) { + assert ready; + if (!(element instanceof PsiClass)) { + return false; + } - private boolean isClassUsedForInnerImports(@Nonnull PsiElement element, @Nonnull Collection array) { - assert ready; - if (!(element instanceof PsiClass)) return false; + Set imports = new HashSet<>(); + for (PsiReference classReference : array) { + PsiImportStatementBase importStmt = PsiTreeUtil.getParentOfType(classReference.getElement(), PsiImportStatementBase.class); + if (importStmt == null) { + return false; + } + imports.add(importStmt); + } - Set imports = new HashSet<>(); - for (PsiReference classReference : array) { - PsiImportStatementBase importStmt = PsiTreeUtil.getParentOfType(classReference.getElement(), PsiImportStatementBase.class); - if (importStmt == null) return false; - imports.add(importStmt); + return ContainerUtil.all(imports, importStmt -> { + PsiElement importedMember = importStmt.resolve(); + if (importedMember != null && PsiTreeUtil.isAncestor(element, importedMember, false)) { + for (PsiReference memberReference : myLocalRefsMap.get(importedMember)) { + if (!PsiTreeUtil.isAncestor(element, memberReference.getElement(), false)) { + return false; + } + } + return true; + } + return false; + }); } - return ContainerUtil.all(imports, importStmt -> { - PsiElement importedMember = importStmt.resolve(); - if (importedMember != null && PsiTreeUtil.isAncestor(element, importedMember, false)) { - for (PsiReference memberReference : myLocalRefsMap.get(importedMember)) { - if (!PsiTreeUtil.isAncestor(element, memberReference.getElement(), false)) { + @RequiredReadAction + private static boolean isParameterUsedRecursively(@Nonnull PsiElement element, @Nonnull Collection array) { + if (!(element instanceof PsiParameter)) { return false; - } } + PsiParameter parameter = (PsiParameter)element; + PsiElement scope = parameter.getDeclarationScope(); + if (!(scope instanceof PsiMethod)) { + return false; + } + PsiMethod method = (PsiMethod)scope; + int paramIndex = ArrayUtil.find(method.getParameterList().getParameters(), parameter); + + for (PsiReference reference : array) { + if (!(reference instanceof PsiElement)) { + return false; + } + PsiElement argument = (PsiElement)reference; + + PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)new PsiMatcherImpl(argument) + .dot(PsiMatchers.hasClass(PsiReferenceExpression.class)) + .parent(PsiMatchers.hasClass(PsiExpressionList.class)) + .parent(PsiMatchers.hasClass(PsiMethodCallExpression.class)) + .getElement(); + if (methodCallExpression == null) { + return false; + } + PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); + if (method != methodExpression.resolve()) { + return false; + } + PsiExpressionList argumentList = methodCallExpression.getArgumentList(); + PsiExpression[] arguments = argumentList.getExpressions(); + int argumentIndex = ArrayUtil.find(arguments, argument); + if (paramIndex != argumentIndex) { + return false; + } + } + return true; - } - return false; - }); - } - - @RequiredReadAction - private static boolean isParameterUsedRecursively(@Nonnull PsiElement element, @Nonnull Collection array) { - if (!(element instanceof PsiParameter)) return false; - PsiParameter parameter = (PsiParameter) element; - PsiElement scope = parameter.getDeclarationScope(); - if (!(scope instanceof PsiMethod)) return false; - PsiMethod method = (PsiMethod) scope; - int paramIndex = ArrayUtil.find(method.getParameterList().getParameters(), parameter); - - for (PsiReference reference : array) { - if (!(reference instanceof PsiElement)) return false; - PsiElement argument = (PsiElement) reference; - - PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) new PsiMatcherImpl(argument) - .dot(PsiMatchers.hasClass(PsiReferenceExpression.class)) - .parent(PsiMatchers.hasClass(PsiExpressionList.class)) - .parent(PsiMatchers.hasClass(PsiMethodCallExpression.class)) - .getElement(); - if (methodCallExpression == null) return false; - PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression(); - if (method != methodExpression.resolve()) return false; - PsiExpressionList argumentList = methodCallExpression.getArgumentList(); - PsiExpression[] arguments = argumentList.getExpressions(); - int argumentIndex = ArrayUtil.find(arguments, argument); - if (paramIndex != argumentIndex) return false; } - return true; - } - - @RequiredReadAction - boolean isReferencedForRead(@Nonnull PsiVariable variable) { - assert ready; - Collection array = myLocalRefsMap.get(variable); - if (array.isEmpty()) return false; - for (PsiReference ref : array) { - PsiElement refElement = ref.getElement(); - PsiElement resolved = ref.resolve(); - if (resolved != null) { - ReadWriteAccessDetector.Access access = getAccess(ref, resolved); - if (access != null && access.isReferencedForRead()) { - if (isJustIncremented(access, refElement)) continue; - return true; + @RequiredReadAction + boolean isReferencedForRead(@Nonnull PsiVariable variable) { + assert ready; + Collection array = myLocalRefsMap.get(variable); + if (array.isEmpty()) { + return false; } - } - } - return false; - } - - @RequiredReadAction - private static ReadWriteAccessDetector.Access getAccess(@Nonnull PsiReference ref, @Nonnull PsiElement resolved) { - PsiElement start = resolved.getLanguage() == ref.getElement().getLanguage() ? resolved : ref.getElement(); - ReadWriteAccessDetector detector = ReadWriteAccessDetector.findDetector(start); - if (detector != null) { - return detector.getReferenceAccess(resolved, ref); + for (PsiReference ref : array) { + PsiElement refElement = ref.getElement(); + PsiElement resolved = ref.resolve(); + if (resolved != null) { + ReadWriteAccessDetector.Access access = getAccess(ref, resolved); + if (access != null && access.isReferencedForRead()) { + if (isJustIncremented(access, refElement)) { + continue; + } + return true; + } + } + } + return false; } - return null; - } - - // "var++;" - private static boolean isJustIncremented(@Nonnull ReadWriteAccessDetector.Access access, @Nonnull PsiElement refElement) { - return access == ReadWriteAccessDetector.Access.ReadWrite && - refElement instanceof PsiExpression && - refElement.getParent() instanceof PsiExpression && - refElement.getParent().getParent() instanceof PsiExpressionStatement; - } - - @RequiredReadAction - boolean isReferencedForWrite(@Nonnull PsiVariable variable) { - assert ready; - Collection array = myLocalRefsMap.get(variable); - if (array.isEmpty()) return false; - for (PsiReference ref : array) { - PsiElement resolved = ref.resolve(); - if (resolved != null) { - ReadWriteAccessDetector.Access access = getAccess(ref, resolved); - if (access != null && access.isReferencedForWrite()) { - return true; + + @RequiredReadAction + private static ReadWriteAccessDetector.Access getAccess(@Nonnull PsiReference ref, @Nonnull PsiElement resolved) { + PsiElement start = resolved.getLanguage() == ref.getElement().getLanguage() ? resolved : ref.getElement(); + ReadWriteAccessDetector detector = ReadWriteAccessDetector.findDetector(start); + if (detector != null) { + return detector.getReferenceAccess(resolved, ref); } - } + return null; } - return false; - } - private static void log(@NonNls @Nonnull Object... info) { - //FileStatusMap.log(info); - } + // "var++;" + private static boolean isJustIncremented(@Nonnull ReadWriteAccessDetector.Access access, @Nonnull PsiElement refElement) { + return access == ReadWriteAccessDetector.Access.ReadWrite + && refElement instanceof PsiExpression + && refElement.getParent() instanceof PsiExpression + && refElement.getParent().getParent() instanceof PsiExpressionStatement; + } - private class GlobalUsageHelperBase extends GlobalUsageHelper { - @Override - public boolean shouldCheckUsages(@Nonnull PsiMember member) { - return false; + @RequiredReadAction + boolean isReferencedForWrite(@Nonnull PsiVariable variable) { + assert ready; + Collection array = myLocalRefsMap.get(variable); + if (array.isEmpty()) { + return false; + } + for (PsiReference ref : array) { + PsiElement resolved = ref.resolve(); + if (resolved != null) { + ReadWriteAccessDetector.Access access = getAccess(ref, resolved); + if (access != null && access.isReferencedForWrite()) { + return true; + } + } + } + return false; } - @Override - public boolean isCurrentFileAlreadyChecked() { - return true; + private static void log(@NonNls @Nonnull Object... info) { + //FileStatusMap.log(info); } - @Override - public boolean isLocallyUsed(@Nonnull PsiNamedElement member) { - return isReferenced(member); + private class GlobalUsageHelperBase extends GlobalUsageHelper { + @Override + public boolean shouldCheckUsages(@Nonnull PsiMember member) { + return false; + } + + @Override + public boolean isCurrentFileAlreadyChecked() { + return true; + } + + @Override + public boolean isLocallyUsed(@Nonnull PsiNamedElement member) { + return isReferenced(member); + } } - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java index f9b244c4ef..08eb7993bb 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java @@ -24,6 +24,7 @@ import consulo.annotation.access.RequiredReadAction; import consulo.codeEditor.Editor; import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.language.editor.FileModificationService; import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.util.LanguageUndoUtil; @@ -47,188 +48,192 @@ import java.util.List; public class ModifierFix extends LocalQuickFixAndIntentionActionOnPsiElement { - private static final Logger LOG = Logger.getInstance(ModifierFix.class); - - @PsiModifier.ModifierConstant private final String myModifier; - private final boolean myShouldHave; - private final boolean myShowContainingClass; - private final String myName; - private final SmartPsiElementPointer myVariable; - - @RequiredReadAction - public ModifierFix( - PsiModifierList modifierList, - @PsiModifier.ModifierConstant @Nonnull String modifier, - boolean shouldHave, - boolean showContainingClass - ) { - super(modifierList); - myModifier = modifier; - myShouldHave = shouldHave; - myShowContainingClass = showContainingClass; - myName = format(null, modifierList); - myVariable = null; - } - - @RequiredReadAction - public ModifierFix( - @Nonnull PsiModifierListOwner owner, - @PsiModifier.ModifierConstant @Nonnull String modifier, - boolean shouldHave, - boolean showContainingClass - ) { - super(owner.getModifierList()); - myModifier = modifier; - myShouldHave = shouldHave; - myShowContainingClass = showContainingClass; - PsiVariable variable = owner instanceof PsiVariable psiVariable ? psiVariable : null; - myName = format(variable, owner.getModifierList()); - - myVariable = variable == null ? null : SmartPointerManager.getInstance(owner.getProject()).createSmartPsiElementPointer(variable); - } - - @Nonnull - @Override - public String getText() { - return myName; - } - - @RequiredReadAction - private String format(PsiVariable variable, PsiModifierList modifierList) { - String name = null; - PsiElement parent = variable == null ? modifierList == null ? null : modifierList.getParent() : variable; - if (parent instanceof PsiClass psiClass) { - name = psiClass.getName(); + private static final Logger LOG = Logger.getInstance(ModifierFix.class); + + @PsiModifier.ModifierConstant + private final String myModifier; + private final boolean myShouldHave; + private final boolean myShowContainingClass; + private final String myName; + private final SmartPsiElementPointer myVariable; + + @RequiredReadAction + public ModifierFix( + PsiModifierList modifierList, + @PsiModifier.ModifierConstant @Nonnull String modifier, + boolean shouldHave, + boolean showContainingClass + ) { + super(modifierList); + myModifier = modifier; + myShouldHave = shouldHave; + myShowContainingClass = showContainingClass; + myName = format(null, modifierList); + myVariable = null; } - else { - int options = PsiFormatUtilBase.SHOW_NAME | (myShowContainingClass ? PsiFormatUtilBase.SHOW_CONTAINING_CLASS : 0); - if (parent instanceof PsiMethod method) { - name = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, options, 0); - } - else if (parent instanceof PsiVariable psiVariable) { - name = PsiFormatUtil.formatVariable(psiVariable, options, PsiSubstitutor.EMPTY); - } - else if (parent instanceof PsiClassInitializer classInitializer) { - PsiClass containingClass = classInitializer.getContainingClass(); - String className = containingClass instanceof PsiAnonymousClass anonymousClass - ? JavaQuickFixBundle.message("anonymous.class.presentation", anonymousClass.getBaseClassType().getPresentableText()) - : containingClass != null ? containingClass.getName() : "unknown"; - name = JavaQuickFixBundle.message("class.initializer.presentation", className); - } + + @RequiredReadAction + public ModifierFix( + @Nonnull PsiModifierListOwner owner, + @PsiModifier.ModifierConstant @Nonnull String modifier, + boolean shouldHave, + boolean showContainingClass + ) { + super(owner.getModifierList()); + myModifier = modifier; + myShouldHave = shouldHave; + myShowContainingClass = showContainingClass; + PsiVariable variable = owner instanceof PsiVariable psiVariable ? psiVariable : null; + myName = format(variable, owner.getModifierList()); + + myVariable = variable == null ? null : SmartPointerManager.getInstance(owner.getProject()).createSmartPsiElementPointer(variable); } - String modifierText = VisibilityUtil.toPresentableText(myModifier); - - return JavaQuickFixBundle.message(myShouldHave ? "add.modifier.fix" : "remove.modifier.fix", name, modifierText); - } - - @Override - @Nonnull - public String getFamilyName() { - return JavaQuickFixBundle.message("fix.modifiers.family"); - } - - @Override - @RequiredReadAction - public boolean isAvailable( - @Nonnull Project project, - @Nonnull PsiFile file, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement - ) { - final PsiModifierList myModifierList = (PsiModifierList)startElement; - PsiVariable variable = myVariable == null ? null : myVariable.getElement(); - return myModifierList.isValid() && - myModifierList.getManager().isInProject(myModifierList) && - myModifierList.hasExplicitModifier(myModifier) != myShouldHave && - (variable == null || variable.isValid()); - } - - private void changeModifierList (PsiModifierList modifierList) { - try { - modifierList.setModifierProperty(myModifier, myShouldHave); + @Nonnull + @Override + public String getText() { + return myName; } - catch (IncorrectOperationException e) { - LOG.error(e); + + @RequiredReadAction + private String format(PsiVariable variable, PsiModifierList modifierList) { + String name = null; + PsiElement parent = variable == null ? modifierList == null ? null : modifierList.getParent() : variable; + if (parent instanceof PsiClass psiClass) { + name = psiClass.getName(); + } + else { + int options = PsiFormatUtilBase.SHOW_NAME | (myShowContainingClass ? PsiFormatUtilBase.SHOW_CONTAINING_CLASS : 0); + if (parent instanceof PsiMethod method) { + name = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY, options, 0); + } + else if (parent instanceof PsiVariable psiVariable) { + name = PsiFormatUtil.formatVariable(psiVariable, options, PsiSubstitutor.EMPTY); + } + else if (parent instanceof PsiClassInitializer classInitializer) { + PsiClass containingClass = classInitializer.getContainingClass(); + String className = containingClass instanceof PsiAnonymousClass anonymousClass + ? JavaQuickFixBundle.message("anonymous.class.presentation", anonymousClass.getBaseClassType().getPresentableText()) + : containingClass != null ? containingClass.getName() : "unknown"; + name = JavaQuickFixBundle.message("class.initializer.presentation", className); + } + } + + String modifierText = VisibilityUtil.toPresentableText(myModifier); + + return JavaQuickFixBundle.message(myShouldHave ? "add.modifier.fix" : "remove.modifier.fix", name, modifierText); } - } - - @Override - @RequiredUIAccess - public void invoke( - @Nonnull Project project, - @Nonnull PsiFile file, - @Nullable Editor editor, - @Nonnull PsiElement startElement, - @Nonnull PsiElement endElement - ) { - final PsiModifierList myModifierList = (PsiModifierList)startElement; - final PsiVariable variable = myVariable == null ? null : myVariable.getElement(); - if (!FileModificationService.getInstance().preparePsiElementForWrite(myModifierList)) return; - final List modifierLists = new ArrayList<>(); - final PsiFile containingFile = myModifierList.getContainingFile(); - final PsiModifierList modifierList; - if (variable != null && variable.isValid()) { - project.getApplication().runWriteAction(() -> { + + @Nonnull + @Override + public String getFamilyName() { + return JavaQuickFixBundle.message("fix.modifiers.family"); + } + + @Override + @RequiredReadAction + public boolean isAvailable( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiModifierList myModifierList = (PsiModifierList)startElement; + PsiVariable variable = myVariable == null ? null : myVariable.getElement(); + return myModifierList.isValid() + && myModifierList.getManager().isInProject(myModifierList) + && myModifierList.hasExplicitModifier(myModifier) != myShouldHave + && (variable == null || variable.isValid()); + } + + private void changeModifierList(PsiModifierList modifierList) { try { - variable.normalizeDeclaration(); + modifierList.setModifierProperty(myModifier, myShouldHave); } catch (IncorrectOperationException e) { - LOG.error(e); + LOG.error(e); } - }); - modifierList = variable.getModifierList(); - assert modifierList != null; - } - else { - modifierList = myModifierList; - } - PsiElement owner = modifierList.getParent(); - if (owner instanceof PsiMethod method) { - PsiModifierList copy = (PsiModifierList)myModifierList.copy(); - changeModifierList(copy); - final int accessLevel = PsiUtil.getAccessLevel(copy); - - OverridingMethodsSearch.search(method, owner.getResolveScope(), true) - .forEach(new PsiElementProcessorAdapter<>((PsiElementProcessor)inheritor -> { - PsiModifierList list = inheritor.getModifierList(); - if (inheritor.getManager().isInProject(inheritor) && PsiUtil.getAccessLevel(list) < accessLevel) { - modifierLists.add(list); - } - return true; - })); } - if (!FileModificationService.getInstance().prepareFileForWrite(containingFile)) return; + @Override + @RequiredUIAccess + public void invoke( + @Nonnull Project project, + @Nonnull PsiFile file, + @Nullable Editor editor, + @Nonnull PsiElement startElement, + @Nonnull PsiElement endElement + ) { + final PsiModifierList myModifierList = (PsiModifierList)startElement; + final PsiVariable variable = myVariable == null ? null : myVariable.getElement(); + if (!FileModificationService.getInstance().preparePsiElementForWrite(myModifierList)) { + return; + } + final List modifierLists = new ArrayList<>(); + final PsiFile containingFile = myModifierList.getContainingFile(); + final PsiModifierList modifierList; + if (variable != null && variable.isValid()) { + project.getApplication().runWriteAction(() -> { + try { + variable.normalizeDeclaration(); + } + catch (IncorrectOperationException e) { + LOG.error(e); + } + }); + modifierList = variable.getModifierList(); + assert modifierList != null; + } + else { + modifierList = myModifierList; + } + PsiElement owner = modifierList.getParent(); + if (owner instanceof PsiMethod method) { + PsiModifierList copy = (PsiModifierList)myModifierList.copy(); + changeModifierList(copy); + final int accessLevel = PsiUtil.getAccessLevel(copy); + + OverridingMethodsSearch.search(method, owner.getResolveScope(), true) + .forEach(new PsiElementProcessorAdapter<>((PsiElementProcessor)inheritor -> { + PsiModifierList list = inheritor.getModifierList(); + if (inheritor.getManager().isInProject(inheritor) && PsiUtil.getAccessLevel(list) < accessLevel) { + modifierLists.add(list); + } + return true; + })); + } - if (!modifierLists.isEmpty()) { - if (Messages.showYesNoDialog( - project, - JavaQuickFixBundle.message("change.inheritors.visibility.warning.text"), - JavaQuickFixBundle.message("change.inheritors.visibility.warning.title"), - UIUtil.getQuestionIcon() - ) == DialogWrapper.OK_EXIT_CODE) { - project.getApplication().runWriteAction(() -> { - if (!FileModificationService.getInstance().preparePsiElementsForWrite(modifierLists)) { + if (!FileModificationService.getInstance().prepareFileForWrite(containingFile)) { return; - } + } - for (final PsiModifierList modifierList1 : modifierLists) { - changeModifierList(modifierList1); - } + if (!modifierLists.isEmpty()) { + if (Messages.showYesNoDialog( + project, + JavaQuickFixBundle.message("change.inheritors.visibility.warning.text"), + JavaQuickFixBundle.message("change.inheritors.visibility.warning.title"), + UIUtil.getQuestionIcon() + ) == DialogWrapper.OK_EXIT_CODE) { + project.getApplication().runWriteAction(() -> { + if (!FileModificationService.getInstance().preparePsiElementsForWrite(modifierLists)) { + return; + } + + for (final PsiModifierList modifierList1 : modifierLists) { + changeModifierList(modifierList1); + } + }); + } + } + + project.getApplication().runWriteAction(() -> { + changeModifierList(modifierList); + LanguageUndoUtil.markPsiFileForUndo(containingFile); }); - } } - project.getApplication().runWriteAction(() -> { - changeModifierList(modifierList); - LanguageUndoUtil.markPsiFileForUndo(containingFile); - }); - } - - @Override - public boolean startInWriteAction() { - return false; - } - + @Override + public boolean startInWriteAction() { + return false; + } } 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 a3c8eebf8b..f8c9ea0db1 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 @@ -80,879 +80,930 @@ @Singleton @ServiceImpl public class QuickFixFactoryImpl extends QuickFixFactory { - private static final Logger LOG = Logger.getInstance(QuickFixFactoryImpl.class); - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@Nonnull PsiModifierList modifierList, - @Nonnull String modifier, - boolean shouldHave, - boolean showContainingClass) { - return new ModifierFix(modifierList, modifier, shouldHave, showContainingClass); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix(@Nonnull PsiModifierListOwner owner, - @Nonnull final String modifier, - final boolean shouldHave, - final boolean showContainingClass) { - return new ModifierFix(owner, modifier, shouldHave, showContainingClass); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix(@Nonnull PsiMethod method, - @Nonnull PsiType toReturn, - boolean fixWholeHierarchy) { - return new MethodReturnTypeFix(method, toReturn, fixWholeHierarchy); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull PsiMethod method, @Nonnull PsiClass toClass) { - return new AddMethodFix(method, toClass); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull String methodText, - @Nonnull PsiClass toClass, - @Nonnull String... exceptions) { - return new AddMethodFix(methodText, toClass, exceptions); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiClass aClass) { - return new ImplementMethodsFix(aClass); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiElement psiElement) { - return new ImplementMethodsFix(psiElement); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAssignmentToComparisonFix(PsiAssignmentExpression expr) { - return new ReplaceAssignmentWithComparisonFix(expr); - } - - @Nonnull - @Override - public LocalQuickFixOnPsiElement createMethodThrowsFix(@Nonnull PsiMethod method, - @Nonnull PsiClassType exceptionClass, - boolean shouldThrow, - boolean showContainingClass) { - return new MethodThrowsFix(method, exceptionClass, shouldThrow, showContainingClass); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFix(@Nonnull PsiClass aClass) { - return new AddDefaultConstructorFix(aClass); - } - - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix(@Nonnull PsiClass aClass, @Nonnull String modifier) { - return aClass.getName() != null ? new AddDefaultConstructorFix(aClass, modifier) : null; - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createMethodParameterTypeFix(@Nonnull PsiMethod method, - int index, - @Nonnull PsiType newType, - boolean fixWholeHierarchy) { - return new MethodParameterFix(method, newType, index, fixWholeHierarchy); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass) { - return new MakeClassInterfaceFix(aClass, true); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass, final boolean makeInterface) { - return new MakeClassInterfaceFix(aClass, makeInterface); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createExtendsListFix(@Nonnull PsiClass aClass, - @Nonnull PsiClassType typeToExtendFrom, - boolean toAdd) { - return new ExtendsListFix(aClass, typeToExtendFrom, toAdd); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createRemoveUnusedParameterFix(@Nonnull PsiParameter parameter) { - return new RemoveUnusedParameterFix(parameter); - } - - @Nonnull - @Override - public IntentionAction createRemoveUnusedVariableFix(@Nonnull PsiVariable variable) { - return new RemoveUnusedVariableFix(variable); - } - - @Override - @Nullable - public IntentionAction createCreateClassOrPackageFix(@Nonnull final PsiElement context, - @Nonnull final String qualifiedName, - final boolean createClass, - final String superClass) { - return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : null, superClass); - } - - @Override - @Nullable - public IntentionAction createCreateClassOrInterfaceFix(@Nonnull final PsiElement context, - @Nonnull final String qualifiedName, - final boolean createClass, - final String superClass) { - return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : ClassKind.INTERFACE, superClass); - } - - @Nonnull - @Override - public IntentionAction createCreateFieldOrPropertyFix(@Nonnull final PsiClass aClass, - @Nonnull final String name, - @Nonnull final PsiType type, - @Nonnull final PropertyMemberType targetMember, - @Nonnull final PsiAnnotation... annotations) { - return new CreateFieldOrPropertyFix(aClass, name, type, targetMember, annotations); - } - - @Nonnull - @Override - public IntentionAction createSetupJDKFix() { - return SetupJDKFix.getInstance(); - } - - @Nonnull - @Override - public IntentionAction createAddExceptionToCatchFix() { - return new AddExceptionToCatchFix(); - } - - @Nonnull - @Override - public IntentionAction createAddExceptionToThrowsFix(@Nonnull PsiElement element) { - return new AddExceptionToThrowsFix(element); - } - - @Nonnull - @Override - public IntentionAction createAddExceptionFromFieldInitializerToConstructorThrowsFix(@Nonnull PsiElement element) { - return new AddExceptionFromFieldInitializerToConstructorThrowsFix(element); - } - - @Nonnull - @Override - public IntentionAction createSurroundWithTryCatchFix(@Nonnull PsiElement element) { - return new SurroundWithTryCatchFix(element); - } - - @Nonnull - @Override - public IntentionAction createGeneralizeCatchFix(@Nonnull PsiElement element, @Nonnull PsiClassType type) { - return new GeneralizeCatchFix(element, type); - } - - @Nonnull - @Override - public IntentionAction createChangeToAppendFix(@Nonnull IElementType sign, - @Nonnull PsiType type, - @Nonnull PsiAssignmentExpression assignment) { - return new ChangeToAppendFix(sign, type, assignment); - } - - @Nonnull - @Override - public IntentionAction createAddTypeCastFix(@Nonnull PsiType type, @Nonnull PsiExpression expression) { - return new AddTypeCastFix(type, expression); - } - - @Nonnull - @Override - public IntentionAction createWrapExpressionFix(@Nonnull PsiType type, @Nonnull PsiExpression expression) { - return new WrapExpressionFix(type, expression); - } - - @Nonnull - @Override - public IntentionAction createReuseVariableDeclarationFix(@Nonnull PsiLocalVariable variable) { - return new ReuseVariableDeclarationFix(variable); - } - - @Nonnull - @Override - public IntentionAction createConvertToStringLiteralAction() { - return new ConvertToStringLiteralAction(); - } - - @Nonnull - @Override - public IntentionAction createDeleteCatchFix(@Nonnull PsiParameter parameter) { - return new DeleteCatchFix(parameter); - } - - @Nonnull - @Override - public IntentionAction createDeleteMultiCatchFix(@Nonnull PsiTypeElement element) { - return new DeleteMultiCatchFix(element); - } - - @Nonnull - @Override - public IntentionAction createConvertSwitchToIfIntention(@Nonnull PsiSwitchStatement statement) { - return new ConvertSwitchToIfIntention(statement); - } - - @Nonnull - @Override - public IntentionAction createNegationBroadScopeFix(@Nonnull PsiPrefixExpression expr) { - return new NegationBroadScopeFix(expr); - } - - @Nonnull - @Override - public IntentionAction createCreateFieldFromUsageFix(@Nonnull PsiReferenceExpression place) { - return new CreateFieldFromUsageFix(place); - } - - @Nonnull - @Override - public IntentionAction createReplaceWithListAccessFix(@Nonnull PsiArrayAccessExpression expression) { - return new ReplaceWithListAccessFix(expression); - } - - @Nonnull - @Override - public IntentionAction createAddNewArrayExpressionFix(@Nonnull PsiArrayInitializerExpression expression) { - return new AddNewArrayExpressionFix(expression); - } - - @Nonnull - @Override - public IntentionAction createMoveCatchUpFix(@Nonnull PsiCatchSection section, @Nonnull PsiCatchSection section1) { - return new MoveCatchUpFix(section, section1); - } - - @Nonnull - @Override - public IntentionAction createRenameWrongRefFix(@Nonnull PsiReferenceExpression ref) { - return new RenameWrongRefFix(ref); - } - - @Nonnull - @Override - public IntentionAction createRemoveQualifierFix(@Nonnull PsiExpression qualifier, - @Nonnull PsiReferenceExpression expression, - @Nonnull PsiClass resolved) { - return new RemoveQualifierFix(qualifier, expression, resolved); - } - - @Nonnull - @Override - public IntentionAction createRemoveParameterListFix(@Nonnull PsiMethod parent) { - return new RemoveParameterListFix(parent); - } - - @Nonnull - @Override - public IntentionAction createShowModulePropertiesFix(@Nonnull PsiElement element) { - return new ShowModulePropertiesFix(element); - } - - @Nonnull - @Override - public IntentionAction createShowModulePropertiesFix(@Nonnull Module module) { - return new ShowModulePropertiesFix(module); - } - - @Nonnull - @Override - public IntentionAction createIncreaseLanguageLevelFix(@Nonnull LanguageLevel level) { - return new IncreaseLanguageLevelFix(level); - } - - @Nonnull - @Override - public IntentionAction createChangeParameterClassFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type) { - return new ChangeParameterClassFix(aClass, type); - } - - @Nonnull - @Override - public IntentionAction createReplaceInaccessibleFieldWithGetterSetterFix(@Nonnull PsiElement element, - @Nonnull PsiMethod getter, - boolean isSetter) { - return new ReplaceInaccessibleFieldWithGetterSetterFix(element, getter, isSetter); - } - - @Nonnull - @Override - public IntentionAction createSurroundWithArrayFix(@Nullable PsiCall methodCall, @Nullable PsiExpression expression) { - return new SurroundWithArrayFix(methodCall, expression); - } - - @Nonnull - @Override - public IntentionAction createImplementAbstractClassMethodsFix(@Nonnull PsiElement elementToHighlight) { - return new ImplementAbstractClassMethodsFix(elementToHighlight); - } - - @Nonnull - @Override - public IntentionAction createMoveClassToSeparateFileFix(@Nonnull PsiClass aClass) { - return new MoveClassToSeparateFileFix(aClass); - } - - @Nonnull - @Override - public IntentionAction createRenameFileFix(@Nonnull String newName) { - return new RenameFileFix(newName); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element) { - return new RenameElementFix(element); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element, @Nonnull String newName) { - return new RenameElementFix(element, newName); - } - - @Nonnull - @Override - public IntentionAction createChangeExtendsToImplementsFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType classToExtendFrom) { - return new ChangeExtendsToImplementsFix(aClass, classToExtendFrom); - } - - @Nonnull - @Override - public IntentionAction createCreateConstructorMatchingSuperFix(@Nonnull PsiClass aClass) { - return new CreateConstructorMatchingSuperFix(aClass); - } - - @Nonnull - @Override - public IntentionAction createRemoveNewQualifierFix(@Nonnull PsiNewExpression expression, PsiClass aClass) { - return new RemoveNewQualifierFix(expression, aClass); - } - - @Nonnull - @Override - public IntentionAction createSuperMethodReturnFix(@Nonnull PsiMethod superMethod, @Nonnull PsiType superMethodType) { - return new SuperMethodReturnFix(superMethod, superMethodType); - } - - @Nonnull - @Override - public IntentionAction createInsertNewFix(@Nonnull PsiMethodCallExpression call, @Nonnull PsiClass aClass) { - return new InsertNewFix(call, aClass); - } - - @Nonnull - @Override - public IntentionAction createAddMethodBodyFix(@Nonnull PsiMethod method) { - return new AddMethodBodyFix(method); - } - - @Nonnull - @Override - public IntentionAction createDeleteMethodBodyFix(@Nonnull PsiMethod method) { - return new DeleteMethodBodyFix(method); - } - - @Nonnull - @Override - public IntentionAction createInsertSuperFix(@Nonnull PsiMethod constructor) { - return new InsertSuperFix(constructor); - } - - @Nonnull - @Override - public IntentionAction createInsertThisFix(@Nonnull PsiMethod constructor) { - return new InsertThisFix(constructor); - } - - @Nonnull - @Override - public IntentionAction createChangeMethodSignatureFromUsageFix(@Nonnull PsiMethod targetMethod, - @Nonnull PsiExpression[] expressions, - @Nonnull PsiSubstitutor substitutor, - @Nonnull PsiElement context, - boolean changeAllUsages, - int minUsagesNumberToShowDialog) { - return new ChangeMethodSignatureFromUsageFix(targetMethod, - expressions, - substitutor, - context, - changeAllUsages, - minUsagesNumberToShowDialog); - } - - @Nonnull - @Override - public IntentionAction createChangeMethodSignatureFromUsageReverseOrderFix(@Nonnull PsiMethod targetMethod, - @Nonnull PsiExpression[] expressions, - @Nonnull PsiSubstitutor substitutor, - @Nonnull PsiElement context, - boolean changeAllUsages, - int minUsagesNumberToShowDialog) { - return new ChangeMethodSignatureFromUsageReverseOrderFix(targetMethod, - expressions, - substitutor, - context, - changeAllUsages, - minUsagesNumberToShowDialog); - } - - @Nonnull - @Override - public IntentionAction createCreateMethodFromUsageFix(@Nonnull PsiMethodCallExpression call) { - return new CreateMethodFromUsageFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreateMethodFromUsageFix(PsiMethodReferenceExpression methodReferenceExpression) { - return new CreateMethodFromMethodReferenceFix(methodReferenceExpression); - } - - @Nonnull - @Override - public IntentionAction createCreateAbstractMethodFromUsageFix(@Nonnull PsiMethodCallExpression call) { - return new CreateAbstractMethodFromUsageFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreatePropertyFromUsageFix(@Nonnull PsiMethodCallExpression call) { - return new CreatePropertyFromUsageFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreateConstructorFromSuperFix(@Nonnull PsiMethodCallExpression call) { - return new CreateConstructorFromSuperFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreateConstructorFromThisFix(@Nonnull PsiMethodCallExpression call) { - return new CreateConstructorFromThisFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreateGetterSetterPropertyFromUsageFix(@Nonnull PsiMethodCallExpression call) { - return new CreateGetterSetterPropertyFromUsageFix(call); - } - - @Nonnull - @Override - public IntentionAction createStaticImportMethodFix(@Nonnull PsiMethodCallExpression call) { - return new StaticImportMethodFix(call); - } - - @Nonnull - @Override - public IntentionAction createReplaceAddAllArrayToCollectionFix(@Nonnull PsiMethodCallExpression call) { - return new ReplaceAddAllArrayToCollectionFix(call); - } - - @Nonnull - @Override - public IntentionAction createCreateConstructorFromCallFix(@Nonnull PsiConstructorCall call) { - return new CreateConstructorFromCallFix(call); - } - - @Nonnull - @Override - public List getVariableTypeFromCallFixes(@Nonnull PsiMethodCallExpression call, @Nonnull PsiExpressionList list) { - return VariableTypeFromCallFix.getQuickFixActions(call, list); - } - - @Nonnull - @Override - public IntentionAction createAddReturnFix(@Nonnull PsiMethod method) { - return new AddReturnFix(method); - } - - @Nonnull - @Override - public IntentionAction createAddVariableInitializerFix(@Nonnull PsiVariable variable) { - return new AddVariableInitializerFix(variable); - } - - @Nonnull - @Override - public IntentionAction createDeferFinalAssignmentFix(@Nonnull PsiVariable variable, @Nonnull PsiReferenceExpression expression) { - return new DeferFinalAssignmentFix(variable, expression); - } - - @Nonnull - @Override - public IntentionAction createVariableAccessFromInnerClassFix(@Nonnull PsiVariable variable, @Nonnull PsiElement scope) { - return new VariableAccessFromInnerClassFix(variable, scope); - } - - @Nonnull - @Override - public IntentionAction createCreateConstructorParameterFromFieldFix(@Nonnull PsiField field) { - return new CreateConstructorParameterFromFieldFix(field); - } - - @Nonnull - @Override - public IntentionAction createInitializeFinalFieldInConstructorFix(@Nonnull PsiField field) { - return new InitializeFinalFieldInConstructorFix(field); - } - - @Nonnull - @Override - public IntentionAction createRemoveTypeArgumentsFix(@Nonnull PsiElement variable) { - return new RemoveTypeArgumentsFix(variable); - } - - @Nonnull - @Override - public IntentionAction createChangeClassSignatureFromUsageFix(@Nonnull PsiClass owner, @Nonnull PsiReferenceParameterList parameterList) { - return new ChangeClassSignatureFromUsageFix(owner, parameterList); - } - - @Nonnull - @Override - public IntentionAction createReplacePrimitiveWithBoxedTypeAction(@Nonnull PsiTypeElement element, - @Nonnull String typeName, - @Nonnull String boxedTypeName) { - return new ReplacePrimitiveWithBoxedTypeAction(element, typeName, boxedTypeName); - } - - @Nonnull - @Override - public IntentionAction createMakeVarargParameterLastFix(@Nonnull PsiParameter parameter) { - return new MakeVarargParameterLastFix(parameter); - } - - @Nonnull - @Override - public IntentionAction createMoveBoundClassToFrontFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type) { - return new MoveBoundClassToFrontFix(aClass, type); - } - - @Override - public void registerPullAsAbstractUpFixes(@Nonnull PsiMethod method, @Nonnull QuickFixActionRegistrar registrar) { - PullAsAbstractUpFix.registerQuickFix(method, registrar); - } - - @Nonnull - @Override - public IntentionAction createCreateAnnotationMethodFromUsageFix(@Nonnull PsiNameValuePair pair) { - return new CreateAnnotationMethodFromUsageFix(pair); - } - - @Nonnull - @Override - public IntentionAction createOptimizeImportsFix(final boolean onTheFly) { - final OptimizeImportsFix fix = new OptimizeImportsFix(); - - return new SyntheticIntentionAction() { - @Nonnull - @Override - public String getText() { - return fix.getText(); - } - - @Override - public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { - return (!onTheFly || timeToOptimizeImports(file)) && fix.isAvailable(project, editor, file); - } - - @Override - public void invoke(@Nonnull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException { - invokeOnTheFlyImportOptimizer(() -> fix.invoke(project, editor, file), file); - } - - @Override - public boolean startInWriteAction() { - return fix.startInWriteAction(); - } - }; - } - - @Override - public void registerFixesForUnusedParameter(@Nonnull PsiParameter parameter, @Nonnull Object highlightInfo) { - Project myProject = parameter.getProject(); - InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile(); - UnusedDeclarationInspectionBase unusedParametersInspection = - (UnusedDeclarationInspectionBase)profile.getUnwrappedTool(UnusedSymbolLocalInspectionBase.SHORT_NAME, parameter); - LOG.assertTrue(ApplicationManager.getApplication().isUnitTestMode() || unusedParametersInspection != null); - List options = new ArrayList<>(); - HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME); - options.addAll(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter)); - if (unusedParametersInspection != null) { - SuppressQuickFix[] batchSuppressActions = unusedParametersInspection.getBatchSuppressActions(parameter); - Collections.addAll(options, SuppressIntentionActionFromFix.convertBatchToSuppressIntentionActions(batchSuppressActions)); - } - //need suppress from Unused Parameters but settings from Unused Symbol - QuickFixAction.registerQuickFixAction((HighlightInfo)highlightInfo, - new SafeDeleteFix(parameter), - options, - HighlightDisplayKey.getDisplayNameByKey(myUnusedSymbolKey)); - } - - @Nonnull - @Override - public IntentionAction createAddToDependencyInjectionAnnotationsFix(@Nonnull Project project, - @Nonnull String qualifiedName, - @Nonnull String element) { - final EntryPointsManagerBase entryPointsManager = EntryPointsManagerBase.getInstance(project); - return SpecialAnnotationsUtil.createAddToSpecialAnnotationsListIntentionAction(JavaQuickFixBundle.message( - "fix.unused.symbol.injection.text", - element, - qualifiedName), - JavaQuickFixBundle - .message - ("fix.unused.symbol.injection.family"), - entryPointsManager.ADDITIONAL_ANNOTATIONS, - qualifiedName); - } - - @Nonnull - @Override - public IntentionAction createAddToImplicitlyWrittenFieldsFix(Project project, @Nonnull final String qualifiedName) { - EntryPointsManagerBase entryPointsManagerBase = EntryPointsManagerBase.getInstance(project); - return entryPointsManagerBase.new AddImplicitlyWriteAnnotation(qualifiedName); - } - - @Nonnull - @Override - public IntentionAction createCreateGetterOrSetterFix(boolean createGetter, boolean createSetter, @Nonnull PsiField field) { - return new CreateGetterOrSetterFix(createGetter, createSetter, field); - } - - @Nonnull - @Override - public IntentionAction createRenameToIgnoredFix(@Nonnull PsiNamedElement namedElement) { - return new RenameToIgnoredFix(namedElement); - } - - @Nonnull - @Override - public IntentionAction createEnableOptimizeImportsOnTheFlyFix() { - return new EnableOptimizeImportsOnTheFlyFix(); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element) { - return new DeleteElementFix(element); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nls @Nonnull String text) { - return new DeleteElementFix(element, text); - } - - @Nonnull - @Override - public IntentionAction createSafeDeleteFix(@Nonnull PsiElement element) { - return new SafeDeleteFix(element); - } - - @Nullable - @Override - public List registerOrderEntryFixes(@Nonnull PsiReference reference) { - return OrderEntryFix.registerFixes(reference); - } - - private static void invokeOnTheFlyImportOptimizer(@Nonnull final Runnable runnable, @Nonnull final PsiFile file) { - final Project project = file.getProject(); - final Document document = PsiDocumentManager.getInstance(project).getDocument(file); - if (document == null) { - return; - } - final long stamp = document.getModificationStamp(); - DumbService.getInstance(file.getProject()).smartInvokeLater(() -> - { - if (project.isDisposed() || document.getModificationStamp() != stamp) { - return; - } - //no need to optimize imports on the fly during undo/redo - final UndoManager undoManager = ProjectUndoManager.getInstance(project); - if (undoManager.isUndoInProgress() || undoManager.isRedoInProgress()) { - return; - } - PsiDocumentManager.getInstance(project).commitAllDocuments(); - String beforeText = file.getText(); - final long oldStamp = document.getModificationStamp(); - UndoUtil.writeInRunUndoTransparentAction(runnable); - if (oldStamp != document.getModificationStamp()) { - String afterText = file.getText(); - if (Comparing.strEqual(beforeText, afterText)) { - LOG.error( - "Import optimizer hasn't optimized any imports", - file.getViewProvider().getVirtualFile().getPath(), - AttachmentFactoryUtil.createAttachment(file - .getViewProvider() - .getVirtualFile())); - } - } - }); - } - - @Nonnull - @Override - public IntentionAction createAddMissingRequiredAnnotationParametersFix(@Nonnull final PsiAnnotation annotation, - @Nonnull final PsiMethod[] annotationMethods, - @Nonnull final Collection missedElements) { - return new AddMissingRequiredAnnotationParametersFix(annotation, annotationMethods, missedElements); - } - - @Nonnull - @Override - public IntentionAction createSurroundWithQuotesAnnotationParameterValueFix(@Nonnull PsiAnnotationMemberValue value, - @Nonnull PsiType expectedType) { - return new SurroundWithQuotesAnnotationParameterValueFix(value, expectedType); - } - - @Nonnull - @Override - public IntentionAction addMethodQualifierFix(@Nonnull PsiMethodCallExpression methodCall) { - return new AddMethodQualifierFix(methodCall); - } - - @Nonnull - @Override - public IntentionAction createWrapWithAdapterFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { - return new WrapLongWithMathToIntExactFix(type, expression); - } - - @Nonnull - @Override - public IntentionAction createWrapWithOptionalFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { - return WrapObjectWithOptionalOfNullableFix.createFix(type, expression); - } - - @Nullable - @Override - public IntentionAction createNotIterableForEachLoopFix(@Nonnull PsiExpression expression) { - final PsiElement parent = expression.getParent(); - if (parent instanceof PsiForeachStatement) { - final PsiType type = expression.getType(); - if (InheritanceUtil.isInheritor(type, JavaClassNames.JAVA_UTIL_ITERATOR)) { - return new ReplaceIteratorForEachLoopWithIteratorForLoopFix((PsiForeachStatement)parent); - } - } - return null; - } - - @Nonnull - @Override - public List createAddAnnotationAttributeNameFixes(@Nonnull PsiNameValuePair pair) { - return AddAnnotationAttributeNameFix.createFixes(pair); - } - - private static boolean timeToOptimizeImports(@Nonnull PsiFile file) { - if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) { - return false; - } - - Project project = file.getProject(); - DaemonCodeAnalyzer codeAnalyzer = DaemonCodeAnalyzer.getInstance(project); - // dont optimize out imports in JSP since it can be included in other JSP - if (!codeAnalyzer.isHighlightingAvailable(file) || !(file instanceof PsiJavaFile) || file instanceof ServerPageFile) { - return false; - } - - if (!codeAnalyzer.isErrorAnalyzingFinished(file)) { - return false; - } - boolean errors = containsErrorsPreventingOptimize(file); - - return !errors && AutoImportHelper.getInstance(project).canChangeFileSilently(file); - } - - private static boolean containsErrorsPreventingOptimize(@Nonnull PsiFile file) { - Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file); - if (document == null) { - return true; - } - // ignore unresolved imports errors - PsiImportList importList = ((PsiJavaFile)file).getImportList(); - final TextRange importsRange = importList == null ? TextRange.EMPTY_RANGE : importList.getTextRange(); - boolean hasErrorsExceptUnresolvedImports = - !DaemonCodeAnalyzer.processHighlights(document, file.getProject(), HighlightSeverity.ERROR, 0, document.getTextLength(), error -> - { - int infoStart = error.getActualStartOffset(); - int infoEnd = error.getActualEndOffset(); - - return importsRange.containsRange(infoStart, infoEnd) && error.getType().equals(HighlightInfoType.WRONG_REF); - }); - - return hasErrorsExceptUnresolvedImports; - } - - @Nonnull - @Override - public IntentionAction createCollectionToArrayFix(@Nonnull PsiExpression collectionExpression, @Nonnull PsiArrayType arrayType) { - return new ConvertCollectionToArrayFix(collectionExpression, arrayType); - } - - @Nonnull - @Override - public IntentionAction createInsertMethodCallFix(@Nonnull PsiMethodCallExpression call, PsiMethod method) { - return new InsertMethodCallFix(call, method); - } - - @Nonnull - @Override - public LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticViaInstanceFix(PsiReferenceExpression methodRef, - JavaResolveResult result) { - return new AccessStaticViaInstanceFix(methodRef, result, true); - } - - @Nonnull - @Override - public IntentionAction createWrapStringWithFileFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { - return new WrapStringWithFileFix(type, expression); - } - - @Nonnull - @Override - public IntentionAction createAddMissingEnumBranchesFix(@Nonnull PsiSwitchBlock switchBlock, @Nonnull Set missingCases) { - return new CreateMissingSwitchBranchesFix(switchBlock, missingCases); - } - - @Nonnull - @Override - public IntentionAction createAddSwitchDefaultFix(@Nonnull PsiSwitchBlock switchBlock, @Nullable String message) { - return new CreateDefaultBranchFix(switchBlock, message); - } - - @Nonnull - @Override - public IntentionAction createWrapSwitchRuleStatementsIntoBlockFix(PsiSwitchLabeledRuleStatement rule) { - return new WrapSwitchRuleStatementsIntoBlockFix(rule); - } - - @Nonnull - @Override - public IntentionAction createDeleteSideEffectAwareFix(@Nonnull PsiExpressionStatement statement) { - return new DeleteSideEffectsAwareFix(statement, statement.getExpression()); - } + private static final Logger LOG = Logger.getInstance(QuickFixFactoryImpl.class); + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( + @Nonnull PsiModifierList modifierList, + @Nonnull String modifier, + boolean shouldHave, + boolean showContainingClass + ) { + return new ModifierFix(modifierList, modifier, shouldHave, showContainingClass); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( + @Nonnull PsiModifierListOwner owner, + @Nonnull final String modifier, + final boolean shouldHave, + final boolean showContainingClass + ) { + return new ModifierFix(owner, modifier, shouldHave, showContainingClass); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix( + @Nonnull PsiMethod method, + @Nonnull PsiType toReturn, + boolean fixWholeHierarchy + ) { + return new MethodReturnTypeFix(method, toReturn, fixWholeHierarchy); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix(@Nonnull PsiMethod method, @Nonnull PsiClass toClass) { + return new AddMethodFix(method, toClass); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAddMethodFix( + @Nonnull String methodText, + @Nonnull PsiClass toClass, + @Nonnull String... exceptions + ) { + return new AddMethodFix(methodText, toClass, exceptions); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiClass aClass) { + return new ImplementMethodsFix(aClass); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createImplementMethodsFix(@Nonnull PsiElement psiElement) { + return new ImplementMethodsFix(psiElement); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAssignmentToComparisonFix(PsiAssignmentExpression expr) { + return new ReplaceAssignmentWithComparisonFix(expr); + } + + @Nonnull + @Override + public LocalQuickFixOnPsiElement createMethodThrowsFix( + @Nonnull PsiMethod method, + @Nonnull PsiClassType exceptionClass, + boolean shouldThrow, + boolean showContainingClass + ) { + return new MethodThrowsFix(method, exceptionClass, shouldThrow, showContainingClass); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFix(@Nonnull PsiClass aClass) { + return new AddDefaultConstructorFix(aClass); + } + + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix(@Nonnull PsiClass aClass, @Nonnull String modifier) { + return aClass.getName() != null ? new AddDefaultConstructorFix(aClass, modifier) : null; + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createMethodParameterTypeFix( + @Nonnull PsiMethod method, + int index, + @Nonnull PsiType newType, + boolean fixWholeHierarchy + ) { + return new MethodParameterFix(method, newType, index, fixWholeHierarchy); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass) { + return new MakeClassInterfaceFix(aClass, true); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createMakeClassInterfaceFix(@Nonnull PsiClass aClass, final boolean makeInterface) { + return new MakeClassInterfaceFix(aClass, makeInterface); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createExtendsListFix( + @Nonnull PsiClass aClass, + @Nonnull PsiClassType typeToExtendFrom, + boolean toAdd + ) { + return new ExtendsListFix(aClass, typeToExtendFrom, toAdd); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createRemoveUnusedParameterFix(@Nonnull PsiParameter parameter) { + return new RemoveUnusedParameterFix(parameter); + } + + @Nonnull + @Override + public IntentionAction createRemoveUnusedVariableFix(@Nonnull PsiVariable variable) { + return new RemoveUnusedVariableFix(variable); + } + + @Override + @Nullable + public IntentionAction createCreateClassOrPackageFix( + @Nonnull final PsiElement context, + @Nonnull final String qualifiedName, + final boolean createClass, + final String superClass + ) { + return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : null, superClass); + } + + @Override + @Nullable + public IntentionAction createCreateClassOrInterfaceFix( + @Nonnull final PsiElement context, + @Nonnull final String qualifiedName, + final boolean createClass, + final String superClass + ) { + return CreateClassOrPackageFix.createFix(qualifiedName, context, createClass ? ClassKind.CLASS : ClassKind.INTERFACE, superClass); + } + + @Nonnull + @Override + public IntentionAction createCreateFieldOrPropertyFix( + @Nonnull final PsiClass aClass, + @Nonnull final String name, + @Nonnull final PsiType type, + @Nonnull final PropertyMemberType targetMember, + @Nonnull final PsiAnnotation... annotations + ) { + return new CreateFieldOrPropertyFix(aClass, name, type, targetMember, annotations); + } + + @Nonnull + @Override + public IntentionAction createSetupJDKFix() { + return SetupJDKFix.getInstance(); + } + + @Nonnull + @Override + public IntentionAction createAddExceptionToCatchFix() { + return new AddExceptionToCatchFix(); + } + + @Nonnull + @Override + public IntentionAction createAddExceptionToThrowsFix(@Nonnull PsiElement element) { + return new AddExceptionToThrowsFix(element); + } + + @Nonnull + @Override + public IntentionAction createAddExceptionFromFieldInitializerToConstructorThrowsFix(@Nonnull PsiElement element) { + return new AddExceptionFromFieldInitializerToConstructorThrowsFix(element); + } + + @Nonnull + @Override + public IntentionAction createSurroundWithTryCatchFix(@Nonnull PsiElement element) { + return new SurroundWithTryCatchFix(element); + } + + @Nonnull + @Override + public IntentionAction createGeneralizeCatchFix(@Nonnull PsiElement element, @Nonnull PsiClassType type) { + return new GeneralizeCatchFix(element, type); + } + + @Nonnull + @Override + public IntentionAction createChangeToAppendFix( + @Nonnull IElementType sign, + @Nonnull PsiType type, + @Nonnull PsiAssignmentExpression assignment + ) { + return new ChangeToAppendFix(sign, type, assignment); + } + + @Nonnull + @Override + public IntentionAction createAddTypeCastFix(@Nonnull PsiType type, @Nonnull PsiExpression expression) { + return new AddTypeCastFix(type, expression); + } + + @Nonnull + @Override + public IntentionAction createWrapExpressionFix(@Nonnull PsiType type, @Nonnull PsiExpression expression) { + return new WrapExpressionFix(type, expression); + } + + @Nonnull + @Override + public IntentionAction createReuseVariableDeclarationFix(@Nonnull PsiLocalVariable variable) { + return new ReuseVariableDeclarationFix(variable); + } + + @Nonnull + @Override + public IntentionAction createConvertToStringLiteralAction() { + return new ConvertToStringLiteralAction(); + } + + @Nonnull + @Override + public IntentionAction createDeleteCatchFix(@Nonnull PsiParameter parameter) { + return new DeleteCatchFix(parameter); + } + + @Nonnull + @Override + public IntentionAction createDeleteMultiCatchFix(@Nonnull PsiTypeElement element) { + return new DeleteMultiCatchFix(element); + } + + @Nonnull + @Override + public IntentionAction createConvertSwitchToIfIntention(@Nonnull PsiSwitchStatement statement) { + return new ConvertSwitchToIfIntention(statement); + } + + @Nonnull + @Override + public IntentionAction createNegationBroadScopeFix(@Nonnull PsiPrefixExpression expr) { + return new NegationBroadScopeFix(expr); + } + + @Nonnull + @Override + public IntentionAction createCreateFieldFromUsageFix(@Nonnull PsiReferenceExpression place) { + return new CreateFieldFromUsageFix(place); + } + + @Nonnull + @Override + public IntentionAction createReplaceWithListAccessFix(@Nonnull PsiArrayAccessExpression expression) { + return new ReplaceWithListAccessFix(expression); + } + + @Nonnull + @Override + public IntentionAction createAddNewArrayExpressionFix(@Nonnull PsiArrayInitializerExpression expression) { + return new AddNewArrayExpressionFix(expression); + } + + @Nonnull + @Override + public IntentionAction createMoveCatchUpFix(@Nonnull PsiCatchSection section, @Nonnull PsiCatchSection section1) { + return new MoveCatchUpFix(section, section1); + } + + @Nonnull + @Override + public IntentionAction createRenameWrongRefFix(@Nonnull PsiReferenceExpression ref) { + return new RenameWrongRefFix(ref); + } + + @Nonnull + @Override + public IntentionAction createRemoveQualifierFix( + @Nonnull PsiExpression qualifier, + @Nonnull PsiReferenceExpression expression, + @Nonnull PsiClass resolved + ) { + return new RemoveQualifierFix(qualifier, expression, resolved); + } + + @Nonnull + @Override + public IntentionAction createRemoveParameterListFix(@Nonnull PsiMethod parent) { + return new RemoveParameterListFix(parent); + } + + @Nonnull + @Override + public IntentionAction createShowModulePropertiesFix(@Nonnull PsiElement element) { + return new ShowModulePropertiesFix(element); + } + + @Nonnull + @Override + public IntentionAction createShowModulePropertiesFix(@Nonnull Module module) { + return new ShowModulePropertiesFix(module); + } + + @Nonnull + @Override + public IntentionAction createIncreaseLanguageLevelFix(@Nonnull LanguageLevel level) { + return new IncreaseLanguageLevelFix(level); + } + + @Nonnull + @Override + public IntentionAction createChangeParameterClassFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type) { + return new ChangeParameterClassFix(aClass, type); + } + + @Nonnull + @Override + public IntentionAction createReplaceInaccessibleFieldWithGetterSetterFix( + @Nonnull PsiElement element, + @Nonnull PsiMethod getter, + boolean isSetter + ) { + return new ReplaceInaccessibleFieldWithGetterSetterFix(element, getter, isSetter); + } + + @Nonnull + @Override + public IntentionAction createSurroundWithArrayFix(@Nullable PsiCall methodCall, @Nullable PsiExpression expression) { + return new SurroundWithArrayFix(methodCall, expression); + } + + @Nonnull + @Override + public IntentionAction createImplementAbstractClassMethodsFix(@Nonnull PsiElement elementToHighlight) { + return new ImplementAbstractClassMethodsFix(elementToHighlight); + } + + @Nonnull + @Override + public IntentionAction createMoveClassToSeparateFileFix(@Nonnull PsiClass aClass) { + return new MoveClassToSeparateFileFix(aClass); + } + + @Nonnull + @Override + public IntentionAction createRenameFileFix(@Nonnull String newName) { + return new RenameFileFix(newName); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element) { + return new RenameElementFix(element); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createRenameElementFix(@Nonnull PsiNamedElement element, @Nonnull String newName) { + return new RenameElementFix(element, newName); + } + + @Nonnull + @Override + public IntentionAction createChangeExtendsToImplementsFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType classToExtendFrom) { + return new ChangeExtendsToImplementsFix(aClass, classToExtendFrom); + } + + @Nonnull + @Override + public IntentionAction createCreateConstructorMatchingSuperFix(@Nonnull PsiClass aClass) { + return new CreateConstructorMatchingSuperFix(aClass); + } + + @Nonnull + @Override + public IntentionAction createRemoveNewQualifierFix(@Nonnull PsiNewExpression expression, PsiClass aClass) { + return new RemoveNewQualifierFix(expression, aClass); + } + + @Nonnull + @Override + public IntentionAction createSuperMethodReturnFix(@Nonnull PsiMethod superMethod, @Nonnull PsiType superMethodType) { + return new SuperMethodReturnFix(superMethod, superMethodType); + } + + @Nonnull + @Override + public IntentionAction createInsertNewFix(@Nonnull PsiMethodCallExpression call, @Nonnull PsiClass aClass) { + return new InsertNewFix(call, aClass); + } + + @Nonnull + @Override + public IntentionAction createAddMethodBodyFix(@Nonnull PsiMethod method) { + return new AddMethodBodyFix(method); + } + + @Nonnull + @Override + public IntentionAction createDeleteMethodBodyFix(@Nonnull PsiMethod method) { + return new DeleteMethodBodyFix(method); + } + + @Nonnull + @Override + public IntentionAction createInsertSuperFix(@Nonnull PsiMethod constructor) { + return new InsertSuperFix(constructor); + } + + @Nonnull + @Override + public IntentionAction createInsertThisFix(@Nonnull PsiMethod constructor) { + return new InsertThisFix(constructor); + } + + @Nonnull + @Override + public IntentionAction createChangeMethodSignatureFromUsageFix( + @Nonnull PsiMethod targetMethod, + @Nonnull PsiExpression[] expressions, + @Nonnull PsiSubstitutor substitutor, + @Nonnull PsiElement context, + boolean changeAllUsages, + int minUsagesNumberToShowDialog + ) { + return new ChangeMethodSignatureFromUsageFix( + targetMethod, + expressions, + substitutor, + context, + changeAllUsages, + minUsagesNumberToShowDialog + ); + } + + @Nonnull + @Override + public IntentionAction createChangeMethodSignatureFromUsageReverseOrderFix( + @Nonnull PsiMethod targetMethod, + @Nonnull PsiExpression[] expressions, + @Nonnull PsiSubstitutor substitutor, + @Nonnull PsiElement context, + boolean changeAllUsages, + int minUsagesNumberToShowDialog + ) { + return new ChangeMethodSignatureFromUsageReverseOrderFix( + targetMethod, + expressions, + substitutor, + context, + changeAllUsages, + minUsagesNumberToShowDialog + ); + } + + @Nonnull + @Override + public IntentionAction createCreateMethodFromUsageFix(@Nonnull PsiMethodCallExpression call) { + return new CreateMethodFromUsageFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreateMethodFromUsageFix(PsiMethodReferenceExpression methodReferenceExpression) { + return new CreateMethodFromMethodReferenceFix(methodReferenceExpression); + } + + @Nonnull + @Override + public IntentionAction createCreateAbstractMethodFromUsageFix(@Nonnull PsiMethodCallExpression call) { + return new CreateAbstractMethodFromUsageFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreatePropertyFromUsageFix(@Nonnull PsiMethodCallExpression call) { + return new CreatePropertyFromUsageFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreateConstructorFromSuperFix(@Nonnull PsiMethodCallExpression call) { + return new CreateConstructorFromSuperFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreateConstructorFromThisFix(@Nonnull PsiMethodCallExpression call) { + return new CreateConstructorFromThisFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreateGetterSetterPropertyFromUsageFix(@Nonnull PsiMethodCallExpression call) { + return new CreateGetterSetterPropertyFromUsageFix(call); + } + + @Nonnull + @Override + public IntentionAction createStaticImportMethodFix(@Nonnull PsiMethodCallExpression call) { + return new StaticImportMethodFix(call); + } + + @Nonnull + @Override + public IntentionAction createReplaceAddAllArrayToCollectionFix(@Nonnull PsiMethodCallExpression call) { + return new ReplaceAddAllArrayToCollectionFix(call); + } + + @Nonnull + @Override + public IntentionAction createCreateConstructorFromCallFix(@Nonnull PsiConstructorCall call) { + return new CreateConstructorFromCallFix(call); + } + + @Nonnull + @Override + public List getVariableTypeFromCallFixes(@Nonnull PsiMethodCallExpression call, @Nonnull PsiExpressionList list) { + return VariableTypeFromCallFix.getQuickFixActions(call, list); + } + + @Nonnull + @Override + public IntentionAction createAddReturnFix(@Nonnull PsiMethod method) { + return new AddReturnFix(method); + } + + @Nonnull + @Override + public IntentionAction createAddVariableInitializerFix(@Nonnull PsiVariable variable) { + return new AddVariableInitializerFix(variable); + } + + @Nonnull + @Override + public IntentionAction createDeferFinalAssignmentFix(@Nonnull PsiVariable variable, @Nonnull PsiReferenceExpression expression) { + return new DeferFinalAssignmentFix(variable, expression); + } + + @Nonnull + @Override + public IntentionAction createVariableAccessFromInnerClassFix(@Nonnull PsiVariable variable, @Nonnull PsiElement scope) { + return new VariableAccessFromInnerClassFix(variable, scope); + } + + @Nonnull + @Override + public IntentionAction createCreateConstructorParameterFromFieldFix(@Nonnull PsiField field) { + return new CreateConstructorParameterFromFieldFix(field); + } + + @Nonnull + @Override + public IntentionAction createInitializeFinalFieldInConstructorFix(@Nonnull PsiField field) { + return new InitializeFinalFieldInConstructorFix(field); + } + + @Nonnull + @Override + public IntentionAction createRemoveTypeArgumentsFix(@Nonnull PsiElement variable) { + return new RemoveTypeArgumentsFix(variable); + } + + @Nonnull + @Override + public IntentionAction createChangeClassSignatureFromUsageFix( + @Nonnull PsiClass owner, + @Nonnull PsiReferenceParameterList parameterList + ) { + return new ChangeClassSignatureFromUsageFix(owner, parameterList); + } + + @Nonnull + @Override + public IntentionAction createReplacePrimitiveWithBoxedTypeAction( + @Nonnull PsiTypeElement element, + @Nonnull String typeName, + @Nonnull String boxedTypeName + ) { + return new ReplacePrimitiveWithBoxedTypeAction(element, typeName, boxedTypeName); + } + + @Nonnull + @Override + public IntentionAction createMakeVarargParameterLastFix(@Nonnull PsiParameter parameter) { + return new MakeVarargParameterLastFix(parameter); + } + + @Nonnull + @Override + public IntentionAction createMoveBoundClassToFrontFix(@Nonnull PsiClass aClass, @Nonnull PsiClassType type) { + return new MoveBoundClassToFrontFix(aClass, type); + } + + @Override + public void registerPullAsAbstractUpFixes(@Nonnull PsiMethod method, @Nonnull QuickFixActionRegistrar registrar) { + PullAsAbstractUpFix.registerQuickFix(method, registrar); + } + + @Nonnull + @Override + public IntentionAction createCreateAnnotationMethodFromUsageFix(@Nonnull PsiNameValuePair pair) { + return new CreateAnnotationMethodFromUsageFix(pair); + } + + @Nonnull + @Override + public IntentionAction createOptimizeImportsFix(final boolean onTheFly) { + final OptimizeImportsFix fix = new OptimizeImportsFix(); + + return new SyntheticIntentionAction() { + @Nonnull + @Override + public String getText() { + return fix.getText(); + } + + @Override + public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { + return (!onTheFly || timeToOptimizeImports(file)) && fix.isAvailable(project, editor, file); + } + + @Override + public void invoke(@Nonnull final Project project, final Editor editor, final PsiFile file) throws IncorrectOperationException { + invokeOnTheFlyImportOptimizer(() -> fix.invoke(project, editor, file), file); + } + + @Override + public boolean startInWriteAction() { + return fix.startInWriteAction(); + } + }; + } + + @Override + public void registerFixesForUnusedParameter(@Nonnull PsiParameter parameter, @Nonnull Object highlightInfo) { + Project myProject = parameter.getProject(); + InspectionProfile profile = InspectionProjectProfileManager.getInstance(myProject).getInspectionProfile(); + UnusedDeclarationInspectionBase unusedParametersInspection = + (UnusedDeclarationInspectionBase)profile.getUnwrappedTool(UnusedSymbolLocalInspectionBase.SHORT_NAME, parameter); + LOG.assertTrue(ApplicationManager.getApplication().isUnitTestMode() || unusedParametersInspection != null); + List options = new ArrayList<>(); + HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME); + options.addAll(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter)); + if (unusedParametersInspection != null) { + SuppressQuickFix[] batchSuppressActions = unusedParametersInspection.getBatchSuppressActions(parameter); + Collections.addAll(options, SuppressIntentionActionFromFix.convertBatchToSuppressIntentionActions(batchSuppressActions)); + } + //need suppress from Unused Parameters but settings from Unused Symbol + QuickFixAction.registerQuickFixAction( + (HighlightInfo)highlightInfo, + new SafeDeleteFix(parameter), + options, + HighlightDisplayKey.getDisplayNameByKey(myUnusedSymbolKey) + ); + } + + @Nonnull + @Override + public IntentionAction createAddToDependencyInjectionAnnotationsFix( + @Nonnull Project project, + @Nonnull String qualifiedName, + @Nonnull String element + ) { + final EntryPointsManagerBase entryPointsManager = EntryPointsManagerBase.getInstance(project); + return SpecialAnnotationsUtil.createAddToSpecialAnnotationsListIntentionAction( + JavaQuickFixBundle.message("fix.unused.symbol.injection.text", element, qualifiedName), + JavaQuickFixBundle.message("fix.unused.symbol.injection.family"), + entryPointsManager.ADDITIONAL_ANNOTATIONS, + qualifiedName + ); + } + + @Nonnull + @Override + public IntentionAction createAddToImplicitlyWrittenFieldsFix(Project project, @Nonnull final String qualifiedName) { + EntryPointsManagerBase entryPointsManagerBase = EntryPointsManagerBase.getInstance(project); + return entryPointsManagerBase.new AddImplicitlyWriteAnnotation(qualifiedName); + } + + @Nonnull + @Override + public IntentionAction createCreateGetterOrSetterFix(boolean createGetter, boolean createSetter, @Nonnull PsiField field) { + return new CreateGetterOrSetterFix(createGetter, createSetter, field); + } + + @Nonnull + @Override + public IntentionAction createRenameToIgnoredFix(@Nonnull PsiNamedElement namedElement) { + return new RenameToIgnoredFix(namedElement); + } + + @Nonnull + @Override + public IntentionAction createEnableOptimizeImportsOnTheFlyFix() { + return new EnableOptimizeImportsOnTheFlyFix(); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element) { + return new DeleteElementFix(element); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createDeleteFix(@Nonnull PsiElement element, @Nls @Nonnull String text) { + return new DeleteElementFix(element, text); + } + + @Nonnull + @Override + public IntentionAction createSafeDeleteFix(@Nonnull PsiElement element) { + return new SafeDeleteFix(element); + } + + @Nullable + @Override + public List registerOrderEntryFixes(@Nonnull PsiReference reference) { + return OrderEntryFix.registerFixes(reference); + } + + private static void invokeOnTheFlyImportOptimizer(@Nonnull final Runnable runnable, @Nonnull final PsiFile file) { + final Project project = file.getProject(); + final Document document = PsiDocumentManager.getInstance(project).getDocument(file); + if (document == null) { + return; + } + final long stamp = document.getModificationStamp(); + DumbService.getInstance(file.getProject()).smartInvokeLater(() -> + { + if (project.isDisposed() || document.getModificationStamp() != stamp) { + return; + } + //no need to optimize imports on the fly during undo/redo + final UndoManager undoManager = ProjectUndoManager.getInstance(project); + if (undoManager.isUndoInProgress() || undoManager.isRedoInProgress()) { + return; + } + PsiDocumentManager.getInstance(project).commitAllDocuments(); + String beforeText = file.getText(); + final long oldStamp = document.getModificationStamp(); + UndoUtil.writeInRunUndoTransparentAction(runnable); + if (oldStamp != document.getModificationStamp()) { + String afterText = file.getText(); + if (Comparing.strEqual(beforeText, afterText)) { + LOG.error( + "Import optimizer hasn't optimized any imports", + file.getViewProvider().getVirtualFile().getPath(), + AttachmentFactoryUtil.createAttachment(file.getViewProvider().getVirtualFile()) + ); + } + } + }); + } + + @Nonnull + @Override + public IntentionAction createAddMissingRequiredAnnotationParametersFix( + @Nonnull final PsiAnnotation annotation, + @Nonnull final PsiMethod[] annotationMethods, + @Nonnull final Collection missedElements + ) { + return new AddMissingRequiredAnnotationParametersFix(annotation, annotationMethods, missedElements); + } + + @Nonnull + @Override + public IntentionAction createSurroundWithQuotesAnnotationParameterValueFix( + @Nonnull PsiAnnotationMemberValue value, + @Nonnull PsiType expectedType + ) { + return new SurroundWithQuotesAnnotationParameterValueFix(value, expectedType); + } + + @Nonnull + @Override + public IntentionAction addMethodQualifierFix(@Nonnull PsiMethodCallExpression methodCall) { + return new AddMethodQualifierFix(methodCall); + } + + @Nonnull + @Override + public IntentionAction createWrapWithAdapterFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { + return new WrapLongWithMathToIntExactFix(type, expression); + } + + @Nonnull + @Override + public IntentionAction createWrapWithOptionalFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { + return WrapObjectWithOptionalOfNullableFix.createFix(type, expression); + } + + @Nullable + @Override + public IntentionAction createNotIterableForEachLoopFix(@Nonnull PsiExpression expression) { + final PsiElement parent = expression.getParent(); + if (parent instanceof PsiForeachStatement) { + final PsiType type = expression.getType(); + if (InheritanceUtil.isInheritor(type, JavaClassNames.JAVA_UTIL_ITERATOR)) { + return new ReplaceIteratorForEachLoopWithIteratorForLoopFix((PsiForeachStatement)parent); + } + } + return null; + } + + @Nonnull + @Override + public List createAddAnnotationAttributeNameFixes(@Nonnull PsiNameValuePair pair) { + return AddAnnotationAttributeNameFix.createFixes(pair); + } + + private static boolean timeToOptimizeImports(@Nonnull PsiFile file) { + if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) { + return false; + } + + Project project = file.getProject(); + DaemonCodeAnalyzer codeAnalyzer = DaemonCodeAnalyzer.getInstance(project); + // dont optimize out imports in JSP since it can be included in other JSP + if (!codeAnalyzer.isHighlightingAvailable(file) || !(file instanceof PsiJavaFile) || file instanceof ServerPageFile) { + return false; + } + + if (!codeAnalyzer.isErrorAnalyzingFinished(file)) { + return false; + } + boolean errors = containsErrorsPreventingOptimize(file); + + return !errors && AutoImportHelper.getInstance(project).canChangeFileSilently(file); + } + + private static boolean containsErrorsPreventingOptimize(@Nonnull PsiFile file) { + Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file); + if (document == null) { + return true; + } + // ignore unresolved imports errors + PsiImportList importList = ((PsiJavaFile)file).getImportList(); + final TextRange importsRange = importList == null ? TextRange.EMPTY_RANGE : importList.getTextRange(); + boolean hasErrorsExceptUnresolvedImports = + !DaemonCodeAnalyzer.processHighlights( + document, + file.getProject(), + HighlightSeverity.ERROR, + 0, + document.getTextLength(), + error -> { + int infoStart = error.getActualStartOffset(); + int infoEnd = error.getActualEndOffset(); + + return importsRange.containsRange(infoStart, infoEnd) && error.getType().equals(HighlightInfoType.WRONG_REF); + } + ); + + return hasErrorsExceptUnresolvedImports; + } + + @Nonnull + @Override + public IntentionAction createCollectionToArrayFix(@Nonnull PsiExpression collectionExpression, @Nonnull PsiArrayType arrayType) { + return new ConvertCollectionToArrayFix(collectionExpression, arrayType); + } + + @Nonnull + @Override + public IntentionAction createInsertMethodCallFix(@Nonnull PsiMethodCallExpression call, PsiMethod method) { + return new InsertMethodCallFix(call, method); + } + + @Nonnull + @Override + public LocalQuickFixAndIntentionActionOnPsiElement createAccessStaticViaInstanceFix( + PsiReferenceExpression methodRef, + JavaResolveResult result + ) { + return new AccessStaticViaInstanceFix(methodRef, result, true); + } + + @Nonnull + @Override + public IntentionAction createWrapStringWithFileFix(@Nullable PsiType type, @Nonnull PsiExpression expression) { + return new WrapStringWithFileFix(type, expression); + } + + @Nonnull + @Override + public IntentionAction createAddMissingEnumBranchesFix(@Nonnull PsiSwitchBlock switchBlock, @Nonnull Set missingCases) { + return new CreateMissingSwitchBranchesFix(switchBlock, missingCases); + } + + @Nonnull + @Override + public IntentionAction createAddSwitchDefaultFix(@Nonnull PsiSwitchBlock switchBlock, @Nullable String message) { + return new CreateDefaultBranchFix(switchBlock, message); + } + + @Nonnull + @Override + public IntentionAction createWrapSwitchRuleStatementsIntoBlockFix(PsiSwitchLabeledRuleStatement rule) { + return new WrapSwitchRuleStatementsIntoBlockFix(rule); + } + + @Nonnull + @Override + public IntentionAction createDeleteSideEffectAwareFix(@Nonnull PsiExpressionStatement statement) { + return new DeleteSideEffectsAwareFix(statement, statement.getExpression()); + } } From dc32be8dee6c6e5352204209a49376b7ecc857f5 Mon Sep 17 00:00:00 2001 From: UNV Date: Sun, 4 May 2025 19:07:29 +0300 Subject: [PATCH 2/3] Refactoring and localizing users of EP_NAME (part 8). --- .../intention/QuickFixFactory.java | 32 ++ .../impl/analysis/GenericsHighlightUtil.java | 22 +- .../impl/analysis/HighlightClassUtil.java | 231 ++++-------- .../analysis/HighlightControlFlowUtil.java | 282 +++++++-------- .../impl/analysis/HighlightMethodUtil.java | 200 +++++------ .../daemon/impl/analysis/HighlightUtil.java | 17 +- .../impl/analysis/HighlightVisitorImpl.java | 333 +++++++++--------- .../impl/analysis/ModuleHighlightUtil.java | 26 +- .../daemon/impl/analysis/RefCountHolder.java | 50 +-- .../daemon/impl/quickfix/ModifierFix.java | 24 +- .../impl/config/QuickFixFactoryImpl.java | 50 +-- 11 files changed, 564 insertions(+), 703 deletions(-) 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 f6e3a04cf9..b1e13a34f8 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 @@ -58,6 +58,22 @@ public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFi final boolean showContainingClass ); + @Nonnull + public LocalQuickFixAndIntentionActionOnPsiElement createAddModifierFix( + @Nonnull PsiModifierList modifierList, + @PsiModifier.ModifierConstant @Nonnull String modifier + ) { + return createModifierListFix(modifierList, modifier, true, false); + } + + @Nonnull + public LocalQuickFixAndIntentionActionOnPsiElement createRemoveModifierFix( + @Nonnull PsiModifierList modifierList, + @PsiModifier.ModifierConstant @Nonnull String modifier + ) { + return createModifierListFix(modifierList, modifier, false, false); + } + @Nonnull public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( @Nonnull PsiModifierListOwner owner, @@ -66,6 +82,22 @@ public abstract LocalQuickFixAndIntentionActionOnPsiElement createModifierListFi final boolean showContainingClass ); + @Nonnull + public LocalQuickFixAndIntentionActionOnPsiElement createAddModifierFix( + @Nonnull PsiModifierListOwner owner, + @PsiModifier.ModifierConstant @Nonnull String modifier + ) { + return createModifierListFix(owner, modifier, true, false); + } + + @Nonnull + public LocalQuickFixAndIntentionActionOnPsiElement createRemoveModifierFix( + @Nonnull PsiModifierListOwner owner, + @PsiModifier.ModifierConstant @Nonnull String modifier + ) { + return createModifierListFix(owner, modifier, false, false); + } + @Nonnull public abstract LocalQuickFixAndIntentionActionOnPsiElement createMethodReturnFix( @Nonnull PsiMethod method, 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 90f1e2326d..d2c77438b0 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 @@ -398,7 +398,7 @@ public static HighlightInfo checkElementInTypeParameterExtendsList( return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(element) .descriptionAndTooltip(JavaErrorLocalize.interfaceExpected()) - .registerFix(QuickFixFactory.getInstance().createMoveBoundClassToFrontFix(aClass, type), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createMoveBoundClassToFrontFix(aClass, type)) .create(); } else if (referenceElements.length != 0 && element != referenceElements[0] @@ -408,7 +408,7 @@ else if (referenceElements.length != 0 && element != referenceElements[0] return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(element) .descriptionAndTooltip(JavaErrorLocalize.typeParameterCannotBeFollowedByOtherBounds()) - .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, type, false), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, type, false)) .create(); } return null; @@ -598,7 +598,7 @@ public static HighlightInfo checkUnrelatedDefaultMethods(@Nonnull PsiClass aClas return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(classIdentifier) .descriptionAndTooltip(message) - .registerFix(QuickFixFactory.getInstance().createImplementMethodsFix(aClass), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createImplementMethodsFix(aClass)) .create(); } if (isInterface || abstracts == null || unrelatedMethodContainingClass.isInterface()) { @@ -623,7 +623,7 @@ public static HighlightInfo checkUnrelatedDefaultMethods(@Nonnull PsiClass aClas return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(classIdentifier) .descriptionAndTooltip(description) - .registerFix(QuickFixFactory.getInstance().createImplementMethodsFix(aClass), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createImplementMethodsFix(aClass)) .create(); } } @@ -992,7 +992,7 @@ public static HighlightInfo checkForeachExpressionTypeIsIterable(PsiExpression e return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) .descriptionAndTooltip(JavaErrorLocalize.foreachNotApplicable(JavaHighlightUtil.formatType(expression.getType()))) - .registerFix(QuickFixFactory.getInstance().createNotIterableForEachLoopFix(expression), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createNotIterableForEachLoopFix(expression)) .create(); } return null; @@ -1293,13 +1293,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), - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createIncreaseLanguageLevelFix(LanguageLevel.JDK_1_6)) .create(); } return null; @@ -1424,7 +1418,7 @@ public static HighlightInfo checkVarArgParameterIsLast(@Nonnull PsiParameter par return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(parameter) .descriptionAndTooltip(JavaErrorLocalize.varargNotLastParameter()) - .registerFix(QuickFixFactory.getInstance().createMakeVarargParameterLastFix(parameter), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createMakeVarargParameterLastFix(parameter)) .create(); } } @@ -1581,7 +1575,7 @@ public static HighlightInfo checkGenericCannotExtendException(PsiReferenceList l return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(referenceElement) .descriptionAndTooltip(JavaErrorLocalize.genericExtendException()) - .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, classType, false), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createExtendsListFix(aClass, classType, false)) .create(); } } 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 40f247e34f..9cd07e61e9 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 @@ -71,11 +71,13 @@ public static HighlightInfo checkAbstractInstantiation(@Nonnull PsiJavaCodeRefer } @Nullable + @RequiredReadAction private static HighlightInfo checkClassWithAbstractMethods(PsiClass aClass, TextRange range) { return checkClassWithAbstractMethods(aClass, aClass, range); } @Nullable + @RequiredReadAction public static HighlightInfo checkClassWithAbstractMethods( PsiClass aClass, PsiElement implementsFixElement, @@ -125,13 +127,14 @@ public static HighlightInfo checkClassWithAbstractMethods( && HighlightUtil.getIncompatibleModifier(PsiModifier.ABSTRACT, aClass.getModifierList()) == null) { QuickFixAction.registerQuickFixAction( errorResult, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.ABSTRACT, true, false) + QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.ABSTRACT) ); } return errorResult; } @Nullable + @RequiredReadAction public static HighlightInfo checkClassMustBeAbstract(PsiClass aClass, TextRange textRange) { if (aClass.isAbstract() || aClass.getRBrace() == null || aClass.isEnum() && hasEnumConstants(aClass)) { return null; @@ -142,30 +145,22 @@ public static HighlightInfo checkClassMustBeAbstract(PsiClass aClass, TextRange @Nullable @RequiredReadAction public static HighlightInfo checkInstantiationOfAbstractClass(PsiClass aClass, @Nonnull PsiElement highlightElement) { - HighlightInfo errorResult = null; if (aClass != null && aClass.isAbstract() && !(highlightElement instanceof PsiNewExpression newExpr && newExpr.getType() instanceof PsiArrayType)) { - String baseClassName = aClass.getName(); - errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(highlightElement) - .descriptionAndTooltip(JavaErrorLocalize.abstractCannotBeInstantiated(baseClassName)) - .create(); + .descriptionAndTooltip(JavaErrorLocalize.abstractCannotBeInstantiated(aClass.getName())); PsiMethod anyAbstractMethod = ClassUtil.getAnyAbstractMethod(aClass); if (!aClass.isInterface() && anyAbstractMethod == null) { // suggest to make not abstract only if possible - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.ABSTRACT, false, false) - ); + errorResult.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(aClass, PsiModifier.ABSTRACT)); } if (anyAbstractMethod != null && highlightElement instanceof PsiNewExpression newExpr && newExpr.getClassReference() != null) { - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createImplementAbstractClassMethodsFix(highlightElement) - ); + errorResult.registerFix(QuickFixFactory.getInstance().createImplementAbstractClassMethodsFix(highlightElement)); } + return errorResult.create(); } - return errorResult; + return null; } private static boolean hasEnumConstants(PsiClass aClass) { @@ -295,37 +290,25 @@ public static HighlightInfo checkPublicClassInRightFile(PsiClass aClass) { } TextRange range = HighlightNamesUtil.getClassDeclarationTextRange(aClass); PsiModifierList psiModifierList = aClass.getModifierList(); - HighlightInfo errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + QuickFixFactory factory = QuickFixFactory.getInstance(); + HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(aClass, range.getStartOffset(), range.getEndOffset()) .descriptionAndTooltip(JavaErrorLocalize.publicClassShouldBeNamedAfterFile(aClass.getName())) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(psiModifierList, PsiModifier.PUBLIC, false, false), - null, - null, - null, - null - ) - .create(); + .registerFix(factory.createRemoveModifierFix(psiModifierList, PsiModifier.PUBLIC)); PsiClass[] classes = file.getClasses(); if (classes.length > 1) { - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createMoveClassToSeparateFileFix(aClass) - ); + errorResult.registerFix(factory.createMoveClassToSeparateFileFix(aClass)); } for (PsiClass otherClass : classes) { if (!otherClass.getManager().areElementsEquivalent(otherClass, aClass) && otherClass.isPublic() && otherClass.getName().equals(virtualFile.getNameWithoutExtension())) { - return errorResult; + return errorResult.create(); } } - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createRenameFileFix(aClass.getName() + JavaFileType.DOT_DEFAULT_EXTENSION) - ); - QuickFixAction.registerQuickFixAction(errorResult, QuickFixFactory.getInstance().createRenameElementFix(aClass)); - return errorResult; + return errorResult.registerFix(factory.createRenameFileFix(aClass.getName() + JavaFileType.DOT_DEFAULT_EXTENSION)) + .registerFix(factory.createRenameElementFix(aClass)) + .create(); } @Nullable @@ -368,27 +351,17 @@ private static HighlightInfo checkStaticFieldDeclarationInInnerClass(@Nonnull Ps return null; } - HighlightInfo result = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder result = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(keyword) .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass()) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(field, PsiModifier.STATIC, false, false), - null, - null, - null, - null - ) - .create(); + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(field, PsiModifier.STATIC)); PsiClass aClass = field.getContainingClass(); if (aClass != null) { - QuickFixAction.registerQuickFixAction( - result, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.STATIC, true, false) - ); + result.registerFix(QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.STATIC)); } - return result; + return result.create(); } @Nullable @@ -408,26 +381,8 @@ private static HighlightInfo checkStaticMethodDeclarationInInnerClass(PsiKeyword return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(keyword) .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass()) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(method, PsiModifier.STATIC, false, false), - null, - null, - null, - null - ) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix( - (PsiClass)keyword.getParent().getParent().getParent(), - PsiModifier.STATIC, - true, - false - ) - , - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(method, PsiModifier.STATIC)) + .registerFix(QuickFixFactory.getInstance().createAddModifierFix((PsiClass)method.getParent(), PsiModifier.STATIC)) .create(); } @@ -445,20 +400,8 @@ private static HighlightInfo checkStaticInitializerDeclarationInInnerClass(PsiKe return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(keyword) .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass()) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(initializer, PsiModifier.STATIC, false, false), - null, - null, - null, - null - ) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(owner, PsiModifier.STATIC, true, false), - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(initializer, PsiModifier.STATIC)) + .registerFix(QuickFixFactory.getInstance().createAddModifierFix(owner, PsiModifier.STATIC)) .create(); } @@ -506,24 +449,18 @@ private static HighlightInfo checkStaticClassDeclarationInInnerClass(PsiKeyword TextRange range = context != null ? context.getTextRange() : HighlightNamesUtil.getClassDeclarationTextRange(aClass); - HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(range) - .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass()) - .create(); + .descriptionAndTooltip(JavaErrorLocalize.staticDeclarationInInnerClass()); + QuickFixFactory factory = QuickFixFactory.getInstance(); if (context != keyword) { - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.STATIC, false, false) - ); + info.registerFix(factory.createRemoveModifierFix(aClass, PsiModifier.STATIC)); } PsiClass containingClass = aClass.getContainingClass(); if (containingClass != null) { - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createModifierListFix(containingClass, PsiModifier.STATIC, true, false) - ); + info.registerFix(factory.createAddModifierFix(containingClass, PsiModifier.STATIC)); } - return info; + return info.create(); } @Nullable @@ -566,24 +503,17 @@ public static HighlightInfo checkExtendsAllowed(PsiReferenceList list) { @Nullable @RequiredReadAction public static HighlightInfo checkImplementsAllowed(PsiReferenceList list) { - if (list.getParent() instanceof PsiClass) { - PsiClass aClass = (PsiClass)list.getParent(); - if (aClass.isInterface()) { - boolean isImplements = list.equals(aClass.getImplementsList()); - if (isImplements) { - HighlightInfo result = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .range(list) - .descriptionAndTooltip(JavaErrorLocalize.implementsAfterInterface()) - .create(); - PsiClassType[] referencedTypes = list.getReferencedTypes(); - if (referencedTypes.length > 0) { - QuickFixAction.registerQuickFixAction( - result, - QuickFixFactory.getInstance().createChangeExtendsToImplementsFix(aClass, referencedTypes[0]) - ); - } - return result; + if (list.getParent() instanceof PsiClass aClass && aClass.isInterface()) { + boolean isImplements = list.equals(aClass.getImplementsList()); + if (isImplements) { + HighlightInfo.Builder result = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(list) + .descriptionAndTooltip(JavaErrorLocalize.implementsAfterInterface()); + PsiClassType[] referencedTypes = list.getReferencedTypes(); + if (referencedTypes.length > 0) { + result.registerFix(QuickFixFactory.getInstance().createChangeExtendsToImplementsFix(aClass, referencedTypes[0])); } + return result.create(); } } return null; @@ -612,7 +542,7 @@ public static HighlightInfo checkExtendsClassAndImplementsInterface( return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(ref) .descriptionAndTooltip(message) - .registerFix(QuickFixFactory.getInstance().createChangeExtendsToImplementsFix(aClass, type), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createChangeExtendsToImplementsFix(aClass, type)) .create(); } return null; @@ -625,13 +555,7 @@ public static HighlightInfo checkCannotInheritFromFinal(PsiClass superClass, Psi return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(elementToHighlight) .descriptionAndTooltip(JavaErrorLocalize.inheritanceFromFinalClass(superClass.getQualifiedName())) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(superClass, PsiModifier.FINAL, false, false), - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(superClass, PsiModifier.FINAL)) .create(); } return null; @@ -672,6 +596,7 @@ private static LocalizeValue checkDefaultConstructorThrowsException( } @Nullable + @RequiredReadAction public static HighlightInfo checkClassDoesNotCallSuperConstructorOrHandleExceptions( @Nonnull PsiClass aClass, RefCountHolder refCountHolder, @@ -689,6 +614,7 @@ public static HighlightInfo checkClassDoesNotCallSuperConstructorOrHandleExcepti return checkBaseClassDefaultConstructorProblem(aClass, refCountHolder, resolveHelper, textRange, PsiClassType.EMPTY_ARRAY); } + @RequiredReadAction public static HighlightInfo checkBaseClassDefaultConstructorProblem( @Nonnull PsiClass aClass, RefCountHolder refCountHolder, @@ -710,21 +636,15 @@ public static HighlightInfo checkBaseClassDefaultConstructorProblem( for (PsiMethod constructor : constructors) { if (resolveHelper.isAccessible(constructor, aClass, null)) { - if (constructor.getParameterList().getParametersCount() == 0 || constructor.getParameterList() - .getParametersCount() == 1 && constructor.isVarArgs()) { + int parametersCount = constructor.getParameterList().getParametersCount(); + if (parametersCount == 0 || parametersCount == 1 && constructor.isVarArgs()) { // it is an error if base ctr throws exceptions LocalizeValue description = checkDefaultConstructorThrowsException(constructor, handledExceptions); if (description != null) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(range) .descriptionAndTooltip(description) - .registerFix( - QuickFixFactory.getInstance().createCreateConstructorMatchingSuperFix(aClass), - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createCreateConstructorMatchingSuperFix(aClass)) .create(); } if (refCountHolder != null) { @@ -738,11 +658,12 @@ public static HighlightInfo checkBaseClassDefaultConstructorProblem( return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(range) .descriptionAndTooltip(JavaErrorLocalize.noDefaultConstructorAvailable(HighlightUtil.formatClass(baseClass))) - .registerFix(QuickFixFactory.getInstance().createCreateConstructorMatchingSuperFix(aClass), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createCreateConstructorMatchingSuperFix(aClass)) .create(); } @Nullable + @RequiredReadAction public static HighlightInfo checkInterfaceCannotBeLocal(PsiClass aClass) { if (PsiUtil.isLocalClass(aClass)) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) @@ -754,6 +675,7 @@ public static HighlightInfo checkInterfaceCannotBeLocal(PsiClass aClass) { } @Nullable + @RequiredReadAction public static HighlightInfo checkCyclicInheritance(PsiClass aClass) { PsiClass circularClass = getCircularClass(aClass, new HashSet<>()); if (circularClass != null) { @@ -903,38 +825,35 @@ public static HighlightInfo checkQualifiedNew(PsiNewExpression expression, PsiTy return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) .descriptionAndTooltip(JavaErrorLocalize.invalidQualifiedNew()) - .registerFix(QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, null), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, null)) .create(); } - HighlightInfo info = null; if (aClass != null) { + HighlightInfo.Builder info = null; if (aClass.isStatic()) { info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) - .descriptionAndTooltip(JavaErrorLocalize.qualifiedNewOfStaticClass()) - .create(); + .descriptionAndTooltip(JavaErrorLocalize.qualifiedNewOfStaticClass()); if (!aClass.isEnum()) { - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.STATIC, false, false) - ); + info.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(aClass, PsiModifier.STATIC)); } } - else if (aClass instanceof PsiAnonymousClass) { - PsiClass baseClass = PsiUtil.resolveClassInType(((PsiAnonymousClass)aClass).getBaseClassType()); + else if (aClass instanceof PsiAnonymousClass anonymousClass) { + PsiClass baseClass = PsiUtil.resolveClassInType(anonymousClass.getBaseClassType()); if (baseClass != null && baseClass.isInterface()) { info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) - .descriptionAndTooltip("Anonymous class implements interface; cannot have qualifier for " + "new") - .create(); + .descriptionAndTooltip(LocalizeValue.localizeTODO( + "Anonymous class implements interface; cannot have qualifier for new" + )); } } - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, aClass) - ); + if (info != null) { + info.registerFix(QuickFixFactory.getInstance().createRemoveNewQualifierFix(expression, aClass)); + } + return info != null ? info.create() : null; } - return info; + return null; } @@ -1188,26 +1107,16 @@ public static HighlightInfo reportIllegalEnclosingUsage( if (staticParent != null) { String element = outerClass == null ? "" : HighlightUtil.formatClass(outerClass) + "." + (place instanceof PsiSuperExpression ? PsiKeyword.SUPER : PsiKeyword.THIS); - HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(elementToHighlight) .descriptionAndTooltip(JavaErrorLocalize.cannotBeReferencedFromStaticContext(element)) // make context not static or referenced class static - .registerFix( - QuickFixFactory.getInstance().createModifierListFix(staticParent, PsiModifier.STATIC, false, false), - null, - null, - null, - null - ) - .create(); + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(staticParent, PsiModifier.STATIC)); if (aClass != null && HighlightUtil.getIncompatibleModifier(PsiModifier.STATIC, aClass.getModifierList()) == null) { - QuickFixAction.registerQuickFixAction( - highlightInfo, - QuickFixFactory.getInstance().createModifierListFix(aClass, PsiModifier.STATIC, true, false) - ); + highlightInfo.registerFix(QuickFixFactory.getInstance().createAddModifierFix(aClass, PsiModifier.STATIC)); } - return highlightInfo; + return highlightInfo.create(); } return null; } 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 6cb0082369..e7360444cc 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 @@ -72,19 +72,14 @@ public static HighlightInfo checkMissingReturnStatement(@Nullable PsiCodeBlock b ControlFlow controlFlow = getControlFlowNoConstantEvaluate(body); if (!ControlFlowUtil.returnPresent(controlFlow)) { PsiJavaToken rBrace = body.getRBrace(); - HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(rBrace == null ? body.getLastChild() : rBrace) - .descriptionAndTooltip(JavaErrorLocalize.missingReturnStatement()) - .create(); - PsiElement parent = body.getParent(); - if (parent instanceof PsiMethod method) { - QuickFixAction.registerQuickFixAction(info, QuickFixFactory.getInstance().createAddReturnFix(method)); - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createMethodReturnFix(method, PsiType.VOID, true) - ); + .descriptionAndTooltip(JavaErrorLocalize.missingReturnStatement()); + if (body.getParent() instanceof PsiMethod method) { + info.registerFix(QuickFixFactory.getInstance().createAddReturnFix(method)); + info.registerFix(QuickFixFactory.getInstance().createMethodReturnFix(method, PsiType.VOID, true)); } - return info; + return info.create(); } } catch (AnalysisCanceledException ignored) { @@ -130,7 +125,7 @@ public static HighlightInfo checkUnreachableStatement(@Nullable PsiCodeBlock cod .registerFix(QuickFixFactory.getInstance().createDeleteFix( unreachableStatement, JavaQuickFixBundle.message("delete.unreachable.statement.fix.text") - ), null, null, null, null) + )) .create(); } } @@ -144,15 +139,15 @@ public static boolean isFieldInitializedAfterObjectConstruction(@Nonnull PsiFiel if (field.hasInitializer()) { return true; } - final boolean isFieldStatic = field.isStatic(); - final PsiClass aClass = field.getContainingClass(); + boolean isFieldStatic = field.isStatic(); + PsiClass aClass = field.getContainingClass(); if (aClass != null) { // field might be assigned in the other field initializers if (isFieldInitializedInOtherFieldInitializer(aClass, field, isFieldStatic, __ -> true)) { return true; } } - final PsiClassInitializer[] initializers; + PsiClassInitializer[] initializers; if (aClass != null) { initializers = aClass.getInitializers(); } @@ -167,7 +162,7 @@ public static boolean isFieldInitializedAfterObjectConstruction(@Nonnull PsiFiel } else { // instance field should be initialized at the end of the each constructor - final PsiMethod[] constructors = aClass.getConstructors(); + PsiMethod[] constructors = aClass.getConstructors(); if (constructors.length == 0) { return false; @@ -178,9 +173,9 @@ public static boolean isFieldInitializedAfterObjectConstruction(@Nonnull PsiFiel if (ctrBody == null) { return false; } - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { - final PsiCodeBlock body = redirectedConstructor.getBody(); + PsiCodeBlock body = redirectedConstructor.getBody(); if (body != null && variableDefinitelyAssignedIn(field, body)) { continue nextConstructor; } @@ -197,7 +192,7 @@ public static boolean isFieldInitializedAfterObjectConstruction(@Nonnull PsiFiel private static boolean isFieldInitializedInOtherFieldInitializer( @Nonnull PsiClass aClass, @Nonnull PsiField field, - final boolean fieldStatic, + boolean fieldStatic, @Nonnull Predicate condition ) { PsiField[] fields = aClass.getFields(); @@ -213,7 +208,7 @@ && variableDefinitelyAssignedIn(field, psiField) } public static boolean isRecursivelyCalledConstructor(@Nonnull PsiMethod constructor) { - final JavaHighlightUtil.ConstructorVisitorInfo info = new JavaHighlightUtil.ConstructorVisitorInfo(); + JavaHighlightUtil.ConstructorVisitorInfo info = new JavaHighlightUtil.ConstructorVisitorInfo(); JavaHighlightUtil.visitConstructorChain(constructor, info); if (info.recursivelyCalledConstructor == null) { return false; @@ -282,31 +277,30 @@ public static HighlightInfo checkFinalFieldInitialized(@Nonnull PsiField field) return null; } - String description = JavaErrorLocalize.variableNotInitialized(field.getName()).get(); TextRange range = HighlightNamesUtil.getFieldDeclarationTextRange(field); - HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(range) - .descriptionAndTooltip(description) - .create(); - QuickFixAction.registerQuickFixAction( - highlightInfo, - HighlightMethodUtil.getFixRange(field), - QuickFixFactory.getInstance().createCreateConstructorParameterFromFieldFix(field) - ); - QuickFixAction.registerQuickFixAction( - highlightInfo, - HighlightMethodUtil.getFixRange(field), - QuickFixFactory.getInstance().createInitializeFinalFieldInConstructorFix(field) - ); - final PsiClass containingClass = field.getContainingClass(); - if (containingClass != null && !containingClass.isInterface()) { - QuickFixAction.registerQuickFixAction( - highlightInfo, - QuickFixFactory.getInstance().createModifierListFix(field, PsiModifier.FINAL, false, false) + .descriptionAndTooltip(JavaErrorLocalize.variableNotInitialized(field.getName())) + .registerFix( + QuickFixFactory.getInstance().createCreateConstructorParameterFromFieldFix(field), + null, + null, + HighlightMethodUtil.getFixRange(field), + null + ) + .registerFix( + QuickFixFactory.getInstance().createInitializeFinalFieldInConstructorFix(field), + null, + null, + HighlightMethodUtil.getFixRange(field), + null ); + PsiClass containingClass = field.getContainingClass(); + if (containingClass != null && !containingClass.isInterface()) { + highlightInfo.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(field, PsiModifier.FINAL)); } - QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance().createAddVariableInitializerFix(field)); - return highlightInfo; + return highlightInfo.registerFix(QuickFixFactory.getInstance().createAddVariableInitializerFix(field)) + .create(); } @RequiredReadAction @@ -366,15 +360,14 @@ public static HighlightInfo checkVariableInitializedBeforeUsage( if (topBlock == null) { return null; } - final PsiElement parent = topBlock.getParent(); + PsiElement parent = topBlock.getParent(); // access to final fields from inner classes always allowed if (inInnerClass(expression, field.getContainingClass())) { return null; } - final PsiCodeBlock block; - final PsiClass aClass; - if (parent instanceof PsiMethod) { - PsiMethod constructor = (PsiMethod)parent; + PsiCodeBlock block; + PsiClass aClass; + if (parent instanceof PsiMethod constructor) { if (!containingFile.getManager() .areElementsEquivalent(constructor.getContainingClass(), field.getContainingClass())) { return null; @@ -384,7 +377,7 @@ public static HighlightInfo checkVariableInitializedBeforeUsage( return null; } // as a last chance, field may be initialized in this() call - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { // variable must be initialized before its usage //??? @@ -400,11 +393,10 @@ public static HighlightInfo checkVariableInitializedBeforeUsage( block = constructor.getBody(); aClass = constructor.getContainingClass(); } - else if (parent instanceof PsiClassInitializer) { - final PsiClassInitializer classInitializer = (PsiClassInitializer)parent; + else if (parent instanceof PsiClassInitializer classInitializer) { if (!containingFile.getManager().areElementsEquivalent( classInitializer.getContainingClass(), - ((PsiField)variable).getContainingClass() + field.getContainingClass() )) { return null; } @@ -413,8 +405,8 @@ else if (parent instanceof PsiClassInitializer) { if (aClass == null || isFieldInitializedInOtherFieldInitializer( aClass, - (PsiField)variable, - variable.hasModifierProperty(PsiModifier.STATIC), + field, + field.isStatic(), field1 -> startOffset > field1.getTextOffset() )) { return null; @@ -424,7 +416,7 @@ else if (parent instanceof PsiClassInitializer) { // field reference outside code block // check variable initialized before its usage aClass = field.getContainingClass(); - final PsiField anotherField = PsiTreeUtil.getTopmostParentOfType(expression, PsiField.class); + PsiField anotherField = PsiTreeUtil.getTopmostParentOfType(expression, PsiField.class); if (aClass == null || isFieldInitializedInOtherFieldInitializer( aClass, @@ -449,7 +441,7 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers())) } block = null; // initializers will be checked later - final PsiMethod[] constructors = aClass.getConstructors(); + PsiMethod[] constructors = aClass.getConstructors(); for (PsiMethod constructor : constructors) { // variable must be initialized before its usage if (offset < constructor.getTextRange().getStartOffset()) { @@ -460,7 +452,7 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers())) return null; } // as a last chance, field may be initialized in this() call - final List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); + List redirectedConstructors = JavaHighlightUtil.getChainedConstructors(constructor); for (PsiMethod redirectedConstructor : redirectedConstructors) { // variable must be initialized before its usage if (offset < redirectedConstructor.getTextRange().getStartOffset()) { @@ -476,7 +468,7 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers())) if (aClass != null) { // field may be initialized in class initializer - final PsiClassInitializer[] initializers = aClass.getInitializers(); + PsiClassInitializer[] initializers = aClass.getInitializers(); for (PsiClassInitializer initializer : initializers) { PsiCodeBlock body = initializer.getBody(); if (body == block) { @@ -501,7 +493,7 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers())) Collection codeBlockProblems = uninitializedVarProblems.get(topBlock); if (codeBlockProblems == null) { try { - final ControlFlow controlFlow = getControlFlow(topBlock); + ControlFlow controlFlow = getControlFlow(topBlock); codeBlockProblems = ControlFlowUtil.getReadBeforeWriteLocals(controlFlow); } catch (AnalysisCanceledException | IndexNotReadyException e) { @@ -511,21 +503,17 @@ && isFieldInitializedInClassInitializer(field, true, aClass.getInitializers())) } if (codeBlockProblems.contains(expression)) { String name = expression.getElement().getText(); - HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) .descriptionAndTooltip(JavaErrorLocalize.variableNotInitialized(name)) - .registerFix(QuickFixFactory.getInstance().createAddVariableInitializerFix(variable), null, null, null, null) - .create(); + .registerFix(QuickFixFactory.getInstance().createAddVariableInitializerFix(variable)); if (variable instanceof PsiLocalVariable) { - //QuickFixAction.registerQuickFixAction(highlightInfo, HighlightFixUtil.createInsertSwitchDefaultFix(variable, topBlock, expression)); + //highlightInfo.registerFix(HighlightFixUtil.createInsertSwitchDefaultFix(variable, topBlock, expression)); } if (variable instanceof PsiField) { - QuickFixAction.registerQuickFixAction( - highlightInfo, - QuickFixFactory.getInstance().createModifierListFix(variable, PsiModifier.FINAL, false, false) - ); + highlightInfo.registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(variable, PsiModifier.FINAL)); } - return highlightInfo; + return highlightInfo.create(); } return null; @@ -544,17 +532,17 @@ private static boolean isFieldInitializedInClassInitializer( private static boolean inInnerClass(@Nonnull PsiElement psiElement, @Nullable PsiClass containingClass) { for (PsiElement element = psiElement; element != null; element = element.getParent()) { - if (element instanceof PsiClass) { - final boolean innerClass = !psiElement.getManager().areElementsEquivalent(element, containingClass); + if (element instanceof PsiClass psiClass) { + boolean innerClass = !psiElement.getManager().areElementsEquivalent(element, containingClass); if (innerClass) { - if (element instanceof PsiAnonymousClass) { - if (PsiTreeUtil.isAncestor(((PsiAnonymousClass)element).getArgumentList(), psiElement, false)) { + if (psiClass instanceof PsiAnonymousClass anonymousClass) { + if (PsiTreeUtil.isAncestor(anonymousClass.getArgumentList(), psiElement, false)) { continue; } - return !insideClassInitialization(containingClass, (PsiClass)element); + return !insideClassInitialization(containingClass, anonymousClass); } - final PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(psiElement, PsiLambdaExpression.class); - return lambdaExpression == null || !insideClassInitialization(containingClass, (PsiClass)element); + PsiLambdaExpression lambdaExpression = PsiTreeUtil.getParentOfType(psiElement, PsiLambdaExpression.class); + return lambdaExpression == null || !insideClassInitialization(containingClass, psiClass); } return false; } @@ -580,11 +568,11 @@ public static boolean isReassigned( @Nonnull Map> finalVarProblems ) { if (variable instanceof PsiLocalVariable) { - final PsiElement parent = variable.getParent(); + PsiElement parent = variable.getParent(); if (parent == null) { return false; } - final PsiElement declarationScope = parent.getParent(); + PsiElement declarationScope = parent.getParent(); if (declarationScope == null) { return false; } @@ -592,11 +580,7 @@ public static boolean isReassigned( getFinalVariableProblemsInBlock(finalVarProblems, declarationScope); return codeBlockProblems.contains(new ControlFlowUtil.VariableInfo(variable, null)); } - if (variable instanceof PsiParameter) { - final PsiParameter parameter = (PsiParameter)variable; - return isAssigned(parameter); - } - return false; + return variable instanceof PsiParameter parameter && isAssigned(parameter); } @@ -611,8 +595,8 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo( return null; } - final PsiElement scope = - variable instanceof PsiField ? variable.getParent() : variable.getParent() == null ? null : variable.getParent().getParent(); + PsiElement scope = variable instanceof PsiField ? variable.getParent() + : variable.getParent() == null ? null : variable.getParent().getParent(); PsiElement codeBlock = PsiUtil.getTopLevelEnclosingCodeBlock(expression, scope); if (codeBlock == null) { return null; @@ -628,16 +612,15 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo( } if (!alreadyAssigned) { - if (!(variable instanceof PsiField)) { + if (!(variable instanceof PsiField field)) { return null; } - final PsiField field = (PsiField)variable; - final PsiClass aClass = field.getContainingClass(); + PsiClass aClass = field.getContainingClass(); if (aClass == null) { return null; } // field can get assigned in other field initializers - final PsiField[] fields = aClass.getFields(); + PsiField[] fields = aClass.getFields(); boolean isFieldStatic = field.isStatic(); for (PsiField psiField : fields) { PsiExpression initializer = psiField.getInitializer(); @@ -652,20 +635,19 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo( if (!alreadyAssigned) { // field can get assigned in class initializers - final PsiMember enclosingConstructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); + PsiMember enclosingConstructorOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); if (enclosingConstructorOrInitializer == null || !aClass.getManager().areElementsEquivalent(enclosingConstructorOrInitializer.getContainingClass(), aClass)) { return null; } - final PsiClassInitializer[] initializers = aClass.getInitializers(); - for (PsiClassInitializer initializer : initializers) { + for (PsiClassInitializer initializer : aClass.getInitializers()) { if (initializer.isStatic() == field.isStatic()) { - final PsiCodeBlock body = initializer.getBody(); + PsiCodeBlock body = initializer.getBody(); if (body == codeBlock) { return null; } try { - final ControlFlow controlFlow = getControlFlow(body); + ControlFlow controlFlow = getControlFlow(body); if (!ControlFlowUtil.isVariableDefinitelyNotAssigned(field, controlFlow)) { alreadyAssigned = true; break; @@ -681,9 +663,10 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo( if (!alreadyAssigned && !field.isStatic()) { // then check if instance field already assigned in other constructor - final PsiMethod ctr = codeBlock.getParent() instanceof PsiMethod ? (PsiMethod)codeBlock.getParent() : null; - // assignment to final field in several constructors threatens us only if these are linked (there is this() call in the beginning) - final List redirectedConstructors = + PsiMethod ctr = codeBlock.getParent() instanceof PsiMethod method ? method : null; + // assignment to final field in several constructors threatens us only if these are linked + // (there is this() call in the beginning) + List redirectedConstructors = ctr != null && ctr.isConstructor() ? JavaHighlightUtil.getChainedConstructors(ctr) : null; for (int j = 0; redirectedConstructors != null && j < redirectedConstructors.size(); j++) { PsiMethod redirectedConstructor = redirectedConstructors.get(j); @@ -697,19 +680,13 @@ public static HighlightInfo checkFinalVariableMightAlreadyHaveBeenAssignedTo( } if (alreadyAssigned) { - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + QuickFixFactory factory = QuickFixFactory.getInstance(); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) .descriptionAndTooltip(JavaErrorLocalize.variableAlreadyAssigned(variable.getName())) + .registerFix(factory.createRemoveModifierFix(variable, PsiModifier.FINAL)) + .registerFix(factory.createDeferFinalAssignmentFix(variable, expression)) .create(); - QuickFixAction.registerQuickFixAction( - highlightInfo, - QuickFixFactory.getInstance().createModifierListFix(variable, PsiModifier.FINAL, false, false) - ); - QuickFixAction.registerQuickFixAction( - highlightInfo, - QuickFixFactory.getInstance().createDeferFinalAssignmentFix(variable, expression) - ); - return highlightInfo; } return null; @@ -723,7 +700,7 @@ private static Collection getFinalVariableProblems Collection codeBlockProblems = finalVarProblems.get(codeBlock); if (codeBlockProblems == null) { try { - final ControlFlow controlFlow = getControlFlowNoConstantEvaluate(codeBlock); + ControlFlow controlFlow = getControlFlowNoConstantEvaluate(codeBlock); codeBlockProblems = ControlFlowUtil.getInitializedTwice(controlFlow); } catch (AnalysisCanceledException e) { @@ -742,13 +719,11 @@ public static HighlightInfo checkFinalVariableInitializedInLoop( @Nonnull PsiElement resolved ) { if (ControlFlowUtil.isVariableAssignedInLoop(expression, resolved)) { - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) .descriptionAndTooltip(JavaErrorLocalize.variableAssignedInLoop(((PsiVariable)resolved).getName())) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix((PsiVariable)resolved, PsiModifier.FINAL)) .create(); - QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance() - .createModifierListFix((PsiVariable)resolved, PsiModifier.FINAL, false, false)); - return highlightInfo; } return null; } @@ -758,56 +733,50 @@ public static HighlightInfo checkFinalVariableInitializedInLoop( public static HighlightInfo checkCannotWriteToFinal(@Nonnull PsiExpression expression, @Nonnull PsiFile containingFile) { PsiReferenceExpression reference = null; boolean readBeforeWrite = false; - if (expression instanceof PsiAssignmentExpression) { - final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression)expression; - final PsiExpression left = PsiUtil.skipParenthesizedExprDown(assignmentExpression.getLExpression()); - if (left instanceof PsiReferenceExpression) { - reference = (PsiReferenceExpression)left; + if (expression instanceof PsiAssignmentExpression assignment) { + if (PsiUtil.skipParenthesizedExprDown(assignment.getLExpression()) instanceof PsiReferenceExpression lRefExpr) { + reference = lRefExpr; } - readBeforeWrite = assignmentExpression.getOperationTokenType() != JavaTokenType.EQ; + readBeforeWrite = assignment.getOperationTokenType() != JavaTokenType.EQ; } - else if (expression instanceof PsiPostfixExpression) { - final PsiExpression operand = PsiUtil.skipParenthesizedExprDown(((PsiPostfixExpression)expression).getOperand()); - final IElementType sign = ((PsiPostfixExpression)expression).getOperationTokenType(); - if (operand instanceof PsiReferenceExpression && (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) { - reference = (PsiReferenceExpression)operand; + else if (expression instanceof PsiPostfixExpression postfixExpr) { + IElementType sign = postfixExpr.getOperationTokenType(); + if (PsiUtil.skipParenthesizedExprDown(postfixExpr.getOperand()) instanceof PsiReferenceExpression operandRefExpr + && (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) { + reference = operandRefExpr; } readBeforeWrite = true; } - else if (expression instanceof PsiPrefixExpression) { - final PsiExpression operand = PsiUtil.skipParenthesizedExprDown(((PsiPrefixExpression)expression).getOperand()); - final IElementType sign = ((PsiPrefixExpression)expression).getOperationTokenType(); - if (operand instanceof PsiReferenceExpression && (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) { - reference = (PsiReferenceExpression)operand; + else if (expression instanceof PsiPrefixExpression prefixExpr) { + IElementType sign = prefixExpr.getOperationTokenType(); + if (PsiUtil.skipParenthesizedExprDown(prefixExpr.getOperand()) instanceof PsiReferenceExpression operandRefExpr + && (sign == JavaTokenType.PLUSPLUS || sign == JavaTokenType.MINUSMINUS)) { + reference = operandRefExpr; } readBeforeWrite = true; } - final PsiElement resolved = reference == null ? null : reference.resolve(); - PsiVariable variable = resolved instanceof PsiVariable ? (PsiVariable)resolved : null; + PsiElement resolved = reference == null ? null : reference.resolve(); + PsiVariable variable = resolved instanceof PsiVariable resolvedVar ? resolvedVar : null; if (variable == null || !variable.hasModifierProperty(PsiModifier.FINAL)) { return null; } - final boolean canWrite = - canWriteToFinal(variable, expression, reference, containingFile) && checkWriteToFinalInsideLambda(variable, reference) == null; + boolean canWrite = canWriteToFinal(variable, expression, reference, containingFile) + && checkWriteToFinalInsideLambda(variable, reference) == null; if (readBeforeWrite || !canWrite) { - final String name = variable.getName(); + String name = variable.getName(); LocalizeValue description = canWrite ? JavaErrorLocalize.variableNotInitialized(name) : JavaErrorLocalize.assignmentToFinalVariable(name); - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression); + 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) + ) .create(); - final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression); - if (innerClass == null || variable instanceof PsiField) { - QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance() - .createModifierListFix(variable, PsiModifier.FINAL, false, false)); - } - else { - QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance() - .createVariableAccessFromInnerClassFix(variable, innerClass)); - } - return highlightInfo; } return null; @@ -826,17 +795,16 @@ private static boolean canWriteToFinal( return false; } PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, expression); - if (variable instanceof PsiField) { + if (variable instanceof PsiField field) { // if inside some field initializer if (HighlightUtil.findEnclosingFieldInitializer(expression) != null) { return true; } // assignment from within inner class is illegal always - PsiField field = (PsiField)variable; if (innerClass != null && !containingFile.getManager().areElementsEquivalent(innerClass, field.getContainingClass())) { return false; } - final PsiMember enclosingCtrOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); + PsiMember enclosingCtrOrInitializer = PsiUtil.findEnclosingConstructorOrInitializer(expression); return enclosingCtrOrInitializer != null && isSameField(enclosingCtrOrInitializer, field, reference, containingFile); } if (variable instanceof PsiLocalVariable) { @@ -871,30 +839,26 @@ public static HighlightInfo checkVariableMustBeFinal( if (variable.hasModifierProperty(PsiModifier.FINAL)) { return null; } - final PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, context); + PsiElement innerClass = getInnerClassVariableReferencedFrom(variable, context); if (innerClass instanceof PsiClass) { - if (variable instanceof PsiParameter) { - final PsiElement parent = variable.getParent(); - if (parent instanceof PsiParameterList && parent.getParent() instanceof PsiLambdaExpression && - notAccessedForWriting(variable, new LocalSearchScope(((PsiParameter)variable).getDeclarationScope()))) { - return null; - } + if (variable instanceof PsiParameter param + && variable.getParent() instanceof PsiParameterList paramList + && paramList instanceof PsiLambdaExpression + && notAccessedForWriting(variable, new LocalSearchScope(param.getDeclarationScope()))) { + return null; } - final boolean isToBeEffectivelyFinal = languageLevel.isAtLeast(LanguageLevel.JDK_1_8); + boolean isToBeEffectivelyFinal = languageLevel.isAtLeast(LanguageLevel.JDK_1_8); if (isToBeEffectivelyFinal && isEffectivelyFinal(variable, innerClass, context)) { return null; } - final String description = isToBeEffectivelyFinal + String description = isToBeEffectivelyFinal ? JavaErrorBundle.message("variable.must.be.final.or.effectively.final", context.getText()) : JavaErrorLocalize.variableMustBeFinal(context.getText()).get(); - - final HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(context) .descriptionAndTooltip(description) + .registerFix(QuickFixFactory.getInstance().createVariableAccessFromInnerClassFix(variable, innerClass)) .create(); - QuickFixAction.registerQuickFixAction(highlightInfo, QuickFixFactory.getInstance() - .createVariableAccessFromInnerClassFix(variable, innerClass)); - return highlightInfo; } return checkWriteToFinalInsideLambda(variable, context); } @@ -914,7 +878,7 @@ private static HighlightInfo checkWriteToFinalInsideLambda( return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(context) .descriptionAndTooltip(JavaErrorLocalize.lambdaVariableMustBeFinal()) - .registerFix(QuickFixFactory.getInstance().createVariableAccessFromInnerClassFix(variable, lambdaExpression), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createVariableAccessFromInnerClassFix(variable, lambdaExpression)) .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 9f88815c66..5e68de8bd7 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 @@ -158,18 +158,7 @@ private static HighlightInfo isWeaker( VisibilityUtil.toPresentableText(accessModifier), PsiUtil.getAccessModifier(superAccessLevel) )) - .registerFix( - QuickFixFactory.getInstance().createModifierListFix( - method, - PsiUtil.getAccessModifier(superAccessLevel), - true, - false - ), - null, - null, - null, - null - ) + .registerFix(QuickFixFactory.getInstance().createAddModifierFix(method, PsiUtil.getAccessModifier(superAccessLevel))) .create(); } return null; @@ -287,26 +276,15 @@ private static HighlightInfo createIncompatibleReturnTypeMessage( @Nonnull TextRange textRange ) { String description = MessageFormat.format("{0}; {1}", createClashMethodMessage(method, superMethod, true), detailMessage); + QuickFixFactory factory = QuickFixFactory.getInstance(); HighlightInfo.Builder builder = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(textRange) .descriptionAndTooltip(description) - .registerFix( - QuickFixFactory.getInstance().createMethodReturnFix(method, substitutedSuperReturnType, false), - null, - null, - null, - null - ) - .registerFix(QuickFixFactory.getInstance().createSuperMethodReturnFix(superMethod, returnType), null, null, null, null); + .registerFix(factory.createMethodReturnFix(method, substitutedSuperReturnType, false)) + .registerFix(factory.createSuperMethodReturnFix(superMethod, returnType)); PsiClass returnClass = PsiUtil.resolveClassInClassTypeOnly(returnType); if (returnClass != null && substitutedSuperReturnType instanceof PsiClassType classType) { - builder.registerFix( - QuickFixFactory.getInstance().createChangeParameterClassFix(returnClass, classType), - null, - null, - null, - null - ); + builder.registerFix(factory.createChangeParameterClassFix(returnClass, classType)); } return builder.create(); @@ -327,6 +305,7 @@ public static HighlightInfo checkMethodOverridesFinal( return null; } + @RequiredReadAction private static HighlightInfo checkSuperMethodIsFinal(PsiMethod method, PsiMethod superMethod) { // strange things happen when super method is from Object and method from interface if (superMethod.isFinal()) { @@ -342,7 +321,7 @@ private static HighlightInfo checkSuperMethodIsFinal(PsiMethod method, PsiMethod PsiModifier.FINAL, false, true - ), null, null, null, null) + )) .create(); } return null; @@ -412,25 +391,22 @@ public static HighlightInfo checkMethodIncompatibleThrows( else { textRange = TextRange.EMPTY_RANGE; } + QuickFixFactory factory = QuickFixFactory.getInstance(); return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(textRange) .descriptionAndTooltip(description) - .registerFix(new LocalQuickFixOnPsiElementAsIntentionAdapter( - QuickFixFactory.getInstance().createMethodThrowsFix( - method, - exception, - false, - false - ) - ), null, null, null, null) - .registerFix(new LocalQuickFixOnPsiElementAsIntentionAdapter( - QuickFixFactory.getInstance().createMethodThrowsFix( - superMethod, - exception, - true, - true - ) - ), null, null, null, null) + .registerFix(new LocalQuickFixOnPsiElementAsIntentionAdapter(factory.createMethodThrowsFix( + method, + exception, + false, + false + ))) + .registerFix(new LocalQuickFixOnPsiElementAsIntentionAdapter(factory.createMethodThrowsFix( + superMethod, + exception, + true, + true + ))) .create(); } } @@ -900,10 +876,7 @@ else if (element != null && !resolveResult.isStaticsScopeCorrect()) { .range(elementToHighlight) .description(description.get()) .escapedToolTip(XmlStringUtil.escapeString(description.get())) - .registerFix(QuickFixFactory.getInstance().createAccessStaticViaInstanceFix( - referenceToMethod, - resolveResult - ), null, null, null, null) + .registerFix(QuickFixFactory.getInstance().createAccessStaticViaInstanceFix(referenceToMethod, resolveResult)) .create(); } } @@ -1085,7 +1058,7 @@ private static void registerMethodCallIntentions( && qualifierExpr.resolve() instanceof PsiClass psiClass && psiClass.getContainingClass() != null && !psiClass.isStatic()) { QuickFixAction.registerQuickFixAction( highlightInfo, - QuickFixFactory.getInstance().createModifierListFix(psiClass, PsiModifier.STATIC, true, false) + QuickFixFactory.getInstance().createAddModifierFix(psiClass, PsiModifier.STATIC) ); } @@ -1433,87 +1406,66 @@ private static boolean showShortType(int i, PsiParameter[] parameters, PsiExpres @RequiredReadAction public static HighlightInfo checkMethodMustHaveBody(PsiMethod method, PsiClass aClass) { - HighlightInfo errorResult = null; if (method.getBody() == null && !method.isAbstract() && !method.hasModifierProperty(PsiModifier.NATIVE) && aClass != null && !aClass.isInterface() && !PsiUtilCore.hasErrorElementChild(method)) { int start = method.getModifierList().getTextRange().getStartOffset(); int end = method.getTextRange().getEndOffset(); - errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + QuickFixFactory factory = QuickFixFactory.getInstance(); + HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(start, end) - .descriptionAndTooltip(JavaErrorLocalize.missingMethodBody()) - .create(); + .descriptionAndTooltip(JavaErrorLocalize.missingMethodBody()); if (HighlightUtil.getIncompatibleModifier(PsiModifier.ABSTRACT, method.getModifierList()) == null) { - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createModifierListFix( - method, - PsiModifier.ABSTRACT, - true, - false - ) - ); + errorResult.registerFix(factory.createAddModifierFix(method, PsiModifier.ABSTRACT)); } - QuickFixAction.registerQuickFixAction(errorResult, QuickFixFactory.getInstance().createAddMethodBodyFix(method)); + return errorResult.registerFix(factory.createAddMethodBodyFix(method)) + .create(); } - return errorResult; + return null; } @RequiredReadAction public static HighlightInfo checkAbstractMethodInConcreteClass(PsiMethod method, PsiElement elementToHighlight) { - HighlightInfo errorResult = null; PsiClass aClass = method.getContainingClass(); if (method.isAbstract() && aClass != null && !aClass.isAbstract() && !aClass.isEnum() && !PsiUtilCore.hasErrorElementChild(method)) { - errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + QuickFixFactory factory = QuickFixFactory.getInstance(); + HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(elementToHighlight) - .descriptionAndTooltip(JavaErrorLocalize.abstractMethodInNonAbstractClass()) - .create(); + .descriptionAndTooltip(JavaErrorLocalize.abstractMethodInNonAbstractClass()); if (method.getBody() != null) { - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createModifierListFix( - method, - PsiModifier.ABSTRACT, - false, - false - ) - ); + errorResult.registerFix(factory.createRemoveModifierFix(method, PsiModifier.ABSTRACT)); } - QuickFixAction.registerQuickFixAction(errorResult, QuickFixFactory.getInstance().createAddMethodBodyFix(method)); - QuickFixAction.registerQuickFixAction(errorResult, QuickFixFactory.getInstance() - .createModifierListFix(aClass, PsiModifier.ABSTRACT, true, false)); + return errorResult.registerFix(factory.createAddMethodBodyFix(method)) + .registerFix(factory.createAddModifierFix(aClass, PsiModifier.ABSTRACT)) + .create(); } - return errorResult; + return null; } @RequiredReadAction public static HighlightInfo checkConstructorName(PsiMethod method) { String methodName = method.getName(); PsiClass aClass = method.getContainingClass(); - HighlightInfo errorResult = null; if (aClass != null) { String className = aClass instanceof PsiAnonymousClass ? null : aClass.getName(); if (className == null || !Comparing.strEqual(methodName, className)) { - PsiElement element = method.getNameIdentifier(); - errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .range(element) - .descriptionAndTooltip(JavaErrorLocalize.missingReturnType()) - .create(); + HighlightInfo.Builder errorResult = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(method.getNameIdentifier()) + .descriptionAndTooltip(JavaErrorLocalize.missingReturnType()); if (className != null) { - QuickFixAction.registerQuickFixAction( - errorResult, - QuickFixFactory.getInstance().createRenameElementFix(method, className) - ); + errorResult.registerFix(QuickFixFactory.getInstance().createRenameElementFix(method, className)); } + return errorResult.create(); } } - return errorResult; + return null; } @Nullable + @RequiredReadAction public static HighlightInfo checkDuplicateMethod( PsiClass aClass, @Nonnull PsiMethod method, @@ -1546,6 +1498,7 @@ public static HighlightInfo checkDuplicateMethod( } @Nullable + @RequiredReadAction public static HighlightInfo checkMethodCanHaveBody(@Nonnull PsiMethod method, @Nonnull LanguageLevel languageLevel) { PsiClass aClass = method.getContainingClass(); boolean hasNoBody = method.getBody() == null; @@ -1555,11 +1508,12 @@ public static HighlightInfo checkMethodCanHaveBody(@Nonnull PsiMethod method, @N boolean isPrivate = method.isPrivate(); List additionalFixes = new ArrayList<>(); - LocalizeValue description = null; + LocalizeValue description; + QuickFixFactory factory = QuickFixFactory.getInstance(); if (hasNoBody) { if (isExtension) { description = JavaErrorLocalize.extensionMethodShouldHaveABody(); - additionalFixes.add(QuickFixFactory.getInstance().createAddMethodBodyFix(method)); + additionalFixes.add(factory.createAddMethodBodyFix(method)); } else if (isInterface) { if (isStatic && languageLevel.isAtLeast(LanguageLevel.JDK_1_8)) { @@ -1568,16 +1522,25 @@ else if (isInterface) { else if (isPrivate && languageLevel.isAtLeast(LanguageLevel.JDK_1_9)) { description = LocalizeValue.localizeTODO("Private methods in interfaces should have a body"); } + else { + return null; + } + } + else { + return null; } } else if (isInterface) { if (!isExtension && !isStatic && !isPrivate) { description = JavaErrorLocalize.interfaceMethodsCannotHaveBody(); if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)) { - additionalFixes.add(QuickFixFactory.getInstance().createModifierListFix(method, PsiModifier.DEFAULT, true, false)); - additionalFixes.add(QuickFixFactory.getInstance().createModifierListFix(method, PsiModifier.STATIC, true, false)); + additionalFixes.add(factory.createAddModifierFix(method, PsiModifier.DEFAULT)); + additionalFixes.add(factory.createAddModifierFix(method, PsiModifier.STATIC)); } } + else { + return null; + } } else if (isExtension) { description = JavaErrorLocalize.extensionMethodInClass(); @@ -1588,26 +1551,23 @@ else if (method.isAbstract()) { else if (method.hasModifierProperty(PsiModifier.NATIVE)) { description = JavaErrorLocalize.nativeMethodsCannotHaveABody(); } - if (description == null) { + else { return null; } - TextRange textRange = HighlightNamesUtil.getMethodDeclarationTextRange(method); - HighlightInfo info = - HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(textRange).descriptionAndTooltip(description).create(); + HighlightInfo.Builder info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(HighlightNamesUtil.getMethodDeclarationTextRange(method)) + .descriptionAndTooltip(description); if (!hasNoBody) { - QuickFixAction.registerQuickFixAction(info, QuickFixFactory.getInstance().createDeleteMethodBodyFix(method)); + info.registerFix(factory.createDeleteMethodBodyFix(method)); } if (method.isAbstract() && !isInterface) { - QuickFixAction.registerQuickFixAction( - info, - QuickFixFactory.getInstance().createModifierListFix(method, PsiModifier.ABSTRACT, false, false) - ); + info.registerFix(factory.createRemoveModifierFix(method, PsiModifier.ABSTRACT)); } for (IntentionAction intentionAction : additionalFixes) { - QuickFixAction.registerQuickFixAction(info, intentionAction); + info.registerFix(intentionAction); } - return info; + return info.create(); } @Nullable @@ -1966,6 +1926,7 @@ public static HighlightInfo checkOverrideEquivalentInheritedMethods( return null; } + @RequiredReadAction public static HighlightInfo checkConstructorHandleSuperClassExceptions(PsiMethod method) { if (!method.isConstructor()) { return null; @@ -1983,26 +1944,23 @@ public static HighlightInfo checkConstructorHandleSuperClassExceptions(PsiMethod return null; } TextRange textRange = HighlightNamesUtil.getMethodDeclarationTextRange(method); - HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + HighlightInfo.Builder highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(textRange) - .descriptionAndTooltip(HighlightUtil.getUnhandledExceptionsDescriptor(unhandled)) - .create(); + .descriptionAndTooltip(HighlightUtil.getUnhandledExceptionsDescriptor(unhandled)); for (PsiClassType exception : unhandled) { - QuickFixAction.registerQuickFixAction( - highlightInfo, - new LocalQuickFixOnPsiElementAsIntentionAdapter( - QuickFixFactory.getInstance().createMethodThrowsFix( - method, - exception, - true, - false - ) + highlightInfo.registerFix(new LocalQuickFixOnPsiElementAsIntentionAdapter( + QuickFixFactory.getInstance().createMethodThrowsFix( + method, + exception, + true, + false ) - ); + )); } - return highlightInfo; + return highlightInfo.create(); } + @RequiredReadAction public static HighlightInfo checkRecursiveConstructorInvocation(@Nonnull PsiMethod method) { if (!HighlightControlFlowUtil.isRecursivelyCalledConstructor(method)) { return null; 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 ad338c2893..80187491bd 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 @@ -1075,7 +1075,7 @@ public static HighlightInfo checkIllegalModifierCombination(@Nonnull PsiKeyword return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(keyword) .descriptionAndTooltip(JavaErrorLocalize.incompatibleModifiers(modifier, incompatible)) - .registerFix(QuickFixFactory.getInstance().createModifierListFix(modifierList, modifier, false, false)) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(modifierList, modifier)) .create(); } @@ -1219,7 +1219,7 @@ else if (modifierOwner instanceof PsiReceiverParameter) { return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(keyword) .descriptionAndTooltip(JavaErrorLocalize.modifierNotAllowed(modifier)) - .registerFix(QuickFixFactory.getInstance().createModifierListFix(modifierList, modifier, false, false)) + .registerFix(QuickFixFactory.getInstance().createRemoveModifierFix(modifierList, modifier)) .create(); } @@ -2186,15 +2186,11 @@ public static void registerStaticProblemQuickFixAction( HighlightInfo errorResult, @Nonnull PsiJavaCodeReferenceElement place ) { + QuickFixFactory factory = QuickFixFactory.getInstance(); if (refElement instanceof PsiModifierListOwner modifierListOwner) { QuickFixAction.registerQuickFixAction( errorResult, - QuickFixFactory.getInstance().createModifierListFix( - modifierListOwner, - PsiModifier.STATIC, - true, - false - ) + factory.createAddModifierFix(modifierListOwner, PsiModifier.STATIC) ); } // make context non static @@ -2202,14 +2198,13 @@ public static void registerStaticProblemQuickFixAction( if (staticParent != null && isInstanceReference(place)) { QuickFixAction.registerQuickFixAction( errorResult, - QuickFixFactory.getInstance() - .createModifierListFix(staticParent, PsiModifier.STATIC, false, false) + factory.createRemoveModifierFix(staticParent, PsiModifier.STATIC) ); } if (place instanceof PsiReferenceExpression placeRefExpr && refElement instanceof PsiField) { QuickFixAction.registerQuickFixAction( errorResult, - QuickFixFactory.getInstance().createCreateFieldFromUsageFix(placeRefExpr) + 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 6ec19bc244..e76e85c093 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 @@ -45,7 +45,6 @@ import consulo.java.language.module.util.JavaClassNames; import consulo.language.editor.DaemonCodeAnalyzer; import consulo.language.editor.Pass; -import consulo.language.editor.inspection.LocalQuickFixAndIntentionActionOnPsiElement; import consulo.language.editor.intention.QuickFixAction; import consulo.language.editor.rawHighlight.HighlightInfo; import consulo.language.editor.rawHighlight.HighlightInfoHolder; @@ -54,6 +53,7 @@ import consulo.language.inject.InjectedLanguageManager; import consulo.language.psi.*; import consulo.language.psi.util.PsiTreeUtil; +import consulo.localize.LocalizeValue; import consulo.project.Project; import consulo.util.collection.MostlySingularMultiMap; import consulo.util.collection.primitive.objects.ObjectIntMap; @@ -332,7 +332,7 @@ public void visitAnnotationMethod(PsiAnnotationMethod method) { } myHolder.add(AnnotationsHighlightUtil.checkValidAnnotationType(method.getReturnType(), method.getReturnTypeElement())); - final PsiClass aClass = method.getContainingClass(); + PsiClass aClass = method.getContainingClass(); myHolder.add(AnnotationsHighlightUtil.checkCyclicMemberType(method.getReturnTypeElement(), aClass)); myHolder.add(AnnotationsHighlightUtil.checkClashesWithSuperMethods(method)); @@ -382,7 +382,7 @@ public void visitPolyadicExpression(@Nonnull PsiPolyadicExpression expression) { @RequiredReadAction public void visitLambdaExpression(@Nonnull PsiLambdaExpression expression) { myHolder.add(checkFeature(expression, JavaFeature.LAMBDA_EXPRESSIONS)); - final PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent()); + PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent()); if (parent instanceof PsiExpressionStatement) { return; } @@ -397,7 +397,7 @@ public void visitLambdaExpression(@Nonnull PsiLambdaExpression expression) { if (!myHolder.hasErrorResults()) { functionalInterfaceType = expression.getFunctionalInterfaceType(); if (functionalInterfaceType != null) { - final String notFunctionalMessage = LambdaHighlightingUtil.checkInterfaceFunctional(functionalInterfaceType); + String notFunctionalMessage = LambdaHighlightingUtil.checkInterfaceFunctional(functionalInterfaceType); if (notFunctionalMessage != null) { myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) @@ -639,7 +639,8 @@ public void visitEnumConstantInitializer(PsiEnumConstantInitializer enumConstant } @Override - public void visitExpression(PsiExpression expression) { + @RequiredReadAction + public void visitExpression(@Nonnull PsiExpression expression) { ProgressManager.checkCanceled(); // visitLiteralExpression is invoked very often in array initializers super.visitExpression(expression); @@ -653,7 +654,9 @@ public void visitExpression(PsiExpression expression) { } PsiElement parent = expression.getParent(); - if (parent instanceof PsiNewExpression && ((PsiNewExpression)parent).getQualifier() != expression && ((PsiNewExpression)parent).getArrayInitializer() != expression) { + if (parent instanceof PsiNewExpression newExpr + && newExpr.getQualifier() != expression + && newExpr.getArrayInitializer() != expression) { // like in 'new String["s"]' myHolder.add(HighlightUtil.checkAssignability(PsiType.INT, expression.getType(), expression, expression)); } @@ -678,14 +681,14 @@ public void visitExpression(PsiExpression expression) { if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkConditionalExpressionBranchTypesMatch(expression, type)); } - if (!myHolder.hasErrorResults() && parent instanceof PsiThrowStatement && ((PsiThrowStatement)parent).getException() == expression) { + if (!myHolder.hasErrorResults() && parent instanceof PsiThrowStatement throwStmt && throwStmt.getException() == expression) { myHolder.add(HighlightUtil.checkMustBeThrowable(type, expression, true)); } if (!myHolder.hasErrorResults()) { myHolder.add(AnnotationsHighlightUtil.checkConstantExpression(expression)); } - if (!myHolder.hasErrorResults() && parent instanceof PsiForeachStatement && ((PsiForeachStatement)parent).getIteratedValue() == expression) { + if (!myHolder.hasErrorResults() && parent instanceof PsiForeachStatement forEach && forEach.getIteratedValue() == expression) { myHolder.add(GenericsHighlightUtil.checkForeachExpressionTypeIsIterable(expression)); } } @@ -749,7 +752,8 @@ public void visitForeachStatement(PsiForeachStatement statement) { } @Override - public void visitImportStaticStatement(PsiImportStaticStatement statement) { + @RequiredReadAction + public void visitImportStaticStatement(@Nonnull PsiImportStaticStatement statement) { myHolder.add(checkFeature(statement, JavaFeature.STATIC_IMPORTS)); if (!myHolder.hasErrorResults()) { myHolder.add(ImportsHighlightUtil.checkStaticOnDemandImportResolvesToClass(statement)); @@ -757,7 +761,8 @@ public void visitImportStaticStatement(PsiImportStaticStatement statement) { } @Override - public void visitIdentifier(final PsiIdentifier identifier) { + @RequiredReadAction + public void visitIdentifier(PsiIdentifier identifier) { TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); PsiElement parent = identifier.getParent(); @@ -766,7 +771,7 @@ public void visitIdentifier(final PsiIdentifier identifier) { myHolder.add(HighlightUtil.checkVariableAlreadyDefined(variable)); if (variable.getInitializer() == null) { - final PsiElement child = variable.getLastChild(); + PsiElement child = variable.getLastChild(); if (child instanceof PsiErrorElement && child.getPrevSibling() == identifier) { return; } @@ -785,8 +790,7 @@ else if (HighlightControlFlowUtil.isReassigned(variable, myFinalVarProblems)) { myHolder.add(HighlightNamesUtil.highlightVariableName(variable, identifier, colorsScheme)); } } - else if (parent instanceof PsiClass) { - PsiClass aClass = (PsiClass)parent; + else if (parent instanceof PsiClass aClass) { if (aClass.isAnnotationType()) { myHolder.add(checkFeature(identifier, JavaFeature.ANNOTATIONS)); } @@ -803,13 +807,12 @@ else if (parent instanceof PsiClass) { myHolder.add(GenericsHighlightUtil.checkUnrelatedConcrete(aClass, identifier)); } } - else if (parent instanceof PsiMethod) { - PsiMethod method = (PsiMethod)parent; + else if (parent instanceof PsiMethod method) { if (method.isConstructor()) { myHolder.add(HighlightMethodUtil.checkConstructorName(method)); } myHolder.add(HighlightNamesUtil.highlightMethodName(method, identifier, true, colorsScheme)); - final PsiClass aClass = method.getContainingClass(); + PsiClass aClass = method.getContainingClass(); if (aClass != null) { myHolder.add(GenericsHighlightUtil.checkDefaultMethodOverrideEquivalentToObjectNonPrivate( myLanguageLevel, @@ -826,55 +829,57 @@ else if (parent instanceof PsiMethod) { } @Override - public void visitImportStatement(final PsiImportStatement statement) { + @RequiredReadAction + public void visitImportStatement(@Nonnull PsiImportStatement statement) { if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkSingleImportClassConflict(statement, mySingleImportedClasses, myFile)); } } @Override + @RequiredReadAction public void visitImportStaticReferenceElement(@Nonnull PsiImportStaticReferenceElement ref) { - final String refName = ref.getReferenceName(); - final JavaResolveResult[] results = ref.multiResolve(false); + String refName = ref.getReferenceName(); + JavaResolveResult[] results = ref.multiResolve(false); - final PsiElement referenceNameElement = ref.getReferenceNameElement(); + PsiElement referenceNameElement = ref.getReferenceNameElement(); if (results.length == 0) { - final String description = JavaErrorBundle.message("cannot.resolve.symbol", refName); + LocalizeValue description = JavaErrorLocalize.cannotResolveSymbol(refName); assert referenceNameElement != null : ref; - final HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.WRONG_REF) + HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.WRONG_REF) .range(referenceNameElement) .descriptionAndTooltip(description) + .registerFix(QuickFixFactory.getInstance().createSetupJDKFix()) .create(); - QuickFixAction.registerQuickFixAction(info, QuickFixFactory.getInstance().createSetupJDKFix()); myHolder.add(info); } else { - final PsiManager manager = ref.getManager(); + PsiManager manager = ref.getManager(); for (JavaResolveResult result : results) { - final PsiElement element = result.getElement(); + PsiElement element = result.getElement(); String description = null; if (element instanceof PsiClass) { - final Pair imported = mySingleImportedClasses.get(refName); - final PsiClass aClass = imported == null ? null : imported.getSecond(); + Pair imported = mySingleImportedClasses.get(refName); + PsiClass aClass = imported == null ? null : imported.getSecond(); if (aClass != null && !manager.areElementsEquivalent(aClass, element)) { //noinspection ConditionalExpressionWithIdenticalBranches description = imported.first == null - ? JavaErrorBundle.message("single.import.class.conflict", refName) + ? JavaErrorLocalize.singleImportClassConflict(refName).get() : imported.first.equals(ref) - ? JavaErrorBundle.message("class.is.ambiguous.in.single.static.import", refName) - : JavaErrorBundle.message("class.is.already.defined.in.single.static.import", refName); + ? JavaErrorLocalize.classIsAmbiguousInSingleStaticImport(refName).get() + : JavaErrorLocalize.classIsAlreadyDefinedInSingleStaticImport(refName).get(); } mySingleImportedClasses.put(refName, Pair.create(ref, (PsiClass)element)); } else if (element instanceof PsiField) { - final Pair imported = mySingleImportedFields.get(refName); - final PsiField field = imported == null ? null : imported.getSecond(); + Pair imported = mySingleImportedFields.get(refName); + PsiField field = imported == null ? null : imported.getSecond(); if (field != null && !manager.areElementsEquivalent(field, element)) { //noinspection ConditionalExpressionWithIdenticalBranches description = imported.first.equals(ref) - ? JavaErrorBundle.message("field.is.ambiguous.in.single.static.import", refName) - : JavaErrorBundle.message("field.is.already.defined.in.single.static.import", refName); + ? JavaErrorLocalize.fieldIsAmbiguousInSingleStaticImport(refName).get() + : JavaErrorLocalize.fieldIsAlreadyDefinedInSingleStaticImport(refName).get(); } mySingleImportedFields.put(refName, Pair.create(ref, (PsiField)element)); } @@ -891,31 +896,27 @@ else if (element instanceof PsiField) { PsiElement resolved = results.length >= 1 ? results[0].getElement() : null; if (results.length > 1) { for (int i = 1; i < results.length; i++) { - final PsiElement element = results[i].getElement(); - if (resolved instanceof PsiMethod && !(element instanceof PsiMethod) || resolved instanceof PsiVariable && !(element instanceof PsiVariable) || resolved instanceof PsiClass && ! - (element instanceof PsiClass)) { + PsiElement element = results[i].getElement(); + if (resolved instanceof PsiMethod && !(element instanceof PsiMethod) + || resolved instanceof PsiVariable && !(element instanceof PsiVariable) + || resolved instanceof PsiClass && !(element instanceof PsiClass)) { resolved = null; break; } } } final TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); - if (resolved instanceof PsiClass) { - myHolder.add(HighlightNamesUtil.highlightClassName((PsiClass)resolved, ref, colorsScheme)); + if (resolved instanceof PsiClass psiClass) { + myHolder.add(HighlightNamesUtil.highlightClassName(psiClass, ref, colorsScheme)); } else { myHolder.add(HighlightNamesUtil.highlightClassNameInQualifier(ref, colorsScheme)); if (referenceNameElement != null) { - if (resolved instanceof PsiVariable) { - myHolder.add(HighlightNamesUtil.highlightVariableName((PsiVariable)resolved, referenceNameElement, colorsScheme)); + if (resolved instanceof PsiVariable variable) { + myHolder.add(HighlightNamesUtil.highlightVariableName(variable, referenceNameElement, colorsScheme)); } - else if (resolved instanceof PsiMethod) { - myHolder.add(HighlightNamesUtil.highlightMethodName( - (PsiMethod)resolved, - referenceNameElement, - false, - colorsScheme - )); + else if (resolved instanceof PsiMethod method) { + myHolder.add(HighlightNamesUtil.highlightMethodName(method, referenceNameElement, false, colorsScheme)); } } } @@ -923,7 +924,8 @@ else if (resolved instanceof PsiMethod) { } @Override - public void visitInstanceOfExpression(PsiInstanceOfExpression expression) { + @RequiredReadAction + public void visitInstanceOfExpression(@Nonnull PsiInstanceOfExpression expression) { super.visitInstanceOfExpression(expression); if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkInstanceOfApplicable(expression)); @@ -934,7 +936,8 @@ public void visitInstanceOfExpression(PsiInstanceOfExpression expression) { } @Override - public void visitKeyword(PsiKeyword keyword) { + @RequiredReadAction + public void visitKeyword(@Nonnull PsiKeyword keyword) { super.visitKeyword(keyword); PsiElement parent = keyword.getParent(); String text = keyword.getText(); @@ -966,7 +969,8 @@ else if (PsiKeyword.INTERFACE.equals(text) && parent instanceof PsiClass) { } @Override - public void visitLabeledStatement(PsiLabeledStatement statement) { + @RequiredReadAction + public void visitLabeledStatement(@Nonnull PsiLabeledStatement statement) { super.visitLabeledStatement(statement); if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkLabelWithoutStatement(statement)); @@ -977,7 +981,8 @@ public void visitLabeledStatement(PsiLabeledStatement statement) { } @Override - public void visitLiteralExpression(PsiLiteralExpression expression) { + @RequiredReadAction + public void visitLiteralExpression(@Nonnull PsiLiteralExpression expression) { super.visitLiteralExpression(expression); if (myHolder.hasErrorResults()) { return; @@ -989,9 +994,8 @@ public void visitLiteralExpression(PsiLiteralExpression expression) { if (myRefCountHolder != null && !myHolder.hasErrorResults()) { for (PsiReference reference : expression.getReferences()) { - PsiElement resolve = reference.resolve(); - if (resolve instanceof PsiMember) { - myRefCountHolder.registerReference(reference, new CandidateInfo(resolve, PsiSubstitutor.EMPTY)); + if (reference.resolve() instanceof PsiMember member) { + myRefCountHolder.registerReference(reference, new CandidateInfo(member, PsiSubstitutor.EMPTY)); } } } @@ -1219,7 +1223,8 @@ else if (parent instanceof PsiEnumConstant) { } @Override - public void visitNameValuePair(PsiNameValuePair pair) { + @RequiredReadAction + public void visitNameValuePair(@Nonnull PsiNameValuePair pair) { myHolder.add(AnnotationsHighlightUtil.checkNameValuePair(pair)); if (!myHolder.hasErrorResults()) { PsiIdentifier nameId = pair.getNameIdentifier(); @@ -1232,6 +1237,7 @@ public void visitNameValuePair(PsiNameValuePair pair) { } @Override + @RequiredReadAction public void visitNewExpression(PsiNewExpression expression) { final PsiType type = expression.getType(); final PsiClass aClass = PsiUtil.resolveClassInType(type); @@ -1274,7 +1280,8 @@ public void visitNewExpression(PsiNewExpression expression) { } @Override - public void visitPackageStatement(PsiPackageStatement statement) { + @RequiredReadAction + public void visitPackageStatement(@Nonnull PsiPackageStatement statement) { super.visitPackageStatement(statement); myHolder.add(AnnotationsHighlightUtil.checkPackageAnnotationContainingFile(statement, myFile)); if (myLanguageLevel.isAtLeast(LanguageLevel.JDK_1_9)) { @@ -1285,10 +1292,11 @@ public void visitPackageStatement(PsiPackageStatement statement) { } @Override - public void visitParameter(PsiParameter parameter) { + @RequiredReadAction + public void visitParameter(@Nonnull PsiParameter parameter) { super.visitParameter(parameter); - final PsiElement parent = parameter.getParent(); + PsiElement parent = parameter.getParent(); if (parent instanceof PsiParameterList && parameter.isVarArgs()) { if (!myHolder.hasErrorResults()) { myHolder.add(checkFeature(parameter, JavaFeature.VARARGS)); @@ -1319,7 +1327,8 @@ else if (parent instanceof PsiForeachStatement) { } @Override - public void visitParameterList(PsiParameterList list) { + @RequiredReadAction + public void visitParameterList(@Nonnull PsiParameterList list) { super.visitParameterList(list); if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkAnnotationMethodParameters(list)); @@ -1327,7 +1336,8 @@ public void visitParameterList(PsiParameterList list) { } @Override - public void visitPostfixExpression(PsiPostfixExpression expression) { + @RequiredReadAction + public void visitPostfixExpression(@Nonnull PsiPostfixExpression expression) { super.visitPostfixExpression(expression); if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkUnaryOperatorApplicable(expression.getOperationSign(), expression.getOperand())); @@ -1335,13 +1345,15 @@ public void visitPostfixExpression(PsiPostfixExpression expression) { } @Override - public void visitPrefixExpression(PsiPrefixExpression expression) { + @RequiredReadAction + public void visitPrefixExpression(@Nonnull PsiPrefixExpression expression) { super.visitPrefixExpression(expression); if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkUnaryOperatorApplicable(expression.getOperationSign(), expression.getOperand())); } } + @RequiredReadAction private void registerConstructorCall(@Nonnull PsiConstructorCall constructorCall) { if (myRefCountHolder != null) { if (constructorCall.resolveMethodGenerics().getElement() instanceof PsiNamedElement namedElem) { @@ -1385,7 +1397,7 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE if (!myHolder.hasErrorResults() && resolved instanceof PsiTypeParameter) { boolean canSelectFromTypeParameter = myJavaSdkVersion.isAtLeast(JavaSdkVersion.JDK_1_7); if (canSelectFromTypeParameter) { - final PsiClass containingClass = PsiTreeUtil.getParentOfType(ref, PsiClass.class); + PsiClass containingClass = PsiTreeUtil.getParentOfType(ref, PsiClass.class); if (containingClass != null) { if (PsiTreeUtil.isAncestor(containingClass.getExtendsList(), ref, false) || PsiTreeUtil.isAncestor(containingClass.getImplementsList(), ref, false)) { @@ -1395,7 +1407,7 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE } if (!canSelectFromTypeParameter) { myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .descriptionAndTooltip("Cannot select from a type parameter") + .descriptionAndTooltip(LocalizeValue.localizeTODO("Cannot select from a type parameter")) .range(ref) .create()); } @@ -1426,22 +1438,17 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE myHolder.add(GenericsHighlightUtil.checkCannotPassInner(ref)); } - if (resolved != null && parent instanceof PsiReferenceList) { - if (!myHolder.hasErrorResults()) { - PsiReferenceList referenceList = (PsiReferenceList)parent; - myHolder.add(HighlightUtil.checkElementInReferenceList(ref, referenceList, result)); - } + if (resolved != null && parent instanceof PsiReferenceList referenceList && !myHolder.hasErrorResults()) { + myHolder.add(HighlightUtil.checkElementInReferenceList(ref, referenceList, result)); } - if (parent instanceof PsiAnonymousClass && ref.equals(((PsiAnonymousClass)parent).getBaseClassReference()) - && myOverrideEquivalentMethodsVisitedClasses.add((PsiClass)parent)) { - PsiClass aClass = (PsiClass)parent; - myHolder.addAll(GenericsHighlightUtil.checkOverrideEquivalentMethods(aClass)); + if (parent instanceof PsiAnonymousClass anonymousClass + && ref.equals(anonymousClass.getBaseClassReference()) + && myOverrideEquivalentMethodsVisitedClasses.add(anonymousClass)) { + myHolder.addAll(GenericsHighlightUtil.checkOverrideEquivalentMethods(anonymousClass)); } - if (resolved instanceof PsiVariable) { - PsiVariable variable = (PsiVariable)resolved; - + if (resolved instanceof PsiVariable variable) { PsiElement containingClass = PsiTreeUtil.getNonStrictParentOfType(ref, PsiClass.class, PsiLambdaExpression.class); if ((containingClass instanceof PsiAnonymousClass || containingClass instanceof PsiLambdaExpression) && !PsiTreeUtil.isAncestor(containingClass, variable, false) @@ -1450,11 +1457,13 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE myHolder.add(HighlightInfo.newHighlightInfo(JavaHighlightInfoTypes.IMPLICIT_ANONYMOUS_CLASS_PARAMETER).range(ref).create()); } - if (variable instanceof PsiParameter && ref instanceof PsiExpression && PsiUtil.isAccessedForWriting((PsiExpression)ref)) { - myReassignedParameters.putInt((PsiParameter)variable, 2); + if (variable instanceof PsiParameter parameter + && ref instanceof PsiExpression + && PsiUtil.isAccessedForWriting((PsiExpression)ref)) { + myReassignedParameters.putInt(parameter, 2); } - final TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); + TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); if (!variable.hasModifierProperty(PsiModifier.FINAL) && isReassigned(variable)) { myHolder.add(HighlightNamesUtil.highlightReassignedVariable(variable, ref)); } @@ -1481,15 +1490,15 @@ private JavaResolveResult doVisitReferenceElement(@Nonnull PsiJavaCodeReferenceE } if (!myHolder.hasErrorResults() && resolved instanceof PsiClass psiClass) { - final PsiClass containingClass = psiClass.getContainingClass(); + PsiClass containingClass = psiClass.getContainingClass(); if (containingClass != null) { - final PsiElement qualifier = ref.getQualifier(); - final PsiElement place; + PsiElement qualifier = ref.getQualifier(); + PsiElement place; if (qualifier instanceof PsiJavaCodeReferenceElement javaCodeRef) { place = javaCodeRef.resolve(); } else if (parent instanceof PsiNewExpression newExpr) { - final PsiExpression newQualifier = newExpr.getQualifier(); + PsiExpression newQualifier = newExpr.getQualifier(); place = newQualifier == null ? ref : PsiUtil.resolveClassInType(newQualifier.getType()); } else { @@ -1500,7 +1509,7 @@ else if (parent instanceof PsiNewExpression newExpr) { } } else if (resolved instanceof PsiTypeParameter typeParam) { - final PsiTypeParameterListOwner owner = typeParam.getOwner(); + PsiTypeParameterListOwner owner = typeParam.getOwner(); if (owner instanceof PsiClass outerClass) { if (!InheritanceUtil.hasEnclosingInstanceInScope(outerClass, ref, false, false)) { myHolder.add(HighlightClassUtil.reportIllegalEnclosingUsage(ref, null, (PsiClass)owner, ref)); @@ -1568,12 +1577,12 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) JavaResolveResult result = results.length == 1 ? results[0] : JavaResolveResult.EMPTY; PsiElement resolved = result.getElement(); - if (resolved instanceof PsiVariable && resolved.getContainingFile() == expression.getContainingFile()) { + if (resolved instanceof PsiVariable variable && variable.getContainingFile() == expression.getContainingFile()) { if (!myHolder.hasErrorResults()) { try { myHolder.add(HighlightControlFlowUtil.checkVariableInitializedBeforeUsage( expression, - (PsiVariable)resolved, + variable, myUninitializedVarProblems, myFile )); @@ -1581,7 +1590,6 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) catch (IndexNotReadyException ignored) { } } - PsiVariable variable = (PsiVariable)resolved; boolean isFinal = variable.hasModifierProperty(PsiModifier.FINAL); if (isFinal && !variable.hasInitializer()) { if (!myHolder.hasErrorResults()) { @@ -1592,16 +1600,16 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) )); } if (!myHolder.hasErrorResults()) { - myHolder.add(HighlightControlFlowUtil.checkFinalVariableInitializedInLoop(expression, resolved)); + myHolder.add(HighlightControlFlowUtil.checkFinalVariableInitializedInLoop(expression, variable)); } } } - PsiElement parent = expression.getParent(); - if (parent instanceof PsiMethodCallExpression && ((PsiMethodCallExpression)parent).getMethodExpression() == expression && (!result.isAccessible() || !result.isStaticsScopeCorrect())) { - PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)parent; - PsiExpressionList list = methodCallExpression.getArgumentList(); - if (!HighlightMethodUtil.isDummyConstructorCall(methodCallExpression, myResolveHelper, list, expression)) { + if (expression.getParent() instanceof PsiMethodCallExpression methodCall + && methodCall.getMethodExpression() == expression + && (!result.isAccessible() || !result.isStaticsScopeCorrect())) { + PsiExpressionList list = methodCall.getArgumentList(); + if (!HighlightMethodUtil.isDummyConstructorCall(methodCall, myResolveHelper, list, expression)) { try { myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallIdentifier( expression, @@ -1609,13 +1617,13 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) list, resolved, result, - methodCallExpression, + methodCall, myResolveHelper, myLanguageLevel, myFile )); - if (!PsiTreeUtil.findChildrenOfType(methodCallExpression.getArgumentList(), PsiLambdaExpression.class).isEmpty()) { + if (!PsiTreeUtil.findChildrenOfType(methodCall.getArgumentList(), PsiLambdaExpression.class).isEmpty()) { PsiElement nameElement = expression.getReferenceNameElement(); if (nameElement != null) { myHolder.add(HighlightMethodUtil.checkAmbiguousMethodCallArguments( @@ -1624,7 +1632,7 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) list, resolved, result, - methodCallExpression, + methodCall, myResolveHelper, nameElement )); @@ -1640,9 +1648,9 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) myHolder.add(HighlightUtil.checkExpressionRequired(expression, resultForIncompleteCode)); } - if (!myHolder.hasErrorResults() && resolved instanceof PsiField) { + if (!myHolder.hasErrorResults() && resolved instanceof PsiField field) { try { - myHolder.add(HighlightUtil.checkIllegalForwardReferenceToField(expression, (PsiField)resolved)); + myHolder.add(HighlightUtil.checkIllegalForwardReferenceToField(expression, field)); } catch (IndexNotReadyException ignored) { } @@ -1653,14 +1661,14 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) if (!myHolder.hasErrorResults()) { myHolder.add(HighlightUtil.checkClassReferenceAfterQualifier(expression, resolved)); } - final PsiExpression qualifierExpression = expression.getQualifierExpression(); + PsiExpression qualifierExpression = expression.getQualifierExpression(); myHolder.add(HighlightUtil.checkUnqualifiedSuperInDefaultMethod(myLanguageLevel, expression, qualifierExpression)); if (!myHolder.hasErrorResults() && qualifierExpression != null) { PsiType type = qualifierExpression.getType(); - if (type instanceof PsiCapturedWildcardType) { - type = ((PsiCapturedWildcardType)type).getUpperBound(); + if (type instanceof PsiCapturedWildcardType capturedWildcardType) { + type = capturedWildcardType.getUpperBound(); } - final PsiClass psiClass = PsiUtil.resolveClassInType(type); + PsiClass psiClass = PsiUtil.resolveClassInType(type); if (psiClass != null) { myHolder.add(GenericsHighlightUtil.areSupersAccessible(psiClass, expression)); } @@ -1675,13 +1683,13 @@ public void visitReferenceExpression(@Nonnull PsiReferenceExpression expression) @RequiredReadAction public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression expression) { myHolder.add(checkFeature(expression, JavaFeature.METHOD_REFERENCES)); - final PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent()); + PsiElement parent = PsiUtil.skipParenthesizedExprUp(expression.getParent()); if (parent instanceof PsiExpressionStatement) { return; } - final JavaResolveResult result; - final JavaResolveResult[] results; + JavaResolveResult result; + JavaResolveResult[] results; try { results = expression.multiResolve(true); result = results.length == 1 ? results[0] : JavaResolveResult.EMPTY; @@ -1692,7 +1700,7 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression if (myRefCountHolder != null) { myRefCountHolder.registerReference(expression, result); } - final PsiElement method = result.getElement(); + PsiElement method = result.getElement(); if (method != null && !result.isAccessible()) { HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) @@ -1702,7 +1710,7 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression myHolder.add(info); } else { - final TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); + TextAttributesScheme colorsScheme = myHolder.getColorsScheme(); if (method instanceof PsiMethod method1 && !expression.isConstructor()) { PsiElement methodNameElement = expression.getReferenceNameElement(); if (methodNameElement != null) { @@ -1713,38 +1721,35 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression } if (!LambdaUtil.isValidLambdaContext(parent)) { - String description = "Method reference expression is not expected here"; myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) - .descriptionAndTooltip(description) + .descriptionAndTooltip(LocalizeValue.localizeTODO("Method reference expression is not expected here")) .create()); } - final PsiType functionalInterfaceType = expression.getFunctionalInterfaceType(); + PsiType functionalInterfaceType = expression.getFunctionalInterfaceType(); if (!myHolder.hasErrorResults()) { if (functionalInterfaceType != null) { - final boolean notFunctional = !LambdaUtil.isFunctionalType(functionalInterfaceType); + boolean notFunctional = !LambdaUtil.isFunctionalType(functionalInterfaceType); if (notFunctional) { - String description = functionalInterfaceType.getPresentableText() + " is not a functional interface"; myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) - .descriptionAndTooltip(description) + .descriptionAndTooltip(LocalizeValue.localizeTODO( + functionalInterfaceType.getPresentableText() + " is not a functional interface" + )) .create()); } } } if (!myHolder.hasErrorResults()) { - final PsiElement referenceNameElement = expression.getReferenceNameElement(); - if (referenceNameElement instanceof PsiKeyword) { - if (!PsiMethodReferenceUtil.isValidQualifier(expression)) { - PsiElement qualifier = expression.getQualifier(); - if (qualifier != null) { - String description = "Cannot find class " + qualifier.getText(); - myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .range(qualifier) - .descriptionAndTooltip(description) - .create()); - } + 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()); } } } @@ -1753,40 +1758,37 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression } if (!myHolder.hasErrorResults() && functionalInterfaceType != null) { - final String errorMessage = PsiMethodReferenceUtil.checkMethodReferenceContext(expression); + String errorMessage = PsiMethodReferenceUtil.checkMethodReferenceContext(expression); if (errorMessage != null) { - final HighlightInfo info = - HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(errorMessage).create(); + HighlightInfo.Builder info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(expression) + .descriptionAndTooltip(errorMessage); if (method instanceof PsiMethod method1 && !method1.isConstructor() && !method1.isAbstract()) { - final boolean shouldHave = !method1.isStatic(); - final LocalQuickFixAndIntentionActionOnPsiElement fixStaticModifier = - QuickFixFactory.getInstance().createModifierListFix( - (PsiModifierListOwner)method, - PsiModifier.STATIC, - shouldHave, false - ); - QuickFixAction.registerQuickFixAction(info, fixStaticModifier); + boolean shouldHave = !method1.isStatic(); + info.registerFix(QuickFixFactory.getInstance().createModifierListFix( + (PsiModifierListOwner)method, + PsiModifier.STATIC, + shouldHave, + false + )); } - myHolder.add(info); + myHolder.add(info.create()); } } - if (!myHolder.hasErrorResults()) { - PsiElement qualifier = expression.getQualifier(); - if (qualifier instanceof PsiTypeElement typeElem) { - final PsiType psiType = typeElem.getType(); - final HighlightInfo genericArrayCreationInfo = GenericsHighlightUtil.checkGenericArrayCreation(qualifier, psiType); - if (genericArrayCreationInfo != null) { - myHolder.add(genericArrayCreationInfo); - } - else { - final String wildcardMessage = PsiMethodReferenceUtil.checkTypeArguments((PsiTypeElement)qualifier, psiType); - if (wildcardMessage != null) { - myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .range(qualifier) - .descriptionAndTooltip(wildcardMessage) - .create()); - } + if (!myHolder.hasErrorResults() && expression.getQualifier() instanceof PsiTypeElement typeElem) { + PsiType psiType = typeElem.getType(); + HighlightInfo genericArrayCreationInfo = GenericsHighlightUtil.checkGenericArrayCreation(typeElem, psiType); + if (genericArrayCreationInfo != null) { + myHolder.add(genericArrayCreationInfo); + } + else { + String wildcardMessage = PsiMethodReferenceUtil.checkTypeArguments(typeElem, psiType); + if (wildcardMessage != null) { + myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(typeElem) + .descriptionAndTooltip(wildcardMessage) + .create()); } } } @@ -1800,7 +1802,7 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression } if (!myHolder.hasErrorResults()) { - final String badReturnTypeMessage = PsiMethodReferenceUtil.checkReturnType(expression, result, functionalInterfaceType); + String badReturnTypeMessage = PsiMethodReferenceUtil.checkReturnType(expression, result, functionalInterfaceType); if (badReturnTypeMessage != null) { myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(expression) @@ -1819,12 +1821,11 @@ public void visitMethodReferenceExpression(@Nonnull PsiMethodReferenceExpression if (expression.isConstructor()) { PsiClass containingClass = PsiMethodReferenceUtil.getQualifierResolveResult(expression).getContainingClass(); - if (containingClass != null) { - if (!myHolder.add(HighlightClassUtil.checkInstantiationOfAbstractClass(containingClass, expression)) - && !myHolder.add(GenericsHighlightUtil.checkEnumInstantiation(expression, containingClass)) - && containingClass.isPhysical() && description == null) { - description = JavaErrorLocalize.cannotResolveConstructor(containingClass.getName()).get(); - } + if (containingClass != null + && !myHolder.add(HighlightClassUtil.checkInstantiationOfAbstractClass(containingClass, expression)) + && !myHolder.add(GenericsHighlightUtil.checkEnumInstantiation(expression, containingClass)) + && containingClass.isPhysical() && description == null) { + description = JavaErrorLocalize.cannotResolveConstructor(containingClass.getName()).get(); } } else if (description == null) { @@ -1856,13 +1857,15 @@ else if (description == null) { @RequiredReadAction private void checkFunctionalInterfaceTypeAccessible(@Nonnull PsiFunctionalExpression expression, PsiType functionalInterfaceType) { PsiClassType.ClassResolveResult resolveResult = PsiUtil.resolveGenericsClassInType(functionalInterfaceType); - final PsiClass psiClass = resolveResult.getElement(); + PsiClass psiClass = resolveResult.getElement(); if (psiClass != null) { if (!PsiUtil.isAccessible(myFile.getProject(), psiClass, expression, null)) { - myHolder.add(HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) - .range(expression) - .descriptionAndTooltip(HighlightUtil.buildProblemWithAccessDescription(expression, resolveResult)) - .create()); + myHolder.add( + HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) + .range(expression) + .descriptionAndTooltip(HighlightUtil.buildProblemWithAccessDescription(expression, resolveResult)) + .create() + ); } else { for (PsiType type : resolveResult.getSubstitutor().getSubstitutionMap().values()) { @@ -2014,7 +2017,7 @@ public void visitThrowStatement(@Nonnull PsiThrowStatement statement) { public void visitTryStatement(@Nonnull PsiTryStatement statement) { super.visitTryStatement(statement); if (!myHolder.hasErrorResults()) { - final Set thrownTypes = HighlightUtil.collectUnhandledExceptions(statement); + Set thrownTypes = HighlightUtil.collectUnhandledExceptions(statement); for (PsiParameter parameter : statement.getCatchBlockParameters()) { boolean added = myHolder.addAll(HighlightUtil.checkExceptionAlreadyCaught(parameter)); if (!added) { 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 ba63a015da..00b975f5fb 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 @@ -81,7 +81,7 @@ public static HighlightInfo checkPackageStatement( return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(statement) .descriptionAndTooltip(JavaErrorLocalize.moduleNoPackage()) - .registerFix(factory().createDeleteFix(statement), null, null, null, null) + .registerFix(factory().createDeleteFix(statement)) .create(); } @@ -108,7 +108,7 @@ public static HighlightInfo checkFileName(@Nonnull PsiJavaModule element, @Nonnu return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(range(element)) .descriptionAndTooltip(JavaErrorLocalize.moduleFileWrongName()) - .registerFix(factory().createRenameFileFix(MODULE_INFO_FILE), null, null, null, null) + .registerFix(factory().createRenameFileFix(MODULE_INFO_FILE)) .create(); } @@ -200,8 +200,8 @@ private static void checkDuplicateRefs( HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(statement) .descriptionAndTooltip(descriptionTemplate.apply(refText)) - .registerFix(factory().createDeleteFix(statement), null, null, null, null) - .registerFix(MergeModuleStatementsFix.createFix(statement), null, null, null, null) + .registerFix(factory().createDeleteFix(statement)) + .registerFix(MergeModuleStatementsFix.createFix(statement)) .create(); results.add(info); } @@ -256,7 +256,7 @@ public static HighlightInfo checkFileLocation(@Nonnull PsiJavaModule element, @N return HighlightInfo.newHighlightInfo(HighlightInfoType.WARNING) .range(range(element)) .descriptionAndTooltip(JavaErrorLocalize.moduleFileWrongLocation()) - .registerFix(new MoveFileFix(vFile, root, JavaQuickFixLocalize.moveFileToSourceRootText().get()), null, null, null, null) + .registerFix(new MoveFileFix(vFile, root, JavaQuickFixLocalize.moveFileToSourceRootText().get())) .create(); } } @@ -306,8 +306,8 @@ public static HighlightInfo checkHostModuleStrength(@Nonnull PsiPackageAccessibi return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(statement) .descriptionAndTooltip(JavaErrorLocalize.moduleOpensInWeakModule()) - .registerFix(factory().createModifierListFix(javaModule, PsiModifier.OPEN, false, false), null, null, null, null) - .registerFix(factory().createDeleteFix(statement), null, null, null, null) + .registerFix(factory().createRemoveModifierFix(javaModule, PsiModifier.OPEN)) + .registerFix(factory().createDeleteFix(statement)) .create(); } @@ -361,13 +361,7 @@ public static List checkPackageAccessTargets(@Nonnull PsiPackageA HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(refElement) .descriptionAndTooltip(message) - .registerFix( - factory().createDeleteFix(refElement, JavaQuickFixLocalize.deleteReferenceFixText().get()), - null, - null, - null, - null - ) + .registerFix(factory().createDeleteFix(refElement, JavaQuickFixLocalize.deleteReferenceFixText().get())) .create(); results.add(info); } @@ -423,7 +417,7 @@ public static List checkServiceImplementations(@Nonnull PsiProvid HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR) .range(implRef) .descriptionAndTooltip(JavaErrorLocalize.moduleDuplicateImpl(refText)) - .registerFix(factory().createDeleteFix(implRef, JavaQuickFixLocalize.deleteReferenceFixText().get()), null, null, null, null) + .registerFix(factory().createDeleteFix(implRef, JavaQuickFixLocalize.deleteReferenceFixText().get())) .create(); results.add(info); continue; @@ -552,7 +546,7 @@ private static HighlightInfo checkPackageAccessibility( return HighlightInfo.newHighlightInfo(HighlightInfoType.WRONG_REF) .range(ref) .descriptionAndTooltip(JavaErrorLocalize.moduleNotInRequirements(refModuleName, requiredName)) - .registerFix(new AddRequiredModuleFix(refModule, requiredName), null, null, null, null) + .registerFix(new AddRequiredModuleFix(refModule, requiredName)) .create(); } } diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java index ace92e04f2..9b28345d03 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java @@ -49,6 +49,7 @@ final class RefCountHolder { private static final Key> REF_COUNT_HOLDER_IN_FILE_KEY = Key.create("REF_COUNT_HOLDER_IN_FILE_KEY"); private volatile boolean ready; // true when analysis completed and inner maps can be queried + @RequiredReadAction static RefCountHolder get(@Nonnull PsiFile file, @Nonnull TextRange dirtyScope) { Reference ref = file.getUserData(REF_COUNT_HOLDER_IN_FILE_KEY); RefCountHolder storedHolder = consulo.util.lang.ref.SoftReference.dereference(ref); @@ -59,11 +60,11 @@ static RefCountHolder get(@Nonnull PsiFile file, @Nonnull TextRange dirtyScope) } return storedHolder == null || wholeFile ? new RefCountHolder( - file, - MultiMap.createConcurrentSet(), - Sets.newConcurrentHashSet(HashingStrategy.canonical()), - new ConcurrentHashMap<>() - ) + file, + MultiMap.createConcurrentSet(), + Sets.newConcurrentHashSet(HashingStrategy.canonical()), + new ConcurrentHashMap<>() + ) : storedHolder.removeInvalidRefs(); } @@ -128,6 +129,7 @@ public boolean shouldCheckUsages(@Nonnull PsiMember member) { return new GlobalUsageHelperBase(); } + @RequiredReadAction void registerLocallyReferenced(@Nonnull PsiNamedElement result) { myDclsUsedMap.add(PsiAnchor.create(result)); } @@ -181,6 +183,7 @@ private void registerLocalRef(@Nonnull PsiReference ref, PsiElement refElement) } @Nonnull + @RequiredReadAction private RefCountHolder removeInvalidRefs() { assert ready; boolean changed = false; @@ -234,6 +237,7 @@ boolean isReferenced(@Nonnull PsiElement element) { return myDclsUsedMap.contains(PsiAnchor.create(element)); } + @RequiredReadAction private boolean isClassUsedForInnerImports(@Nonnull PsiElement element, @Nonnull Collection array) { assert ready; if (!(element instanceof PsiClass)) { @@ -249,39 +253,34 @@ private boolean isClassUsedForInnerImports(@Nonnull PsiElement element, @Nonnull imports.add(importStmt); } - return ContainerUtil.all(imports, importStmt -> { - PsiElement importedMember = importStmt.resolve(); - if (importedMember != null && PsiTreeUtil.isAncestor(element, importedMember, false)) { - for (PsiReference memberReference : myLocalRefsMap.get(importedMember)) { - if (!PsiTreeUtil.isAncestor(element, memberReference.getElement(), false)) { - return false; + return ContainerUtil.all( + imports, + importStmt -> { + PsiElement importedMember = importStmt.resolve(); + if (importedMember != null && PsiTreeUtil.isAncestor(element, importedMember, false)) { + for (PsiReference memberReference : myLocalRefsMap.get(importedMember)) { + if (!PsiTreeUtil.isAncestor(element, memberReference.getElement(), false)) { + return false; + } } + return true; } - return true; + return false; } - return false; - }); + ); } @RequiredReadAction private static boolean isParameterUsedRecursively(@Nonnull PsiElement element, @Nonnull Collection array) { - if (!(element instanceof PsiParameter)) { + if (!(element instanceof PsiParameter parameter && parameter.getDeclarationScope() instanceof PsiMethod method)) { return false; } - PsiParameter parameter = (PsiParameter)element; - PsiElement scope = parameter.getDeclarationScope(); - if (!(scope instanceof PsiMethod)) { - return false; - } - PsiMethod method = (PsiMethod)scope; int paramIndex = ArrayUtil.find(method.getParameterList().getParameters(), parameter); for (PsiReference reference : array) { - if (!(reference instanceof PsiElement)) { + if (!(reference instanceof PsiElement argument)) { return false; } - PsiElement argument = (PsiElement)reference; - PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression)new PsiMatcherImpl(argument) .dot(PsiMatchers.hasClass(PsiReferenceExpression.class)) .parent(PsiMatchers.hasClass(PsiExpressionList.class)) @@ -365,7 +364,7 @@ boolean isReferencedForWrite(@Nonnull PsiVariable variable) { return false; } - private static void log(@NonNls @Nonnull Object... info) { + private static void log(@Nonnull Object... info) { //FileStatusMap.log(info); } @@ -381,6 +380,7 @@ public boolean isCurrentFileAlreadyChecked() { } @Override + @RequiredReadAction public boolean isLocallyUsed(@Nonnull PsiNamedElement member) { return isReferenced(member); } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java index 08eb7993bb..3c07e1bf41 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/daemon/impl/quickfix/ModifierFix.java @@ -35,6 +35,7 @@ import consulo.language.psi.resolve.PsiElementProcessor; import consulo.language.psi.resolve.PsiElementProcessorAdapter; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; import consulo.ui.annotation.RequiredUIAccess; @@ -97,7 +98,7 @@ public String getText() { @RequiredReadAction private String format(PsiVariable variable, PsiModifierList modifierList) { - String name = null; + String name; PsiElement parent = variable == null ? modifierList == null ? null : modifierList.getParent() : variable; if (parent instanceof PsiClass psiClass) { name = psiClass.getName(); @@ -112,22 +113,27 @@ else if (parent instanceof PsiVariable psiVariable) { } else if (parent instanceof PsiClassInitializer classInitializer) { PsiClass containingClass = classInitializer.getContainingClass(); - String className = containingClass instanceof PsiAnonymousClass anonymousClass - ? JavaQuickFixBundle.message("anonymous.class.presentation", anonymousClass.getBaseClassType().getPresentableText()) - : containingClass != null ? containingClass.getName() : "unknown"; - name = JavaQuickFixBundle.message("class.initializer.presentation", className); + LocalizeValue className = containingClass instanceof PsiAnonymousClass anonymousClass + ? JavaQuickFixLocalize.anonymousClassPresentation(anonymousClass.getBaseClassType().getPresentableText()) + : containingClass != null ? LocalizeValue.of(containingClass.getName()) : LocalizeValue.localizeTODO("unknown"); + name = JavaQuickFixLocalize.classInitializerPresentation(className).get(); + } + else { + name = "?"; } } String modifierText = VisibilityUtil.toPresentableText(myModifier); - return JavaQuickFixBundle.message(myShouldHave ? "add.modifier.fix" : "remove.modifier.fix", name, modifierText); + return myShouldHave + ? JavaQuickFixLocalize.addModifierFix(name, modifierText).get() + : JavaQuickFixLocalize.removeModifierFix(name, modifierText).get(); } @Nonnull @Override public String getFamilyName() { - return JavaQuickFixBundle.message("fix.modifiers.family"); + return JavaQuickFixLocalize.fixModifiersFamily().get(); } @Override @@ -210,8 +216,8 @@ public void invoke( if (!modifierLists.isEmpty()) { if (Messages.showYesNoDialog( project, - JavaQuickFixBundle.message("change.inheritors.visibility.warning.text"), - JavaQuickFixBundle.message("change.inheritors.visibility.warning.title"), + JavaQuickFixLocalize.changeInheritorsVisibilityWarningText().get(), + JavaQuickFixLocalize.changeInheritorsVisibilityWarningTitle().get(), UIUtil.getQuestionIcon() ) == DialogWrapper.OK_EXIT_CODE) { project.getApplication().runWriteAction(() -> { 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 f8c9ea0db1..52c58b5d83 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 @@ -35,13 +35,14 @@ import com.intellij.java.language.psi.util.ClassKind; import com.intellij.java.language.psi.util.InheritanceUtil; import com.intellij.java.language.psi.util.PropertyMemberType; +import consulo.annotation.access.RequiredReadAction; import consulo.annotation.component.ServiceImpl; -import consulo.application.ApplicationManager; +import consulo.application.Application; import consulo.codeEditor.Editor; import consulo.document.Document; import consulo.document.util.TextRange; import consulo.ide.impl.idea.codeInsight.daemon.impl.quickfix.RenameElementFix; -import consulo.java.analysis.impl.JavaQuickFixBundle; +import consulo.java.analysis.impl.localize.JavaQuickFixLocalize; import consulo.java.language.module.util.JavaClassNames; import consulo.language.ast.IElementType; import consulo.language.editor.AutoImportHelper; @@ -84,6 +85,7 @@ public class QuickFixFactoryImpl extends QuickFixFactory { @Nonnull @Override + @RequiredReadAction public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( @Nonnull PsiModifierList modifierList, @Nonnull String modifier, @@ -95,6 +97,7 @@ public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( @Nonnull @Override + @RequiredReadAction public LocalQuickFixAndIntentionActionOnPsiElement createModifierListFix( @Nonnull PsiModifierListOwner owner, @Nonnull final String modifier, @@ -166,6 +169,7 @@ public LocalQuickFixAndIntentionActionOnPsiElement createAddDefaultConstructorFi } @Override + @RequiredReadAction public LocalQuickFixAndIntentionActionOnPsiElement createAddConstructorFix(@Nonnull PsiClass aClass, @Nonnull String modifier) { return aClass.getName() != null ? new AddDefaultConstructorFix(aClass, modifier) : null; } @@ -716,6 +720,7 @@ public String getText() { } @Override + @RequiredReadAction public boolean isAvailable(@Nonnull Project project, Editor editor, PsiFile file) { return (!onTheFly || timeToOptimizeImports(file)) && fix.isAvailable(project, editor, file); } @@ -738,7 +743,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(ApplicationManager.getApplication().isUnitTestMode() || unusedParametersInspection != null); + LOG.assertTrue(Application.get().isUnitTestMode() || unusedParametersInspection != null); List options = new ArrayList<>(); HighlightDisplayKey myUnusedSymbolKey = HighlightDisplayKey.find(UnusedSymbolLocalInspectionBase.SHORT_NAME); options.addAll(IntentionManager.getInstance().getStandardIntentionOptions(myUnusedSymbolKey, parameter)); @@ -764,8 +769,8 @@ public IntentionAction createAddToDependencyInjectionAnnotationsFix( ) { final EntryPointsManagerBase entryPointsManager = EntryPointsManagerBase.getInstance(project); return SpecialAnnotationsUtil.createAddToSpecialAnnotationsListIntentionAction( - JavaQuickFixBundle.message("fix.unused.symbol.injection.text", element, qualifiedName), - JavaQuickFixBundle.message("fix.unused.symbol.injection.family"), + JavaQuickFixLocalize.fixUnusedSymbolInjectionText(element, qualifiedName).get(), + JavaQuickFixLocalize.fixUnusedSymbolInjectionFamily().get(), entryPointsManager.ADDITIONAL_ANNOTATIONS, qualifiedName ); @@ -816,6 +821,7 @@ public IntentionAction createSafeDeleteFix(@Nonnull PsiElement element) { @Nullable @Override + @RequiredReadAction public List registerOrderEntryFixes(@Nonnull PsiReference reference) { return OrderEntryFix.registerFixes(reference); } @@ -827,8 +833,7 @@ private static void invokeOnTheFlyImportOptimizer(@Nonnull final Runnable runnab return; } final long stamp = document.getModificationStamp(); - DumbService.getInstance(file.getProject()).smartInvokeLater(() -> - { + DumbService.getInstance(file.getProject()).smartInvokeLater(() -> { if (project.isDisposed() || document.getModificationStamp() != stamp) { return; } @@ -845,7 +850,7 @@ private static void invokeOnTheFlyImportOptimizer(@Nonnull final Runnable runnab String afterText = file.getText(); if (Comparing.strEqual(beforeText, afterText)) { LOG.error( - "Import optimizer hasn't optimized any imports", + "Import optimizer hasn't optimized any imports", file.getViewProvider().getVirtualFile().getPath(), AttachmentFactoryUtil.createAttachment(file.getViewProvider().getVirtualFile()) ); @@ -910,6 +915,7 @@ public List createAddAnnotationAttributeNameFixes(@Nonnull PsiN return AddAnnotationAttributeNameFix.createFixes(pair); } + @RequiredReadAction private static boolean timeToOptimizeImports(@Nonnull PsiFile file) { if (!CodeInsightSettings.getInstance().OPTIMIZE_IMPORTS_ON_THE_FLY) { return false; @@ -930,6 +936,7 @@ private static boolean timeToOptimizeImports(@Nonnull PsiFile file) { return !errors && AutoImportHelper.getInstance(project).canChangeFileSilently(file); } + @RequiredReadAction private static boolean containsErrorsPreventingOptimize(@Nonnull PsiFile file) { Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file); if (document == null) { @@ -938,20 +945,19 @@ private static boolean containsErrorsPreventingOptimize(@Nonnull PsiFile file) { // ignore unresolved imports errors PsiImportList importList = ((PsiJavaFile)file).getImportList(); final TextRange importsRange = importList == null ? TextRange.EMPTY_RANGE : importList.getTextRange(); - boolean hasErrorsExceptUnresolvedImports = - !DaemonCodeAnalyzer.processHighlights( - document, - file.getProject(), - HighlightSeverity.ERROR, - 0, - document.getTextLength(), - error -> { - int infoStart = error.getActualStartOffset(); - int infoEnd = error.getActualEndOffset(); - - return importsRange.containsRange(infoStart, infoEnd) && error.getType().equals(HighlightInfoType.WRONG_REF); - } - ); + boolean hasErrorsExceptUnresolvedImports = !DaemonCodeAnalyzer.processHighlights( + document, + file.getProject(), + HighlightSeverity.ERROR, + 0, + document.getTextLength(), + error -> { + int infoStart = error.getActualStartOffset(); + int infoEnd = error.getActualEndOffset(); + + return importsRange.containsRange(infoStart, infoEnd) && error.getType().equals(HighlightInfoType.WRONG_REF); + } + ); return hasErrorsExceptUnresolvedImports; } From 774b07464661a58129f185926e4a0d15908ee9ae Mon Sep 17 00:00:00 2001 From: UNV Date: Sun, 4 May 2025 21:19:03 +0300 Subject: [PATCH 3/3] Refactoring and localizing users of EP_NAME (part 9). --- .../daemon/impl/analysis/RefCountHolder.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java index 9b28345d03..80195c5f72 100644 --- a/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java +++ b/java-analysis-impl/src/main/java/com/intellij/java/analysis/impl/codeInsight/daemon/impl/analysis/RefCountHolder.java @@ -75,14 +75,14 @@ void storeReadyHolder(@Nonnull PsiFile file) { private RefCountHolder( @Nonnull PsiFile file, - @Nonnull MultiMap myLocalRefsMap, - @Nonnull Set myDclsUsedMap, - @Nonnull Map myImportStatements + @Nonnull MultiMap localRefsMap, + @Nonnull Set dclsUsedMap, + @Nonnull Map importStatements ) { myFile = file; - this.myLocalRefsMap = myLocalRefsMap; - this.myDclsUsedMap = myDclsUsedMap; - this.myImportStatements = myImportStatements; + myLocalRefsMap = localRefsMap; + myDclsUsedMap = dclsUsedMap; + myImportStatements = importStatements; log("c: created for ", file); }