diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java index ac4fdc6741ff..fb2abd9aaaea 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java @@ -96,10 +96,10 @@ public final class GetterProcessor extends AbstractClassProcessor { @NotNull public Collection createFieldGetters(@NotNull PsiClass psiClass, @NotNull String methodModifier, @Nullable String nameHint) { Collection result = new ArrayList<>(); + final Collection getterFields = filterGetterFields(psiClass); - GetterFieldProcessor fieldProcessor = getGetterFieldProcessor(); for (PsiField getterField : getterFields) { - ContainerUtil.addIfNotNull(result, fieldProcessor.createGetterMethod(getterField, psiClass, methodModifier, nameHint)); + ContainerUtil.addIfNotNull(result, GetterFieldProcessor.createGetterMethod(getterField, psiClass, methodModifier, nameHint)); } return result; } @@ -111,39 +111,51 @@ public final class GetterProcessor extends AbstractClassProcessor { final Collection classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass); filterToleratedElements(classMethods); + final GetterFieldProcessor fieldProcessor = getGetterFieldProcessor(); final AccessorsInfo.AccessorsValues classAccessorsValues = AccessorsInfo.getAccessorsValues(psiClass); - GetterFieldProcessor fieldProcessor = getGetterFieldProcessor(); for (PsiField psiField : psiClass.getFields()) { - boolean createGetter = true; - PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - //Skip static fields. - createGetter = !modifierList.hasModifierProperty(PsiModifier.STATIC); - //Skip fields having Getter annotation already - createGetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); - //Skip fields that start with $ - createGetter &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); - //Skip fields if a method with same name and arguments count already exists - final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField, classAccessorsValues); - final Collection methodNames = - LombokUtils.toAllGetterNames(accessorsInfo, psiField.getName(), PsiTypes.booleanType().equals(psiField.getType())); - for (String methodName : methodNames) { - createGetter &= !PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 0); - } - } - - if (createGetter) { + if (shouldCreateGetter(psiField, fieldProcessor, classAccessorsValues, classMethods)) { getterFields.add(psiField); } } return getterFields; } + private static boolean shouldCreateGetter(@NotNull PsiField psiField, + @NotNull GetterFieldProcessor fieldProcessor, + @NotNull AccessorsInfo.AccessorsValues classAccessorsValues, + @NotNull Collection classMethods) { + boolean createGetter = true; + PsiModifierList modifierList = psiField.getModifierList(); + if (null != modifierList) { + //Skip static fields. + createGetter = !modifierList.hasModifierProperty(PsiModifier.STATIC); + //Skip fields having Getter annotation already + createGetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); + //Skip fields that start with $ + createGetter &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); + //Skip fields if a method with same name and arguments count already exists + final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField, classAccessorsValues); + final Collection methodNames = + LombokUtils.toAllGetterNames(accessorsInfo, psiField.getName(), PsiTypes.booleanType().equals(psiField.getType())); + for (String methodName : methodNames) { + createGetter &= !PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 0); + } + } + return createGetter; + } + @Override public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { - if (PsiClassUtil.getNames(filterGetterFields(containingClass)).contains(psiField.getName())) { + final Collection classMethods = PsiClassUtil.collectClassMethodsIntern(containingClass); + filterToleratedElements(classMethods); + + final AccessorsInfo.AccessorsValues classAccessorsValues = AccessorsInfo.getAccessorsValues(containingClass); + final GetterFieldProcessor fieldProcessor = getGetterFieldProcessor(); + + if (shouldCreateGetter(psiField, fieldProcessor, classAccessorsValues, classMethods)) { return LombokPsiElementUsage.READ; } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java index 010df2ad3756..747b66597faf 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java @@ -68,8 +68,8 @@ public final class SetterProcessor extends AbstractClassProcessor { } private static void validateAnnotationOnRightType(@NotNull PsiAnnotation psiAnnotation, - @NotNull PsiClass psiClass, - @NotNull ProblemSink builder) { + @NotNull PsiClass psiClass, + @NotNull ProblemSink builder) { if (psiClass.isAnnotationType() || psiClass.isInterface() || psiClass.isEnum()) { builder.addErrorMessage("inspection.message.s.only.supported.on.class.or.field.type", psiAnnotation.getQualifiedName()); builder.markFailed(); @@ -77,13 +77,15 @@ public final class SetterProcessor extends AbstractClassProcessor { } private static void validateVisibility(@NotNull PsiAnnotation psiAnnotation, @NotNull ProblemSink builder) { - if(null == LombokProcessorUtil.getMethodModifier(psiAnnotation)) { + if (null == LombokProcessorUtil.getMethodModifier(psiAnnotation)) { builder.markFailed(); } } @Override - protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List target, + protected void generatePsiElements(@NotNull PsiClass psiClass, + @NotNull PsiAnnotation psiAnnotation, + @NotNull List target, @Nullable String nameHint) { final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation); if (methodVisibility != null) { @@ -107,38 +109,48 @@ public final class SetterProcessor extends AbstractClassProcessor { final Collection classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass); filterToleratedElements(classMethods); - SetterFieldProcessor fieldProcessor = getSetterFieldProcessor(); + final SetterFieldProcessor fieldProcessor = getSetterFieldProcessor(); final Collection setterFields = new ArrayList<>(); for (PsiField psiField : psiClass.getFields()) { - boolean createSetter = true; - PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - //Skip final fields. - createSetter = !modifierList.hasModifierProperty(PsiModifier.FINAL); - //Skip static fields. - createSetter &= !modifierList.hasModifierProperty(PsiModifier.STATIC); - //Skip fields having Setter annotation already - createSetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); - //Skip fields that start with $ - createSetter &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); - //Skip fields if a method with same name already exists - final Collection methodNames = fieldProcessor.getAllSetterNames(psiField, PsiTypes.booleanType().equals(psiField.getType())); - for (String methodName : methodNames) { - createSetter &= !PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 1); - } - } - if (createSetter) { + if (shouldGenerateSetter(psiField, fieldProcessor, classMethods)) { setterFields.add(psiField); } } return setterFields; } + private static boolean shouldGenerateSetter(@NotNull PsiField psiField, @NotNull SetterFieldProcessor fieldProcessor, + @NotNull Collection classMethods) { + boolean createSetter = true; + PsiModifierList modifierList = psiField.getModifierList(); + if (null != modifierList) { + //Skip final fields. + createSetter = !modifierList.hasModifierProperty(PsiModifier.FINAL); + //Skip static fields. + createSetter &= !modifierList.hasModifierProperty(PsiModifier.STATIC); + //Skip fields having Setter annotation already + createSetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); + //Skip fields that start with $ + createSetter &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); + //Skip fields if a method with same name already exists + final Collection methodNames = fieldProcessor.getAllSetterNames(psiField, PsiTypes.booleanType().equals(psiField.getType())); + for (String methodName : methodNames) { + createSetter &= !PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 1); + } + } + return createSetter; + } + @Override public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { - if (PsiClassUtil.getNames(filterSetterFields(containingClass)).contains(psiField.getName())) { + final Collection classMethods = PsiClassUtil.collectClassMethodsIntern(containingClass); + filterToleratedElements(classMethods); + + final SetterFieldProcessor fieldProcessor = getSetterFieldProcessor(); + + if (shouldGenerateSetter(psiField, fieldProcessor, classMethods)) { return LombokPsiElementUsage.WRITE; } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java index 3f10fb3ad056..54d0a2868f31 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java @@ -125,34 +125,34 @@ public final class WitherProcessor extends AbstractClassProcessor { Collection witherFields = new ArrayList<>(); for (PsiField psiField : psiClass.getFields()) { - boolean createWither = true; - PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - // Skip static fields. - createWither = !modifierList.hasModifierProperty(PsiModifier.STATIC); - // Skip final fields that are initialized and not annotated with @Builder.Default - createWither &= !(modifierList.hasModifierProperty(PsiModifier.FINAL) && psiField.hasInitializer() && - PsiAnnotationSearchUtil.findAnnotation(psiField, BUILDER_DEFAULT_ANNOTATION) == null); - // Skip fields that start with $ - createWither &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); - // Skip fields having Wither annotation already - createWither &= !PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokClassNames.WITHER, LombokClassNames.WITH); - } - if (createWither) { + if (shouldGenerateWither(psiField)) { witherFields.add(psiField); } } return witherFields; } + private static boolean shouldGenerateWither(@NotNull PsiField psiField) { + boolean createWither = true; + PsiModifierList modifierList = psiField.getModifierList(); + if (null != modifierList) { + // Skip static fields. + createWither = !modifierList.hasModifierProperty(PsiModifier.STATIC); + // Skip final fields that are initialized and not annotated with @Builder.Default + createWither &= !(modifierList.hasModifierProperty(PsiModifier.FINAL) && psiField.hasInitializer() && + PsiAnnotationSearchUtil.findAnnotation(psiField, BUILDER_DEFAULT_ANNOTATION) == null); + // Skip fields that start with $ + createWither &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); + // Skip fields having Wither annotation already + createWither &= !PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokClassNames.WITHER, LombokClassNames.WITH); + } + return createWither; + } + @Override public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { - final PsiClass containingClass = psiField.getContainingClass(); - if (null != containingClass) { - final Collection witherFields = getWitherFields(containingClass); - if (PsiClassUtil.getNames(witherFields).contains(psiField.getName())) { - return LombokPsiElementUsage.READ_WRITE; - } + if (shouldGenerateWither(psiField)) { + return LombokPsiElementUsage.READ_WRITE; } return LombokPsiElementUsage.NONE; } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java index 69d0033c439a..f8e8cdbb6ee2 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java @@ -184,27 +184,30 @@ public abstract class AbstractConstructorClassProcessor extends AbstractClassPro Collection fields = psiClass.isRecord() ? RecordAugmentProvider.getFieldAugments(psiClass) : PsiClassUtil.collectClassFieldsIntern(psiClass); for (PsiField psiField : fields) { - // skip fields named $ - boolean addField = !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); - - final PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - // skip static fields - addField &= !modifierList.hasModifierProperty(PsiModifier.STATIC); - - boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); - // skip initialized final fields - addField &= (!isFinal || !psiField.hasInitializer() || - PsiAnnotationSearchUtil.findAnnotation(psiField, BUILDER_DEFAULT_ANNOTATION) != null); - } - - if (addField) { + if (isNotInitializedAndNotStaticField(psiField, classAnnotatedWithValue)) { allNotInitializedNotStaticFields.add(psiField); } } return allNotInitializedNotStaticFields; } + static boolean isNotInitializedAndNotStaticField(@NotNull PsiField psiField, boolean classAnnotatedWithValue) { + // skip fields named $ + boolean addField = !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); + + final PsiModifierList modifierList = psiField.getModifierList(); + if (null != modifierList) { + // skip static fields + addField &= !modifierList.hasModifierProperty(PsiModifier.STATIC); + + boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); + // skip initialized final fields + addField &= (!isFinal || !psiField.hasInitializer() || + PsiAnnotationSearchUtil.findAnnotation(psiField, BUILDER_DEFAULT_ANNOTATION) != null); + } + return addField; + } + @NotNull public static Collection getAllFields(@NotNull PsiClass psiClass) { return getAllNotInitializedAndNotStaticFields(psiClass); @@ -221,19 +224,25 @@ public abstract class AbstractConstructorClassProcessor extends AbstractClassPro final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, LombokClassNames.VALUE); for (PsiField psiField : getAllNotInitializedAndNotStaticFields(psiClass)) { - final PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - final boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); - final boolean isNonNull = !ignoreNonNull && PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokUtils.NONNULL_ANNOTATIONS); - // accept initialized final or nonnull fields - if ((isFinal || isNonNull) && !psiField.hasInitializer()) { - result.add(psiField); - } + if (isRequiredField(psiField, ignoreNonNull, classAnnotatedWithValue)) { + result.add(psiField); } } return result; } + static boolean isRequiredField(@NotNull PsiField psiField, boolean ignoreNonNull, boolean classAnnotatedWithValue) { + final PsiModifierList modifierList = psiField.getModifierList(); + boolean shouldAddField = false; + if (null != modifierList) { + final boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); + final boolean isNonNull = !ignoreNonNull && PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokUtils.NONNULL_ANNOTATIONS); + // accept initialized final or nonnull fields + shouldAddField = (isFinal || isNonNull) && !psiField.hasInitializer(); + } + return shouldAddField; + } + private static boolean isFieldFinal(@NotNull PsiField psiField, @NotNull PsiModifierList modifierList, boolean classAnnotatedWithValue) { boolean isFinal = modifierList.hasModifierProperty(PsiModifier.FINAL); if (!isFinal && classAnnotatedWithValue) { diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AllArgsConstructorProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AllArgsConstructorProcessor.java index 02fcd8fbcb4b..840b04fd5d82 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AllArgsConstructorProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AllArgsConstructorProcessor.java @@ -5,6 +5,7 @@ import de.plushnikov.intellij.plugin.LombokClassNames; import de.plushnikov.intellij.plugin.problem.ProblemSink; import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage; import de.plushnikov.intellij.plugin.util.LombokProcessorUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -64,7 +65,8 @@ public final class AllArgsConstructorProcessor extends AbstractConstructorClassP public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { - if (PsiClassUtil.getNames(getAllNotInitializedAndNotStaticFields(containingClass)).contains(psiField.getName())) { + final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(containingClass, LombokClassNames.VALUE); + if (isNotInitializedAndNotStaticField(psiField, classAnnotatedWithValue)) { return LombokPsiElementUsage.WRITE; } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/NoArgsConstructorProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/NoArgsConstructorProcessor.java index 1a0ac2a08235..032b2b0c49fb 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/NoArgsConstructorProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/NoArgsConstructorProcessor.java @@ -6,6 +6,7 @@ import de.plushnikov.intellij.plugin.problem.ProblemSink; import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage; import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory; import de.plushnikov.intellij.plugin.util.LombokProcessorUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; @@ -78,14 +79,14 @@ public final class NoArgsConstructorProcessor extends AbstractConstructorClassPr @Override public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { - final PsiClass containingClass = psiField.getContainingClass(); - if (null != containingClass) { - - final boolean forceConstructorWithJavaDefaults = isForceConstructor(psiAnnotation); - final Collection params = getConstructorFields(containingClass, forceConstructorWithJavaDefaults); - - if (PsiClassUtil.getNames(params).contains(psiField.getName())) { - return LombokPsiElementUsage.WRITE; + final boolean forceConstructorWithJavaDefaults = isForceConstructor(psiAnnotation); + if(forceConstructorWithJavaDefaults) { + final PsiClass containingClass = psiField.getContainingClass(); + if (null != containingClass) { + final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(containingClass, LombokClassNames.VALUE); + if (isRequiredField(psiField, false, classAnnotatedWithValue)) { + return LombokPsiElementUsage.WRITE; + } } } return LombokPsiElementUsage.NONE; diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/RequiredArgsConstructorProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/RequiredArgsConstructorProcessor.java index 7c8ef3e99df7..a01c30d50fb5 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/RequiredArgsConstructorProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/RequiredArgsConstructorProcessor.java @@ -5,6 +5,7 @@ import de.plushnikov.intellij.plugin.LombokClassNames; import de.plushnikov.intellij.plugin.problem.ProblemSink; import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage; import de.plushnikov.intellij.plugin.util.LombokProcessorUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -54,7 +55,8 @@ public final class RequiredArgsConstructorProcessor extends AbstractConstructorC public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { - if (PsiClassUtil.getNames(getRequiredFields(containingClass)).contains(psiField.getName())) { + final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(containingClass, LombokClassNames.VALUE); + if (isRequiredField(psiField, false, classAnnotatedWithValue)) { return LombokPsiElementUsage.WRITE; } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/AbstractFieldNameConstantsProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/AbstractFieldNameConstantsProcessor.java index 16cae9e8892e..2fc6bed59651 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/AbstractFieldNameConstantsProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/AbstractFieldNameConstantsProcessor.java @@ -49,20 +49,34 @@ public abstract class AbstractFieldNameConstantsProcessor extends AbstractClassP Collection filterMembers(@NotNull PsiClass psiClass, PsiAnnotation psiAnnotation) { final Collection result = new ArrayList<>(); - final boolean onlyExplicitlyIncluded = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded", false); + final boolean onlyExplicitlyIncluded = isOnlyExplicitlyIncluded(psiAnnotation); Collection psiMembers; - if(psiClass.isRecord()) { + if (psiClass.isRecord()) { psiMembers = List.of(psiClass.getRecordComponents()); - }else{ - psiMembers = PsiClassUtil.collectClassFieldsIntern(psiClass); + } + else { + psiMembers = PsiClassUtil.collectClassFieldsIntern(psiClass); } for (PsiMember psiMember : psiMembers) { - boolean useField = true; + if (shouldUseField(psiMember, onlyExplicitlyIncluded)) { + result.add(psiMember); + } + } + return result; + } + + private static boolean shouldUseField(@NotNull PsiMember psiMember, boolean onlyExplicitlyIncluded) { + boolean useField = true; + + if (onlyExplicitlyIncluded) { + //Only use fields annotated with @FieldNameConstants.Include, Include annotation overrides other rules + useField = PsiAnnotationSearchUtil.isAnnotatedWith(psiMember, FIELD_NAME_CONSTANTS_INCLUDE); + } + else { PsiModifierList modifierList = psiMember.getModifierList(); if (null != modifierList) { - //Skip static fields. useField = !modifierList.hasModifierProperty(PsiModifier.STATIC); //Skip transient fields @@ -72,17 +86,8 @@ public abstract class AbstractFieldNameConstantsProcessor extends AbstractClassP useField &= !StringUtil.notNullize(psiMember.getName()).startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); //Skip fields annotated with @FieldNameConstants.Exclude useField &= !PsiAnnotationSearchUtil.isAnnotatedWith(psiMember, FIELD_NAME_CONSTANTS_EXCLUDE); - - if (onlyExplicitlyIncluded) { - //Only use fields annotated with @FieldNameConstants.Include, Include annotation overrides other rules - useField = PsiAnnotationSearchUtil.isAnnotatedWith(psiMember, FIELD_NAME_CONSTANTS_INCLUDE); - } - - if (useField) { - result.add(psiMember); - } } - return result; + return useField; } @NotNull @@ -97,10 +102,15 @@ public abstract class AbstractFieldNameConstantsProcessor extends AbstractClassP public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { final PsiClass containingClass = psiField.getContainingClass(); if (null != containingClass) { - if (PsiClassUtil.getNames(filterMembers(containingClass, psiAnnotation)).contains(psiField.getName())) { + final boolean onlyExplicitlyIncluded = isOnlyExplicitlyIncluded(psiAnnotation); + if (shouldUseField(psiField, onlyExplicitlyIncluded)) { return LombokPsiElementUsage.USAGE; } } return LombokPsiElementUsage.NONE; } + + private static boolean isOnlyExplicitlyIncluded(@NotNull PsiAnnotation psiAnnotation) { + return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded", false); + } } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/FieldNameConstantsOldProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/FieldNameConstantsOldProcessor.java index 8a3e1153a242..01a10efcf5a7 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/FieldNameConstantsOldProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/FieldNameConstantsOldProcessor.java @@ -65,7 +65,9 @@ public final class FieldNameConstantsOldProcessor extends AbstractClassProcessor } @Override - protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List target, + protected void generatePsiElements(@NotNull PsiClass psiClass, + @NotNull PsiAnnotation psiAnnotation, + @NotNull List target, @Nullable String nameHint) { final Collection psiFields = filterFields(psiClass); for (PsiField psiField : psiFields) { @@ -79,35 +81,34 @@ public final class FieldNameConstantsOldProcessor extends AbstractClassProcessor private static Collection filterFields(@NotNull PsiClass psiClass) { final Collection psiFields = new ArrayList<>(); - FieldNameConstantsFieldProcessor fieldProcessor = getFieldNameConstantsFieldProcessor(); + final FieldNameConstantsFieldProcessor fieldProcessor = getFieldNameConstantsFieldProcessor(); for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) { - boolean useField = true; - PsiModifierList modifierList = psiField.getModifierList(); - if (null != modifierList) { - //Skip static fields. - useField = !modifierList.hasModifierProperty(PsiModifier.STATIC); - //Skip fields having same annotation already - useField &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); - //Skip fields that start with $ - useField &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); - } - - if (useField) { + if (shouldUseField(psiField, fieldProcessor)) { psiFields.add(psiField); } } return psiFields; } + private static boolean shouldUseField(@NotNull PsiField psiField, @NotNull FieldNameConstantsFieldProcessor fieldProcessor) { + boolean useField = true; + PsiModifierList modifierList = psiField.getModifierList(); + if (null != modifierList) { + //Skip static fields. + useField = !modifierList.hasModifierProperty(PsiModifier.STATIC); + //Skip fields having same annotation already + useField &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClasses()); + //Skip fields that start with $ + useField &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); + } + return useField; + } + @Override public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) { - final PsiClass containingClass = psiField.getContainingClass(); - if (null != containingClass) { - if (PsiClassUtil.getNames(filterFields(containingClass)).contains(psiField.getName())) { - return LombokPsiElementUsage.USAGE; - } + if (shouldUseField(psiField, getFieldNameConstantsFieldProcessor())) { + return LombokPsiElementUsage.USAGE; } return LombokPsiElementUsage.NONE; } - } diff --git a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java index d678e9735ae9..db0cc5080b5b 100644 --- a/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java +++ b/plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java @@ -69,8 +69,8 @@ public final class GetterFieldProcessor extends AbstractFieldProcessor { if (result && lazy) { if (!psiField.hasModifierProperty(PsiModifier.FINAL) || !psiField.hasModifierProperty(PsiModifier.PRIVATE)) { builder.addErrorMessage("inspection.message.lazy.requires.field.to.be.private.final") - .withLocalQuickFixes(()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.PRIVATE, true, false), - ()->PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, true, false)); + .withLocalQuickFixes(() -> PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.PRIVATE, true, false), + () -> PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, true, false)); result = false; } if (!psiField.hasInitializer()) { @@ -107,8 +107,10 @@ public final class GetterFieldProcessor extends AbstractFieldProcessor { @Nullable @Contract("_,_,_,null -> !null") - public PsiMethod createGetterMethod(@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier, - @Nullable String nameHint) { + public static PsiMethod createGetterMethod(@NotNull PsiField psiField, + @NotNull PsiClass psiClass, + @NotNull String methodModifier, + @Nullable String nameHint) { final AccessorsInfo accessorsInfo = AccessorsInfo.buildFor(psiField); final String methodName = LombokUtils.getGetterName(psiField, accessorsInfo); if (nameHint != null && !nameHint.equals(methodName)) return null;