From 62a75ea0335ad96fc0f42756ce59f3a838486aca Mon Sep 17 00:00:00 2001 From: UNV Date: Wed, 15 Oct 2025 19:00:55 +0300 Subject: [PATCH] Generate handlers localizing and refactoring. --- .../GenerateConstructorHandler.java | 501 +++++++++--------- .../generation/GenerateEqualsHandler.java | 222 ++++---- .../GenerateFieldOrPropertyHandler.java | 194 ++++--- .../GenerateGetterAndSetterHandler.java | 52 +- .../generation/GenerateGetterHandler.java | 81 +-- .../GenerateGetterSetterHandlerBase.java | 106 ++-- .../GenerateMembersHandlerBase.java | 164 +++--- .../generation/GenerateSetterHandler.java | 68 +-- 8 files changed, 737 insertions(+), 651 deletions(-) diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateConstructorHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateConstructorHandler.java index b94a56f892..384b8f0d31 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateConstructorHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateConstructorHandler.java @@ -24,7 +24,7 @@ import com.intellij.java.language.psi.javadoc.PsiDocComment; import com.intellij.java.language.psi.util.PsiUtil; import com.intellij.java.language.psi.util.TypeConversionUtil; -import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.component.extension.ExtensionPoint; import consulo.ide.impl.idea.ide.util.MemberChooser; import consulo.language.codeStyle.CodeStyleManager; @@ -38,286 +38,297 @@ import consulo.logging.Logger; import consulo.platform.base.localize.CommonLocalize; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.Messages; import consulo.ui.ex.awt.UIUtil; import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; -import org.jetbrains.annotations.NonNls; import java.util.ArrayList; import java.util.Collections; import java.util.List; public class GenerateConstructorHandler extends GenerateMembersHandlerBase { - private static final Logger LOG = Logger.getInstance(GenerateConstructorHandler.class); - private boolean myCopyJavadoc; - - public GenerateConstructorHandler() { - super(CodeInsightLocalize.generateConstructorFieldsChooserTitle().get()); - } - - @Override - protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { - PsiField[] fields = aClass.getFields(); - ArrayList array = new ArrayList<>(); - ExtensionPoint usageProviders = aClass.getProject().getExtensionPoint(ImplicitUsageProvider.class); - - for (PsiField field : fields) { - if (field.hasModifierProperty(PsiModifier.STATIC)) { - continue; - } - - if (field.hasModifierProperty(PsiModifier.FINAL) && field.getInitializer() != null) { - continue; - } - - boolean isImplicitWrote = usageProviders.findFirstSafe(it -> it.isImplicitWrite(field)) != null; - if (isImplicitWrote) { - continue; - } - - array.add(new PsiFieldMember(field)); - } - return array.toArray(new ClassMember[array.size()]); - } - - @Override - @Nullable - protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { - if (aClass instanceof PsiAnonymousClass) { - Messages.showMessageDialog( - project, - CodeInsightLocalize.errorAttemptToGenerateConstructorForAnonymousClass().get(), - CommonLocalize.titleError().get(), - UIUtil.getErrorIcon() - ); - return null; + private static final Logger LOG = Logger.getInstance(GenerateConstructorHandler.class); + private boolean myCopyJavadoc; + + public GenerateConstructorHandler() { + super(CodeInsightLocalize.generateConstructorFieldsChooserTitle()); } - myCopyJavadoc = false; - PsiMethod[] baseConstructors = null; - PsiClass baseClass = aClass.getSuperClass(); - if (baseClass != null) { - ArrayList array = new ArrayList<>(); - for (PsiMethod method : baseClass.getConstructors()) { - if (JavaPsiFacade.getInstance(method.getProject()).getResolveHelper().isAccessible(method, aClass, null)) { - array.add(method); + @Override + protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { + PsiField[] fields = aClass.getFields(); + ArrayList array = new ArrayList<>(); + ExtensionPoint usageProviders = aClass.getProject().getExtensionPoint(ImplicitUsageProvider.class); + + for (PsiField field : fields) { + if (field.isStatic()) { + continue; + } + + if (field.isFinal() && field.getInitializer() != null) { + continue; + } + + boolean isImplicitWrote = usageProviders.findFirstSafe(it -> it.isImplicitWrite(field)) != null; + if (isImplicitWrote) { + continue; + } + + array.add(new PsiFieldMember(field)); } - } - if (!array.isEmpty()) { - if (array.size() == 1) { - baseConstructors = new PsiMethod[]{array.get(0)}; - } else { - final PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY); - PsiMethodMember[] constructors = ContainerUtil.map2Array(array, PsiMethodMember.class, s -> new PsiMethodMember(s, substitutor)); - MemberChooser chooser = new MemberChooser<>(constructors, false, true, project); - chooser.setTitle(CodeInsightLocalize.generateConstructorSuperConstructorChooserTitle()); - chooser.show(); - List elements = chooser.getSelectedElements(); - if (elements == null || elements.isEmpty()) { + return array.toArray(new ClassMember[array.size()]); + } + + @Override + @Nullable + @RequiredUIAccess + protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { + if (aClass instanceof PsiAnonymousClass) { + Messages.showMessageDialog( + project, + CodeInsightLocalize.errorAttemptToGenerateConstructorForAnonymousClass().get(), + CommonLocalize.titleError().get(), + UIUtil.getErrorIcon() + ); return null; - } - baseConstructors = new PsiMethod[elements.size()]; - for (int i = 0; i < elements.size(); i++) { - final ClassMember member = elements.get(i); - baseConstructors[i] = ((PsiMethodMember) member).getElement(); - } - myCopyJavadoc = chooser.isCopyJavadoc(); } - } - } - ClassMember[] allMembers = getAllOriginalMembers(aClass); - ClassMember[] members; - if (allMembers.length == 0) { - members = ClassMember.EMPTY_ARRAY; - } else { - members = chooseMembers(allMembers, true, false, project, null); - if (members == null) { - return null; - } - } - if (baseConstructors != null) { - ArrayList array = new ArrayList<>(); - for (PsiMethod baseConstructor : baseConstructors) { - array.add(new PsiMethodMember(baseConstructor)); - } - ContainerUtil.addAll(array, members); - members = array.toArray(new ClassMember[array.size()]); - } + myCopyJavadoc = false; + PsiMethod[] baseConstructors = null; + PsiClass baseClass = aClass.getSuperClass(); + if (baseClass != null) { + ArrayList array = new ArrayList<>(); + for (PsiMethod method : baseClass.getConstructors()) { + if (JavaPsiFacade.getInstance(method.getProject()).getResolveHelper().isAccessible(method, aClass, null)) { + array.add(method); + } + } + if (!array.isEmpty()) { + if (array.size() == 1) { + baseConstructors = new PsiMethod[]{array.get(0)}; + } + else { + PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(baseClass, aClass, PsiSubstitutor.EMPTY); + PsiMethodMember[] constructors = + ContainerUtil.map2Array(array, PsiMethodMember.class, s -> new PsiMethodMember(s, substitutor)); + MemberChooser chooser = new MemberChooser<>(constructors, false, true, project); + chooser.setTitle(CodeInsightLocalize.generateConstructorSuperConstructorChooserTitle()); + chooser.show(); + List elements = chooser.getSelectedElements(); + if (elements == null || elements.isEmpty()) { + return null; + } + baseConstructors = new PsiMethod[elements.size()]; + for (int i = 0; i < elements.size(); i++) { + ClassMember member = elements.get(i); + baseConstructors[i] = ((PsiMethodMember) member).getElement(); + } + myCopyJavadoc = chooser.isCopyJavadoc(); + } + } + } - return members; - } - - @Override - protected MemberChooser createMembersChooser( - ClassMember[] members, - boolean allowEmptySelection, - boolean copyJavadocCheckbox, - Project project - ) { - final MemberChooser chooser = super.createMembersChooser(members, allowEmptySelection, copyJavadocCheckbox, project); - final List preselection = preselect(members); - if (!preselection.isEmpty()) { - chooser.selectElements(preselection.toArray(new ClassMember[preselection.size()])); - } - return chooser; - } - - protected static List preselect(ClassMember[] members) { - final List preselection = new ArrayList<>(); - for (ClassMember member : members) { - if (member instanceof PsiFieldMember fieldMember) { - final PsiField psiField = fieldMember.getElement(); - if (psiField != null && psiField.hasModifierProperty(PsiModifier.FINAL)) { - preselection.add(member); + ClassMember[] allMembers = getAllOriginalMembers(aClass); + ClassMember[] members; + if (allMembers.length == 0) { + members = ClassMember.EMPTY_ARRAY; } - } - } - return preselection; - } - - @Override - @Nonnull - protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) throws IncorrectOperationException { - List baseConstructors = new ArrayList<>(); - List fieldsVector = new ArrayList<>(); - for (ClassMember member1 : members) { - PsiElement member = ((PsiElementClassMember) member1).getElement(); - if (member instanceof PsiMethod method) { - baseConstructors.add(method); - } else { - fieldsVector.add((PsiField) member); - } + else { + members = chooseMembers(allMembers, true, false, project, null); + if (members == null) { + return null; + } + } + if (baseConstructors != null) { + ArrayList array = new ArrayList<>(); + for (PsiMethod baseConstructor : baseConstructors) { + array.add(new PsiMethodMember(baseConstructor)); + } + ContainerUtil.addAll(array, members); + members = array.toArray(new ClassMember[array.size()]); + } + + return members; } - PsiField[] fields = fieldsVector.toArray(new PsiField[fieldsVector.size()]); - - if (!baseConstructors.isEmpty()) { - List constructors = new ArrayList<>(baseConstructors.size()); - final PsiClass superClass = aClass.getSuperClass(); - assert superClass != null; - PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); - for (PsiMethod baseConstructor : baseConstructors) { - if (substitutor != PsiSubstitutor.EMPTY) { - baseConstructor = GenerateMembersUtil.substituteGenericMethod(baseConstructor, substitutor, aClass); + + @Override + protected MemberChooser createMembersChooser( + ClassMember[] members, + boolean allowEmptySelection, + boolean copyJavadocCheckbox, + Project project + ) { + MemberChooser chooser = super.createMembersChooser(members, allowEmptySelection, copyJavadocCheckbox, project); + List preselection = preselect(members); + if (!preselection.isEmpty()) { + chooser.selectElements(preselection.toArray(new ClassMember[preselection.size()])); } - constructors.add(new PsiGenerationInfo(generateConstructorPrototype(aClass, baseConstructor, myCopyJavadoc, fields))); - } - return filterOutAlreadyInsertedConstructors(aClass, constructors); + return chooser; } - final List constructors = - Collections.singletonList(new PsiGenerationInfo(generateConstructorPrototype(aClass, null, false, fields))); - return filterOutAlreadyInsertedConstructors(aClass, constructors); - } - - private static List filterOutAlreadyInsertedConstructors(PsiClass aClass, List constructors) { - boolean alreadyExist = true; - for (GenerationInfo constructor : constructors) { - alreadyExist &= aClass.findMethodBySignature((PsiMethod) constructor.getPsiMember(), false) != null; + + protected static List preselect(ClassMember[] members) { + List preselection = new ArrayList<>(); + for (ClassMember member : members) { + if (member instanceof PsiFieldMember fieldMember) { + PsiField psiField = fieldMember.getElement(); + if (psiField != null && psiField.isFinal()) { + preselection.add(member); + } + } + } + return preselection; } - if (alreadyExist) { - return Collections.emptyList(); + + @Nonnull + @Override + @RequiredWriteAction + protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) + throws IncorrectOperationException { + List baseConstructors = new ArrayList<>(); + List fieldsVector = new ArrayList<>(); + for (ClassMember member1 : members) { + PsiElement member = ((PsiElementClassMember) member1).getElement(); + if (member instanceof PsiMethod method) { + baseConstructors.add(method); + } + else { + fieldsVector.add((PsiField) member); + } + } + PsiField[] fields = fieldsVector.toArray(new PsiField[fieldsVector.size()]); + + if (!baseConstructors.isEmpty()) { + List constructors = new ArrayList<>(baseConstructors.size()); + PsiClass superClass = aClass.getSuperClass(); + assert superClass != null; + PsiSubstitutor substitutor = TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY); + for (PsiMethod baseConstructor : baseConstructors) { + if (substitutor != PsiSubstitutor.EMPTY) { + baseConstructor = GenerateMembersUtil.substituteGenericMethod(baseConstructor, substitutor, aClass); + } + constructors.add(new PsiGenerationInfo<>(generateConstructorPrototype(aClass, baseConstructor, myCopyJavadoc, fields))); + } + return filterOutAlreadyInsertedConstructors(aClass, constructors); + } + List constructors = + Collections.singletonList(new PsiGenerationInfo<>(generateConstructorPrototype(aClass, null, false, fields))); + return filterOutAlreadyInsertedConstructors(aClass, constructors); } - return constructors; - } - - @Override - protected String getNothingFoundMessage() { - return "Constructor already exist"; - } - - @RequiredReadAction - public static PsiMethod generateConstructorPrototype( - PsiClass aClass, - PsiMethod baseConstructor, - boolean copyJavaDoc, - PsiField[] fields - ) throws IncorrectOperationException { - PsiManager manager = aClass.getManager(); - JVMElementFactory factory = JVMElementFactories.requireFactory(aClass.getLanguage(), aClass.getProject()); - CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(manager.getProject()); - - PsiMethod constructor = factory.createConstructor(aClass.getName(), aClass); - String modifier = PsiUtil.getMaximumModifierForMember(aClass, false); - - if (modifier != null) { - PsiUtil.setModifierProperty(constructor, modifier, true); + + private static List filterOutAlreadyInsertedConstructors( + PsiClass aClass, + List constructors + ) { + boolean alreadyExist = true; + for (GenerationInfo constructor : constructors) { + alreadyExist &= aClass.findMethodBySignature((PsiMethod) constructor.getPsiMember(), false) != null; + } + if (alreadyExist) { + return Collections.emptyList(); + } + return constructors; } - if (baseConstructor != null) { - PsiJavaCodeReferenceElement[] throwRefs = baseConstructor.getThrowsList().getReferenceElements(); - for (PsiJavaCodeReferenceElement ref : throwRefs) { - constructor.getThrowsList().add(ref); - } + @Override + protected String getNothingFoundMessage() { + return "Constructor already exists"; + } - if (copyJavaDoc) { - final PsiDocComment docComment = ((PsiMethod) baseConstructor.getNavigationElement()).getDocComment(); - if (docComment != null) { - constructor.addAfter(docComment, null); + @RequiredWriteAction + public static PsiMethod generateConstructorPrototype( + PsiClass aClass, + PsiMethod baseConstructor, + boolean copyJavaDoc, + PsiField[] fields + ) throws IncorrectOperationException { + PsiManager manager = aClass.getManager(); + JVMElementFactory factory = JVMElementFactories.requireFactory(aClass.getLanguage(), aClass.getProject()); + CodeStyleManager codeStyleManager = CodeStyleManager.getInstance(manager.getProject()); + + PsiMethod constructor = factory.createConstructor(aClass.getName(), aClass); + String modifier = PsiUtil.getMaximumModifierForMember(aClass, false); + + if (modifier != null) { + PsiUtil.setModifierProperty(constructor, modifier, true); } - } - } - boolean isNotEnum = false; - if (baseConstructor != null) { - PsiClass superClass = aClass.getSuperClass(); - LOG.assertTrue(superClass != null); - if (!CommonClassNames.JAVA_LANG_ENUM.equals(superClass.getQualifiedName())) { - isNotEnum = true; - if (baseConstructor instanceof PsiCompiledElement) { // to get some parameter names - PsiClass dummyClass = JVMElementFactories.requireFactory(baseConstructor.getLanguage(), baseConstructor.getProject()) - .createClass("Dummy"); - baseConstructor = (PsiMethod) dummyClass.add(baseConstructor); + if (baseConstructor != null) { + PsiJavaCodeReferenceElement[] throwRefs = baseConstructor.getThrowsList().getReferenceElements(); + for (PsiJavaCodeReferenceElement ref : throwRefs) { + constructor.getThrowsList().add(ref); + } + + if (copyJavaDoc) { + PsiDocComment docComment = ((PsiMethod) baseConstructor.getNavigationElement()).getDocComment(); + if (docComment != null) { + constructor.addAfter(docComment, null); + } + } } - PsiParameter[] params = baseConstructor.getParameterList().getParameters(); - for (PsiParameter param : params) { - PsiParameter newParam = factory.createParameter(param.getName(), param.getType(), aClass); - GenerateMembersUtil.copyOrReplaceModifierList(param, newParam); - constructor.getParameterList().add(newParam); + + boolean isNotEnum = false; + if (baseConstructor != null) { + PsiClass superClass = aClass.getSuperClass(); + LOG.assertTrue(superClass != null); + if (!CommonClassNames.JAVA_LANG_ENUM.equals(superClass.getQualifiedName())) { + isNotEnum = true; + if (baseConstructor instanceof PsiCompiledElement) { // to get some parameter names + PsiClass dummyClass = + JVMElementFactoryProvider.forLanguageRequired(baseConstructor.getProject(), baseConstructor.getLanguage()) + .createClass("Dummy"); + baseConstructor = (PsiMethod) dummyClass.add(baseConstructor); + } + PsiParameter[] params = baseConstructor.getParameterList().getParameters(); + for (PsiParameter param : params) { + PsiParameter newParam = factory.createParameter(param.getName(), param.getType(), aClass); + GenerateMembersUtil.copyOrReplaceModifierList(param, newParam); + constructor.getParameterList().add(newParam); + } + } } - } - } - JavaCodeStyleManager javaStyle = JavaCodeStyleManager.getInstance(aClass.getProject()); + JavaCodeStyleManager javaStyle = JavaCodeStyleManager.getInstance(aClass.getProject()); - final PsiMethod dummyConstructor = factory.createConstructor(aClass.getName()); - dummyConstructor.getParameterList().replace(constructor.getParameterList().copy()); - List fieldParams = new ArrayList<>(); - for (PsiField field : fields) { - String fieldName = field.getName(); - String name = javaStyle.variableNameToPropertyName(fieldName, VariableKind.FIELD); - String parmName = javaStyle.propertyNameToVariableName(name, VariableKind.PARAMETER); - parmName = javaStyle.suggestUniqueVariableName(parmName, dummyConstructor, true); - PsiParameter parm = factory.createParameter(parmName, field.getType(), aClass); + PsiMethod dummyConstructor = factory.createConstructor(aClass.getName()); + dummyConstructor.getParameterList().replace(constructor.getParameterList().copy()); + List fieldParams = new ArrayList<>(); + for (PsiField field : fields) { + String fieldName = field.getName(); + String name = javaStyle.variableNameToPropertyName(fieldName, VariableKind.FIELD); + String paramName = javaStyle.propertyNameToVariableName(name, VariableKind.PARAMETER); + paramName = javaStyle.suggestUniqueVariableName(paramName, dummyConstructor, true); + PsiParameter param = factory.createParameter(paramName, field.getType(), aClass); - NullableNotNullManager.getInstance(field.getProject()).copyNullableOrNotNullAnnotation(field, parm); + NullableNotNullManager.getInstance(field.getProject()).copyNullableOrNotNullAnnotation(field, param); - constructor.getParameterList().add(parm); - dummyConstructor.getParameterList().add(parm.copy()); - fieldParams.add(parm); - } + constructor.getParameterList().add(param); + dummyConstructor.getParameterList().add(param.copy()); + fieldParams.add(param); + } - ConstructorBodyGenerator generator = ConstructorBodyGenerator.forLanguage(aClass.getLanguage()); - if (generator != null) { - @NonNls StringBuilder buffer = new StringBuilder(); - generator.start(buffer, constructor.getName(), PsiParameter.EMPTY_ARRAY); - if (isNotEnum) { - generator.generateSuperCallIfNeeded(buffer, baseConstructor.getParameterList().getParameters()); - } - generator.generateFieldInitialization(buffer, fields, fieldParams.toArray(new PsiParameter[fieldParams.size()])); - generator.finish(buffer); - PsiMethod stub = factory.createMethodFromText(buffer.toString(), aClass); - constructor.getBody().replace(stub.getBody()); - } + ConstructorBodyGenerator generator = ConstructorBodyGenerator.forLanguage(aClass.getLanguage()); + if (generator != null) { + StringBuilder buffer = new StringBuilder(); + generator.start(buffer, constructor.getName(), PsiParameter.EMPTY_ARRAY); + if (isNotEnum) { + generator.generateSuperCallIfNeeded(buffer, baseConstructor.getParameterList().getParameters()); + } + generator.generateFieldInitialization(buffer, fields, fieldParams.toArray(new PsiParameter[fieldParams.size()])); + generator.finish(buffer); + PsiMethod stub = factory.createMethodFromText(buffer.toString(), aClass); + constructor.getBody().replace(stub.getBody()); + } - constructor = (PsiMethod) codeStyleManager.reformat(constructor); - return constructor; - } + constructor = (PsiMethod) codeStyleManager.reformat(constructor); + return constructor; + } - @Override - protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) { - LOG.assertTrue(false); - return null; - } + @Override + protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) { + LOG.assertTrue(false); + return null; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateEqualsHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateEqualsHandler.java index d7847815aa..510b7a0d27 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateEqualsHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateEqualsHandler.java @@ -41,115 +41,127 @@ * @author dsl */ public class GenerateEqualsHandler extends GenerateMembersHandlerBase { - private static final Logger LOG = Logger.getInstance(GenerateEqualsHandler.class); - private PsiField[] myEqualsFields = null; - private PsiField[] myHashCodeFields = null; - private PsiField[] myNonNullFields = null; - private static final PsiElementClassMember[] DUMMY_RESULT = new PsiElementClassMember[1]; //cannot return empty array, but this result won't be used anyway - - public GenerateEqualsHandler() { - super(""); - } - - @Override - @RequiredUIAccess - protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project, Editor editor) { - myEqualsFields = null; - myHashCodeFields = null; - myNonNullFields = PsiField.EMPTY_ARRAY; - - GlobalSearchScope scope = aClass.getResolveScope(); - final PsiMethod equalsMethod = GenerateEqualsHelper.findMethod(aClass, GenerateEqualsHelper.getEqualsSignature(project, scope)); - final PsiMethod hashCodeMethod = GenerateEqualsHelper.findMethod(aClass, GenerateEqualsHelper.getHashCodeSignature()); - - boolean needEquals = equalsMethod == null; - boolean needHashCode = hashCodeMethod == null; - if (!needEquals && !needHashCode) { - LocalizeValue text = aClass instanceof PsiAnonymousClass - ? CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedWarningAnonymous() - : CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedWarning(aClass.getQualifiedName()); - - if (Messages.showYesNoDialog( - project, - text.get(), - CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedTitle().get(), - UIUtil.getQuestionIcon() - ) == Messages.YES) { - if (!project.getApplication().runWriteAction((Computable)() -> { - try { - equalsMethod.delete(); - hashCodeMethod.delete(); - return Boolean.TRUE; - } - catch (IncorrectOperationException e) { - LOG.error(e); - return Boolean.FALSE; - } - })) { - return null; - } else { - needEquals = needHashCode = true; + private static final Logger LOG = Logger.getInstance(GenerateEqualsHandler.class); + private PsiField[] myEqualsFields = null; + private PsiField[] myHashCodeFields = null; + private PsiField[] myNonNullFields = null; + //cannot return empty array, but this result won't be used anyway + private static final PsiElementClassMember[] DUMMY_RESULT = new PsiElementClassMember[1]; + + public GenerateEqualsHandler() { + super(LocalizeValue.empty()); + } + + @Override + @RequiredUIAccess + protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project, Editor editor) { + myEqualsFields = null; + myHashCodeFields = null; + myNonNullFields = PsiField.EMPTY_ARRAY; + + GlobalSearchScope scope = aClass.getResolveScope(); + PsiMethod equalsMethod = GenerateEqualsHelper.findMethod(aClass, GenerateEqualsHelper.getEqualsSignature(project, scope)); + PsiMethod hashCodeMethod = GenerateEqualsHelper.findMethod(aClass, GenerateEqualsHelper.getHashCodeSignature()); + + boolean needEquals = equalsMethod == null; + boolean needHashCode = hashCodeMethod == null; + if (!needEquals && !needHashCode) { + LocalizeValue text = aClass instanceof PsiAnonymousClass + ? CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedWarningAnonymous() + : CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedWarning(aClass.getQualifiedName()); + + if (Messages.showYesNoDialog( + project, + text.get(), + CodeInsightLocalize.generateEqualsAndHashcodeAlreadyDefinedTitle().get(), + UIUtil.getQuestionIcon() + ) == Messages.YES) { + if (!project.getApplication().runWriteAction((Computable) () -> { + try { + equalsMethod.delete(); + hashCodeMethod.delete(); + return Boolean.TRUE; + } + catch (IncorrectOperationException e) { + LOG.error(e); + return Boolean.FALSE; + } + })) { + return null; + } + else { + needEquals = needHashCode = true; + } + } + else { + return null; + } } - } else { - return null; - } + boolean hasNonStaticFields = hasNonStaticFields(aClass); + if (!hasNonStaticFields) { + HintManager.getInstance().showErrorHint(editor, "No fields to include in equals/hashCode have been found"); + return null; + } + + GenerateEqualsWizard wizard = new GenerateEqualsWizard(project, aClass, needEquals, needHashCode); + if (!wizard.showAndGet()) { + return null; + } + myEqualsFields = wizard.getEqualsFields(); + myHashCodeFields = wizard.getHashCodeFields(); + myNonNullFields = wizard.getNonNullFields(); + return DUMMY_RESULT; } - boolean hasNonStaticFields = hasNonStaticFields(aClass); - if (!hasNonStaticFields) { - HintManager.getInstance().showErrorHint(editor, "No fields to include in equals/hashCode have been found"); - return null; + + private static boolean hasNonStaticFields(PsiClass aClass) { + for (PsiField field : aClass.getFields()) { + if (!field.isStatic()) { + return true; + } + } + return false; } - GenerateEqualsWizard wizard = new GenerateEqualsWizard(project, aClass, needEquals, needHashCode); - if (!wizard.showAndGet()) { - return null; + @Override + protected boolean hasMembers(@Nonnull PsiClass aClass) { + return hasNonStaticFields(aClass); } - myEqualsFields = wizard.getEqualsFields(); - myHashCodeFields = wizard.getHashCodeFields(); - myNonNullFields = wizard.getNonNullFields(); - return DUMMY_RESULT; - } - - private static boolean hasNonStaticFields(PsiClass aClass) { - for (PsiField field : aClass.getFields()) { - if (!field.hasModifierProperty(PsiModifier.STATIC)) { - return true; - } + + @Nonnull + @Override + protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] originalMembers) + throws IncorrectOperationException { + Project project = aClass.getProject(); + boolean useInstanceOfToCheckParameterType = JavaCodeInsightSettings.getInstance().USE_INSTANCEOF_ON_EQUALS_PARAMETER; + boolean useAccessors = JavaCodeInsightSettings.getInstance().USE_ACCESSORS_IN_EQUALS_HASHCODE; + + GenerateEqualsHelper helper = new GenerateEqualsHelper( + project, + aClass, + myEqualsFields, + myHashCodeFields, + myNonNullFields, + useInstanceOfToCheckParameterType, + useAccessors + ); + return OverrideImplementUtil.convert2GenerationInfos(helper.generateMembers()); + } + + @Override + protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { + return null; + } + + @Override + protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) { + return null; + } + + @Override + protected void cleanup() { + super.cleanup(); + myEqualsFields = null; + myHashCodeFields = null; + myNonNullFields = null; } - return false; - } - - @Override - protected boolean hasMembers(@Nonnull PsiClass aClass) { - return hasNonStaticFields(aClass); - } - - @Override - @Nonnull - protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] originalMembers) throws IncorrectOperationException { - Project project = aClass.getProject(); - final boolean useInstanceofToCheckParameterType = JavaCodeInsightSettings.getInstance().USE_INSTANCEOF_ON_EQUALS_PARAMETER; - final boolean useAccessors = JavaCodeInsightSettings.getInstance().USE_ACCESSORS_IN_EQUALS_HASHCODE; - - GenerateEqualsHelper helper = new GenerateEqualsHelper(project, aClass, myEqualsFields, myHashCodeFields, myNonNullFields, useInstanceofToCheckParameterType, useAccessors); - return OverrideImplementUtil.convert2GenerationInfos(helper.generateMembers()); - } - - @Override - protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { - return null; - } - - @Override - protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) { - return null; - } - - @Override - protected void cleanup() { - super.cleanup(); - myEqualsFields = null; - myHashCodeFields = null; - myNonNullFields = null; - } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateFieldOrPropertyHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateFieldOrPropertyHandler.java index a183b67182..51bbb30d80 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateFieldOrPropertyHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateFieldOrPropertyHandler.java @@ -22,13 +22,17 @@ import com.intellij.java.language.psi.codeStyle.VariableKind; import com.intellij.java.language.psi.util.PropertyMemberType; import com.intellij.java.language.psi.util.PropertyUtil; +import consulo.annotation.access.RequiredWriteAction; import consulo.language.editor.generation.ClassMember; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.util.collection.ContainerUtil; import jakarta.annotation.Nonnull; import jakarta.annotation.Nullable; + import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -37,105 +41,119 @@ * @author Gregory.Shrago */ public class GenerateFieldOrPropertyHandler extends GenerateMembersHandlerBase { - private final String myAttributeName; - private final PsiType myType; - private final PropertyMemberType myMemberType; - private final PsiAnnotation[] myAnnotations; - - public GenerateFieldOrPropertyHandler(String attributeName, PsiType type, final PropertyMemberType memberType, final PsiAnnotation... annotations) { - super(""); - myAttributeName = attributeName; - myType = type; - myMemberType = memberType; - myAnnotations = annotations; - } + private final String myAttributeName; + private final PsiType myType; + private final PropertyMemberType myMemberType; + private final PsiAnnotation[] myAnnotations; - @Override - protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { - return ClassMember.EMPTY_ARRAY; - } + public GenerateFieldOrPropertyHandler( + String attributeName, + PsiType type, + PropertyMemberType memberType, + PsiAnnotation... annotations + ) { + super(LocalizeValue.empty()); + myAttributeName = attributeName; + myType = type; + myMemberType = memberType; + myAnnotations = annotations; + } + @Override + @RequiredUIAccess + protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { + return ClassMember.EMPTY_ARRAY; + } - @Override - @Nonnull - public List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) throws IncorrectOperationException { - PsiElementFactory psiElementFactory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); - try { - String fieldName = getFieldName(aClass); - PsiField psiField = psiElementFactory.createField(fieldName, myType); - GenerationInfo[] infos = new GenerateGetterAndSetterHandler().generateMemberPrototypes(aClass, new PsiFieldMember(psiField)); - if (myAnnotations.length > 0) { - PsiMember targetMember = null; - if (myMemberType == PropertyMemberType.FIELD) { - targetMember = psiField; - } else { - for (GenerationInfo info : infos) { - PsiMember member = info.getPsiMember(); - if (!(member instanceof PsiMethod)) { - continue; - } - if (myMemberType == PropertyMemberType.GETTER && PropertyUtil.isSimplePropertyGetter((PsiMethod) member) || myMemberType == PropertyMemberType.SETTER && PropertyUtil - .isSimplePropertySetter((PsiMethod) member)) { - targetMember = member; - break; + @Nonnull + @Override + @RequiredWriteAction + public List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) + throws IncorrectOperationException { + PsiElementFactory psiElementFactory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); + try { + String fieldName = getFieldName(aClass); + PsiField psiField = psiElementFactory.createField(fieldName, myType); + GenerationInfo[] infos = new GenerateGetterAndSetterHandler().generateMemberPrototypes(aClass, new PsiFieldMember(psiField)); + if (myAnnotations.length > 0) { + PsiMember targetMember = null; + if (myMemberType == PropertyMemberType.FIELD) { + targetMember = psiField; + } + else { + for (GenerationInfo info : infos) { + PsiMember member = info.getPsiMember(); + if (!(member instanceof PsiMethod)) { + continue; + } + if (myMemberType == PropertyMemberType.GETTER && PropertyUtil.isSimplePropertyGetter((PsiMethod) member) || myMemberType == PropertyMemberType.SETTER && PropertyUtil + .isSimplePropertySetter((PsiMethod) member)) { + targetMember = member; + break; + } + } + if (targetMember == null) { + targetMember = findExistingMember(aClass, myMemberType); + } + } + PsiModifierList modifierList = targetMember != null ? targetMember.getModifierList() : null; + if (modifierList != null) { + for (PsiAnnotation annotation : myAnnotations) { + PsiAnnotation existing = modifierList.findAnnotation(annotation.getQualifiedName()); + if (existing != null) { + existing.replace(annotation); + } + else { + modifierList.addAfter(annotation, null); + } + } + } } - } - if (targetMember == null) { - targetMember = findExistingMember(aClass, myMemberType); - } + return ContainerUtil.concat(Collections.singletonList(new PsiGenerationInfo<>(psiField)), Arrays.asList(infos)); } - PsiModifierList modifierList = targetMember != null ? targetMember.getModifierList() : null; - if (modifierList != null) { - for (PsiAnnotation annotation : myAnnotations) { - PsiAnnotation existing = modifierList.findAnnotation(annotation.getQualifiedName()); - if (existing != null) { - existing.replace(annotation); - } else { - modifierList.addAfter(annotation, null); - } - } + catch (IncorrectOperationException e) { + assert false : e; + return Collections.emptyList(); } - } - return ContainerUtil.concat(Collections.singletonList(new PsiGenerationInfo(psiField)), Arrays.asList(infos)); - } catch (IncorrectOperationException e) { - assert false : e; - return Collections.emptyList(); } - } - @Nullable - public PsiMember findExistingMember(@Nonnull PsiClass aClass, @Nonnull PropertyMemberType memberType) { - if (memberType == PropertyMemberType.FIELD) { - return aClass.findFieldByName(getFieldName(aClass), false); - } else if (memberType == PropertyMemberType.GETTER) { - try { - PsiElementFactory psiElementFactory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); - PsiField field = psiElementFactory.createField(myAttributeName, myType); - PsiMethod[] templates = GetterSetterPrototypeProvider.generateGetterSetters(field, myMemberType == PropertyMemberType.GETTER); - for (PsiMethod template : templates) { - PsiMethod existingMethod = aClass.findMethodBySignature(template, true); - if (existingMethod != null) { - return existingMethod; - } + @Nullable + public PsiMember findExistingMember(@Nonnull PsiClass aClass, @Nonnull PropertyMemberType memberType) { + if (memberType == PropertyMemberType.FIELD) { + return aClass.findFieldByName(getFieldName(aClass), false); + } + else if (memberType == PropertyMemberType.GETTER) { + try { + PsiElementFactory psiElementFactory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory(); + PsiField field = psiElementFactory.createField(myAttributeName, myType); + PsiMethod[] templates = + GetterSetterPrototypeProvider.generateGetterSetters(field, myMemberType == PropertyMemberType.GETTER); + for (PsiMethod template : templates) { + PsiMethod existingMethod = aClass.findMethodBySignature(template, true); + if (existingMethod != null) { + return existingMethod; + } + } + } + catch (IncorrectOperationException e) { + assert false : e; + } } - } catch (IncorrectOperationException e) { - assert false : e; - } + return null; } - return null; - } - private String getFieldName(PsiClass aClass) { - return myMemberType == PropertyMemberType.FIELD ? myAttributeName : JavaCodeStyleManager.getInstance(aClass.getProject()).propertyNameToVariableName(myAttributeName, VariableKind.FIELD); - } + private String getFieldName(PsiClass aClass) { + return myMemberType == PropertyMemberType.FIELD ? myAttributeName : JavaCodeStyleManager.getInstance(aClass.getProject()) + .propertyNameToVariableName(myAttributeName, VariableKind.FIELD); + } - @Override - protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { - throw new UnsupportedOperationException(); - } + @Override + protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { + throw new UnsupportedOperationException(); + } - @Override - protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) throws IncorrectOperationException { - throw new UnsupportedOperationException(); - } + @Override + protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) throws IncorrectOperationException { + throw new UnsupportedOperationException(); + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterAndSetterHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterAndSetterHandler.java index fff20953f4..5153cb9310 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterAndSetterHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterAndSetterHandler.java @@ -25,34 +25,34 @@ import java.util.Collections; public class GenerateGetterAndSetterHandler extends GenerateGetterSetterHandlerBase { - private final GenerateGetterHandler myGenerateGetterHandler = new GenerateGetterHandler(); - private final GenerateSetterHandler myGenerateSetterHandler = new GenerateSetterHandler(); - - public GenerateGetterAndSetterHandler() { - super(CodeInsightLocalize.generateGetterSetterTitle().get()); - } - - @Override - public GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { - ArrayList array = new ArrayList<>(); - GenerationInfo[] getters = myGenerateGetterHandler.generateMemberPrototypes(aClass, original); - GenerationInfo[] setters = myGenerateSetterHandler.generateMemberPrototypes(aClass, original); - - if (getters.length + setters.length > 0) { - Collections.addAll(array, getters); - Collections.addAll(array, setters); + private final GenerateGetterHandler myGenerateGetterHandler = new GenerateGetterHandler(); + private final GenerateSetterHandler myGenerateSetterHandler = new GenerateSetterHandler(); + + public GenerateGetterAndSetterHandler() { + super(CodeInsightLocalize.generateGetterSetterTitle()); } - return array.toArray(new GenerationInfo[array.size()]); - } + @Override + public GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { + ArrayList array = new ArrayList<>(); + GenerationInfo[] getters = myGenerateGetterHandler.generateMemberPrototypes(aClass, original); + GenerationInfo[] setters = myGenerateSetterHandler.generateMemberPrototypes(aClass, original); + + if (getters.length + setters.length > 0) { + Collections.addAll(array, getters); + Collections.addAll(array, setters); + } + + return array.toArray(new GenerationInfo[array.size()]); + } - @Override - protected String getNothingFoundMessage() { - return "No fields have been found to generate getters/setters for"; - } + @Override + protected String getNothingFoundMessage() { + return "No fields have been found to generate getters/setters for"; + } - @Override - protected String getNothingAcceptedMessage() { - return "No fields without getter/setter were found"; - } + @Override + protected String getNothingAcceptedMessage() { + return "No fields without getter/setter were found"; + } } \ No newline at end of file diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterHandler.java index 07daeabf61..aacf0e06da 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterHandler.java @@ -19,57 +19,64 @@ import com.intellij.java.language.impl.codeInsight.generation.GenerationInfo; import com.intellij.java.language.impl.codeInsight.generation.PropertyClassMember; import com.intellij.java.language.psi.PsiClass; -import consulo.java.analysis.codeInsight.JavaCodeInsightBundle; +import consulo.java.analysis.codeInsight.localize.JavaCodeInsightLocalize; import consulo.language.editor.generation.ClassMember; import consulo.language.editor.localize.CodeInsightLocalize; import consulo.language.util.IncorrectOperationException; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import jakarta.annotation.Nullable; import javax.swing.*; public class GenerateGetterHandler extends GenerateGetterSetterHandlerBase { - public GenerateGetterHandler() { - super(CodeInsightLocalize.generateGetterFieldsChooserTitle().get()); - } + public GenerateGetterHandler() { + super(CodeInsightLocalize.generateGetterFieldsChooserTitle()); + } - @Override - protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { - if (aClass.isInterface()) { - return ClassMember.EMPTY_ARRAY; // TODO + @Override + @RequiredUIAccess + protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { + if (aClass.isInterface()) { + return ClassMember.EMPTY_ARRAY; // TODO + } + return super.chooseOriginalMembers(aClass, project); } - return super.chooseOriginalMembers(aClass, project); - } - @Nullable - @Override - protected JComponent getHeaderPanel(final Project project) { - return getHeaderPanel(project, GetterTemplatesManager.getInstance(), JavaCodeInsightBundle.message("generate.equals.hashcode.template")); - } + @Nullable + @Override + protected JComponent getHeaderPanel(Project project) { + return getHeaderPanel( + project, + GetterTemplatesManager.getInstance(), + JavaCodeInsightLocalize.generateEqualsHashcodeTemplate().get() + ); + } - @Override - protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { - if (original instanceof PropertyClassMember propertyClassMember) { - final GenerationInfo[] getters = propertyClassMember.generateGetters(aClass); - if (getters != null) { - return getters; - } - } else if (original instanceof EncapsulatableClassMember encapsulatableClassMember) { - final GenerationInfo getter = encapsulatableClassMember.generateGetter(); - if (getter != null) { - return new GenerationInfo[]{getter}; - } + @Override + protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { + if (original instanceof PropertyClassMember propertyClassMember) { + GenerationInfo[] getters = propertyClassMember.generateGetters(aClass); + if (getters != null) { + return getters; + } + } + else if (original instanceof EncapsulatableClassMember encapsulatableClassMember) { + GenerationInfo getter = encapsulatableClassMember.generateGetter(); + if (getter != null) { + return new GenerationInfo[]{getter}; + } + } + return GenerationInfo.EMPTY_ARRAY; } - return GenerationInfo.EMPTY_ARRAY; - } - @Override - protected String getNothingFoundMessage() { - return "No fields have been found to generate getters for"; - } + @Override + protected String getNothingFoundMessage() { + return "No fields have been found to generate getters for"; + } - @Override - protected String getNothingAcceptedMessage() { - return "No fields without getter were found"; - } + @Override + protected String getNothingAcceptedMessage() { + return "No fields without getter were found"; + } } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterSetterHandlerBase.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterSetterHandlerBase.java index 187aab5bc6..0c4754b7e9 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterSetterHandlerBase.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateGetterSetterHandlerBase.java @@ -29,6 +29,7 @@ import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.ui.ex.awt.ComboBox; import consulo.ui.ex.awt.ComponentWithBrowseButton; import consulo.ui.ex.awt.ListCellRendererWrapper; @@ -40,15 +41,13 @@ import javax.swing.*; import java.awt.*; -import java.awt.event.ActionEvent; -import java.awt.event.ActionListener; import java.util.Collection; import java.util.List; public abstract class GenerateGetterSetterHandlerBase extends GenerateMembersHandlerBase { private static final Logger LOG = Logger.getInstance(GenerateGetterSetterHandlerBase.class); - public GenerateGetterSetterHandlerBase(String chooserTitle) { + public GenerateGetterSetterHandlerBase(@Nonnull LocalizeValue chooserTitle) { super(chooserTitle); } @@ -63,8 +62,9 @@ protected String getHelpId() { } @Override + @RequiredUIAccess protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project, Editor editor) { - final ClassMember[] allMembers = getAllOriginalMembers(aClass); + ClassMember[] allMembers = getAllOriginalMembers(aClass); if (allMembers == null) { HintManager.getInstance().showErrorHint(editor, getNothingFoundMessage()); return null; @@ -76,49 +76,54 @@ protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project, return chooseMembers(allMembers, false, false, project, editor); } - protected static JComponent getHeaderPanel(final Project project, final TemplatesManager templatesManager, final String templatesTitle) { - final JPanel panel = new JPanel(new BorderLayout()); - final JLabel templateChooserLabel = new JLabel(templatesTitle); + protected static JComponent getHeaderPanel( + final Project project, + final TemplatesManager templatesManager, + final String templatesTitle + ) { + JPanel panel = new JPanel(new BorderLayout()); + JLabel templateChooserLabel = new JLabel(templatesTitle); panel.add(templateChooserLabel, BorderLayout.WEST); - final ComboBox comboBox = new ComboBox(); + ComboBox comboBox = new ComboBox<>(); templateChooserLabel.setLabelFor(comboBox); - comboBox.setRenderer(new ListCellRendererWrapper() { + comboBox.setRenderer(new ListCellRendererWrapper<>() { @Override public void customize(JList list, TemplateResource value, int index, boolean selected, boolean hasFocus) { setText(value.getName()); } }); - final ComponentWithBrowseButton comboBoxWithBrowseButton = new ComponentWithBrowseButton(comboBox, e -> { - final TemplatesPanel ui = new TemplatesPanel(project, templatesManager) { - @Override - protected boolean onMultipleFields() { - return false; - } - - @Override - public LocalizeValue getDisplayName() { - return LocalizeValue.localizeTODO(StringUtil.capitalizeWords(UIUtil.removeMnemonic(StringUtil.trimEnd(templatesTitle, ":")), true)); - } - }; - ui.selectNodeInTree(templatesManager.getDefaultTemplate()); - ShowSettingsUtil.getInstance().editConfigurable(panel, ui).doWhenDone(() -> setComboboxModel(templatesManager, comboBox)); - }); - - setComboboxModel(templatesManager, comboBox); - comboBox.addActionListener(new ActionListener() { - @Override - public void actionPerformed(@Nonnull final ActionEvent M) { - templatesManager.setDefaultTemplate((TemplateResource) comboBox.getSelectedItem()); + ComponentWithBrowseButton comboBoxWithBrowseButton = new ComponentWithBrowseButton( + comboBox, + e -> { + TemplatesPanel ui = new TemplatesPanel(project, templatesManager) { + @Override + protected boolean onMultipleFields() { + return false; + } + + @Override + public LocalizeValue getDisplayName() { + return LocalizeValue.localizeTODO(StringUtil.capitalizeWords( + UIUtil.removeMnemonic(StringUtil.trimEnd(templatesTitle, ":")), + true + )); + } + }; + ui.selectNodeInTree(templatesManager.getDefaultTemplate()); + ShowSettingsUtil.getInstance().editConfigurable(panel, ui).doWhenDone(() -> setComboBoxModel(templatesManager, comboBox)); } - }); + ); + + setComboBoxModel(templatesManager, comboBox); + comboBox.addActionListener(M -> templatesManager.setDefaultTemplate((TemplateResource) comboBox.getSelectedItem())); panel.add(comboBoxWithBrowseButton, BorderLayout.CENTER); return panel; } - private static void setComboboxModel(TemplatesManager templatesManager, ComboBox comboBox) { - final Collection templates = templatesManager.getAllTemplates(); - comboBox.setModel(new DefaultComboBoxModel(templates.toArray(new TemplateResource[templates.size()]))); + private static void setComboBoxModel(TemplatesManager templatesManager, ComboBox comboBox) { + Collection templates = templatesManager.getAllTemplates(); + comboBox.setModel(new DefaultComboBoxModel<>(templates.toArray(new TemplateResource[templates.size()]))); comboBox.setSelectedItem(templatesManager.getDefaultTemplate()); } @@ -128,31 +133,32 @@ private static void setComboboxModel(TemplatesManager templatesManager, ComboBox protected abstract String getNothingAcceptedMessage(); public boolean canBeAppliedTo(PsiClass targetClass) { - final ClassMember[] allMembers = getAllOriginalMembers(targetClass); + ClassMember[] allMembers = getAllOriginalMembers(targetClass); return allMembers != null && allMembers.length != 0; } @Override @Nullable - protected ClassMember[] getAllOriginalMembers(final PsiClass aClass) { - final List list = GenerateAccessorProviderRegistrar.getEncapsulatableClassMembers(aClass); + protected ClassMember[] getAllOriginalMembers(PsiClass aClass) { + List list = GenerateAccessorProviderRegistrar.getEncapsulatableClassMembers(aClass); if (list.isEmpty()) { return null; } - final List members = ContainerUtil.findAll(list, member -> { - try { - return generateMemberPrototypes(aClass, member).length > 0; - } - catch (GenerateCodeException e) { - return true; - } - catch (IncorrectOperationException e) { - LOG.error(e); - return false; + List members = ContainerUtil.findAll( + list, + member -> { + try { + return generateMemberPrototypes(aClass, member).length > 0; + } + catch (GenerateCodeException e) { + return true; + } + catch (IncorrectOperationException e) { + LOG.error(e); + return false; + } } - }); + ); return members.toArray(new ClassMember[members.size()]); } - - } diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateMembersHandlerBase.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateMembersHandlerBase.java index 6b5eddab2f..3e96a8d458 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateMembersHandlerBase.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateMembersHandlerBase.java @@ -21,7 +21,8 @@ import com.intellij.java.language.psi.PsiClass; import com.intellij.java.language.psi.PsiDocCommentOwner; import com.intellij.java.language.psi.PsiMember; -import consulo.application.ApplicationManager; +import consulo.annotation.access.RequiredReadAction; +import consulo.annotation.access.RequiredWriteAction; import consulo.application.Result; import consulo.codeEditor.Editor; import consulo.codeEditor.LogicalPosition; @@ -45,8 +46,10 @@ import consulo.language.psi.PsiElement; import consulo.language.psi.PsiFile; import consulo.language.util.IncorrectOperationException; +import consulo.localize.LocalizeValue; import consulo.logging.Logger; import consulo.project.Project; +import consulo.ui.annotation.RequiredUIAccess; import consulo.util.collection.ContainerUtil; import consulo.util.lang.StringUtil; import jakarta.annotation.Nonnull; @@ -59,16 +62,18 @@ public abstract class GenerateMembersHandlerBase implements CodeInsightActionHandler, ContextAwareActionHandler { private static final Logger LOG = Logger.getInstance(GenerateMembersHandlerBase.class); - private final String myChooserTitle; + @Nonnull + private final LocalizeValue myChooserTitle; protected boolean myToCopyJavaDoc = false; - public GenerateMembersHandlerBase(String chooserTitle) { + public GenerateMembersHandlerBase(@Nonnull LocalizeValue chooserTitle) { myChooserTitle = chooserTitle; } @Override + @RequiredReadAction public boolean isAvailableForQuickList(@Nonnull Editor editor, @Nonnull PsiFile file, @Nonnull DataContext dataContext) { - final PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, false); + PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, false); return aClass != null && hasMembers(aClass); } @@ -77,14 +82,15 @@ protected boolean hasMembers(@Nonnull PsiClass aClass) { } @Override - public final void invoke(@Nonnull final Project project, @Nonnull final Editor editor, @Nonnull PsiFile file) { + @RequiredUIAccess + public final void invoke(@Nonnull Project project, @Nonnull Editor editor, @Nonnull PsiFile file) { if (!LanguageEditorUtil.checkModificationAllowed(editor)) { return; } if (!FileDocumentManager.getInstance().requestWriting(editor.getDocument(), project)) { return; } - final PsiClass aClass = OverrideImplementUtil.getContextClass(project, editor, file, false); + PsiClass aClass = OverrideImplementUtil.getContextClass(project, editor, file, false); if (aClass == null || aClass.isInterface()) { return; //? } @@ -92,32 +98,32 @@ public final void invoke(@Nonnull final Project project, @Nonnull final Editor e LOG.assertTrue(aClass.getContainingFile() != null); try { - final ClassMember[] members = chooseOriginalMembers(aClass, project, editor); + ClassMember[] members = chooseOriginalMembers(aClass, project, editor); if (members == null) { return; } - WriteCommandAction.runWriteCommandAction(project, new Runnable() { - @Override - public void run() { - final int offset = editor.getCaretModel().getOffset(); + WriteCommandAction.runWriteCommandAction( + project, + () -> { + int offset = editor.getCaretModel().getOffset(); try { doGenerate(project, editor, aClass, members); } catch (GenerateCodeException e) { - final String message = e.getMessage(); - ApplicationManager.getApplication().invokeLater(new Runnable() { - @Override - public void run() { + String message = e.getMessage(); + project.getApplication().invokeLater( + () -> { if (!editor.isDisposed()) { editor.getCaretModel().moveToOffset(offset); HintManager.getInstance().showErrorHint(editor, message); } - } - }, project.getDisposed()); + }, + project.getDisposed() + ); } } - }); + ); } finally { cleanup(); @@ -127,16 +133,17 @@ public void run() { protected void cleanup() { } - private void doGenerate(final Project project, final Editor editor, PsiClass aClass, ClassMember[] members) { + @RequiredWriteAction + private void doGenerate(@Nonnull Project project, Editor editor, PsiClass aClass, ClassMember[] members) { int offset = editor.getCaretModel().getOffset(); int col = editor.getCaretModel().getLogicalPosition().column; int line = editor.getCaretModel().getLogicalPosition().line; - final Document document = editor.getDocument(); + Document document = editor.getDocument(); int lineStartOffset = document.getLineStartOffset(line); CharSequence docText = document.getCharsSequence(); String textBeforeCaret = docText.subSequence(lineStartOffset, offset).toString(); - final String afterCaret = docText.subSequence(offset, document.getLineEndOffset(line)).toString(); + String afterCaret = docText.subSequence(offset, document.getLineEndOffset(line)).toString(); if (textBeforeCaret.trim().length() > 0 && StringUtil.isEmptyOrSpaces(afterCaret) && !editor.getSelectionModel().hasSelection()) { PsiDocumentManager.getInstance(project).commitDocument(document); offset = editor.getCaretModel().getOffset(); @@ -159,16 +166,16 @@ private void doGenerate(final Project project, final Editor editor, PsiClass aCl editor.getCaretModel().moveToLogicalPosition(new LogicalPosition(line, col)); if (newMembers.isEmpty()) { - if (!ApplicationManager.getApplication().isUnitTestMode()) { + if (!project.getApplication().isUnitTestMode()) { HintManager.getInstance().showErrorHint(editor, getNothingFoundMessage()); } return; } else { - final List elements = new ArrayList(); + List elements = new ArrayList<>(); for (GenerationInfo member : newMembers) { if (!(member instanceof TemplateGenerationInfo)) { - final PsiMember psiMember = member.getPsiMember(); + PsiMember psiMember = member.getPsiMember(); if (psiMember != null) { elements.add(psiMember); } @@ -178,7 +185,7 @@ private void doGenerate(final Project project, final Editor editor, PsiClass aCl GlobalInspectionContextBase.cleanupElements(project, null, elements.toArray(new PsiElement[elements.size()])); } - final ArrayList templates = new ArrayList(); + List templates = new ArrayList<>(); for (GenerationInfo member : newMembers) { if (member instanceof TemplateGenerationInfo) { templates.add((TemplateGenerationInfo) member); @@ -198,64 +205,75 @@ protected String getNothingFoundMessage() { return "Nothing found to insert"; } - private static void runTemplates(final Project myProject, final Editor editor, final List templates, final int index) { + @RequiredReadAction + private static void runTemplates( + @Nonnull Project project, + final Editor editor, + final List templates, + final int index + ) { TemplateGenerationInfo info = templates.get(index); - final Template template = info.getTemplate(); + Template template = info.getTemplate(); - final PsiElement element = info.getPsiMember(); - final TextRange range = element.getTextRange(); + PsiElement element = info.getPsiMember(); + TextRange range = element.getTextRange(); editor.getDocument().deleteString(range.getStartOffset(), range.getEndOffset()); int offset = range.getStartOffset(); editor.getCaretModel().moveToOffset(offset); editor.getScrollingModel().scrollToCaret(ScrollType.CENTER); - TemplateManager.getInstance(myProject).startTemplate(editor, template, new TemplateEditingAdapter() { - @Override - public void templateFinished(Template template, boolean brokenOff) { - if (index + 1 < templates.size()) { - ApplicationManager.getApplication().invokeLater(new Runnable() { - @Override - public void run() { - new WriteCommandAction(myProject) { - @Override - protected void run(@Nonnull Result result) throws Throwable { - runTemplates(myProject, editor, templates, index + 1); - } - }.execute(); - } - }); + TemplateManager.getInstance(project).startTemplate( + editor, + template, + new TemplateEditingAdapter() { + @Override + public void templateFinished(Template template, boolean brokenOff) { + if (index + 1 < templates.size()) { + project.getApplication().invokeLater(() -> new WriteCommandAction(project) { + @Override + @RequiredReadAction + protected void run(@Nonnull Result result) throws Throwable { + runTemplates(project, editor, templates, index + 1); + } + }.execute()); + } } } - }); + ); } - @Nullable + @RequiredUIAccess protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project) { ClassMember[] allMembers = getAllOriginalMembers(aClass); return chooseMembers(allMembers, false, false, project, null); } @Nullable + @RequiredUIAccess protected ClassMember[] chooseOriginalMembers(PsiClass aClass, Project project, Editor editor) { return chooseOriginalMembers(aClass, project); } @Nullable - protected ClassMember[] chooseMembers(ClassMember[] members, boolean allowEmptySelection, boolean copyJavadocCheckbox, Project project, @Nullable Editor editor) { + @RequiredUIAccess + protected ClassMember[] chooseMembers( + ClassMember[] members, + boolean allowEmptySelection, + boolean copyJavadocCheckbox, + Project project, + @Nullable Editor editor + ) { MemberChooser chooser = createMembersChooser(members, allowEmptySelection, copyJavadocCheckbox, project); if (editor != null) { - final int offset = editor.getCaretModel().getOffset(); + int offset = editor.getCaretModel().getOffset(); ClassMember preselection = null; for (ClassMember member : members) { - if (member instanceof PsiElementClassMember) { - final PsiDocCommentOwner owner = ((PsiElementClassMember) member).getElement(); - if (owner != null) { - final TextRange textRange = owner.getTextRange(); - if (textRange != null && textRange.contains(offset)) { - preselection = member; - break; - } + if (member instanceof PsiElementClassMember classMember) { + PsiDocCommentOwner owner = classMember.getElement(); + if (owner != null && owner.getTextRange().contains(offset)) { + preselection = classMember; + break; } } } @@ -266,18 +284,24 @@ protected ClassMember[] chooseMembers(ClassMember[] members, boolean allowEmptyS chooser.show(); myToCopyJavaDoc = chooser.isCopyJavadoc(); - final List list = chooser.getSelectedElements(); + List list = chooser.getSelectedElements(); return list == null ? null : list.toArray(new ClassMember[list.size()]); } - protected MemberChooser createMembersChooser(ClassMember[] members, boolean allowEmptySelection, boolean copyJavadocCheckbox, Project project) { - MemberChooser chooser = new MemberChooser(members, allowEmptySelection, true, project, false, getHeaderPanel(project)) { - @Nullable - @Override - protected String getHelpId() { - return GenerateMembersHandlerBase.this.getHelpId(); - } - }; + protected MemberChooser createMembersChooser( + ClassMember[] members, + boolean allowEmptySelection, + boolean copyJavadocCheckbox, + Project project + ) { + MemberChooser chooser = + new MemberChooser<>(members, allowEmptySelection, true, project, false, getHeaderPanel(project)) { + @Nullable + @Override + protected String getHelpId() { + return GenerateMembersHandlerBase.this.getHelpId(); + } + }; chooser.setTitle(myChooserTitle); chooser.setCopyJavadocVisible(copyJavadocCheckbox); return chooser; @@ -293,8 +317,9 @@ protected String getHelpId() { } @Nonnull - protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) throws IncorrectOperationException { - ArrayList array = new ArrayList(); + protected List generateMemberPrototypes(PsiClass aClass, ClassMember[] members) + throws IncorrectOperationException { + List array = new ArrayList<>(); for (ClassMember member : members) { GenerationInfo[] prototypes = generateMemberPrototypes(aClass, member); if (prototypes != null) { @@ -306,7 +331,10 @@ protected List generateMemberPrototypes(PsiClass aClas protected abstract ClassMember[] getAllOriginalMembers(PsiClass aClass); - protected abstract GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember originalMember) throws IncorrectOperationException; + protected abstract GenerationInfo[] generateMemberPrototypes( + PsiClass aClass, + ClassMember originalMember + ) throws IncorrectOperationException; @Override public boolean startInWriteAction() { diff --git a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateSetterHandler.java b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateSetterHandler.java index 13b4f59480..d2313cd632 100644 --- a/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateSetterHandler.java +++ b/plugin/src/main/java/com/intellij/java/impl/codeInsight/generation/GenerateSetterHandler.java @@ -19,7 +19,7 @@ import com.intellij.java.language.impl.codeInsight.generation.GenerationInfo; import com.intellij.java.language.impl.codeInsight.generation.PropertyClassMember; import com.intellij.java.language.psi.PsiClass; -import consulo.java.analysis.codeInsight.JavaCodeInsightBundle; +import consulo.java.analysis.codeInsight.localize.JavaCodeInsightLocalize; import consulo.language.editor.generation.ClassMember; import consulo.language.editor.localize.CodeInsightLocalize; import consulo.language.util.IncorrectOperationException; @@ -29,40 +29,44 @@ import javax.swing.*; public class GenerateSetterHandler extends GenerateGetterSetterHandlerBase { + public GenerateSetterHandler() { + super(CodeInsightLocalize.generateSetterFieldsChooserTitle()); + } - public GenerateSetterHandler() { - super(CodeInsightLocalize.generateSetterFieldsChooserTitle().get()); - } - - @Nullable - @Override - protected JComponent getHeaderPanel(final Project project) { - return getHeaderPanel(project, SetterTemplatesManager.getInstance(), JavaCodeInsightBundle.message("generate.equals.hashcode.template")); - } + @Nullable + @Override + protected JComponent getHeaderPanel(Project project) { + return getHeaderPanel( + project, + SetterTemplatesManager.getInstance(), + JavaCodeInsightLocalize.generateEqualsHashcodeTemplate().get() + ); + } - @Override - protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { - if (original instanceof PropertyClassMember propertyClassMember) { - final GenerationInfo[] getters = propertyClassMember.generateSetters(aClass); - if (getters != null) { - return getters; - } - } else if (original instanceof EncapsulatableClassMember encapsulatableClassMember) { - final GenerationInfo setter = encapsulatableClassMember.generateSetter(); - if (setter != null) { - return new GenerationInfo[]{setter}; - } + @Override + protected GenerationInfo[] generateMemberPrototypes(PsiClass aClass, ClassMember original) throws IncorrectOperationException { + if (original instanceof PropertyClassMember propertyClassMember) { + GenerationInfo[] getters = propertyClassMember.generateSetters(aClass); + if (getters != null) { + return getters; + } + } + else if (original instanceof EncapsulatableClassMember encapsulatableClassMember) { + GenerationInfo setter = encapsulatableClassMember.generateSetter(); + if (setter != null) { + return new GenerationInfo[]{setter}; + } + } + return GenerationInfo.EMPTY_ARRAY; } - return GenerationInfo.EMPTY_ARRAY; - } - @Override - protected String getNothingFoundMessage() { - return "No fields have been found to generate setters for"; - } + @Override + protected String getNothingFoundMessage() { + return "No fields have been found to generate setters for"; + } - @Override - protected String getNothingAcceptedMessage() { - return "No fields without setter were found"; - } + @Override + protected String getNothingAcceptedMessage() { + return "No fields without setter were found"; + } }