MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2025-12-13 15:52:01 +07:00
Code Issues Packages Projects Releases Wiki Activity

[lombok] IDEA-353161 Prevent calculation of all not relevant fields on each check

Browse Source 
GitOrigin-RevId: b7158a0ea4ca2346c18c1ce7e95d77bf9aa212c1
This commit is contained in:
Michail Plushnikov
2024-05-12 18:12:59 +02:00
committed by intellij-monorepo-bot
parent 7dae9242d9
commit be6ddc2aec
10 changed files with 192 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java
View File

@@ -96,10 +96,10 @@ public final class GetterProcessor extends AbstractClassProcessor {
@NotNull
public Collection<PsiMethod> createFieldGetters(@NotNull PsiClass psiClass, @NotNull String methodModifier, @Nullable String nameHint) {
Collection<PsiMethod> result = new ArrayList<>();
final Collection<PsiField> 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<PsiMethod> 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<String> 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<PsiMethod> 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<String> 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<PsiMethod> 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;
}
}

60
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java
View File

@@ -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<? super PsiElement> target,
protected void generatePsiElements(@NotNull PsiClass psiClass,
@NotNull PsiAnnotation psiAnnotation,
@NotNull List<? super PsiElement> 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<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
filterToleratedElements(classMethods);
SetterFieldProcessor fieldProcessor = getSetterFieldProcessor();
final SetterFieldProcessor fieldProcessor = getSetterFieldProcessor();
final Collection<PsiField> 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<String> 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<PsiMethod> 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<String> 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<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(containingClass);
filterToleratedElements(classMethods);
final SetterFieldProcessor fieldProcessor = getSetterFieldProcessor();
if (shouldGenerateSetter(psiField, fieldProcessor, classMethods)) {
return LombokPsiElementUsage.WRITE;
}
}

40
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java
View File

@@ -125,34 +125,34 @@ public final class WitherProcessor extends AbstractClassProcessor {
Collection<PsiField> 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<PsiField> witherFields = getWitherFields(containingClass);
if (PsiClassUtil.getNames(witherFields).contains(psiField.getName())) {
return LombokPsiElementUsage.READ_WRITE;
}
if (shouldGenerateWither(psiField)) {
return LombokPsiElementUsage.READ_WRITE;
}
return LombokPsiElementUsage.NONE;
}

55
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java
View File

@@ -184,27 +184,30 @@ public abstract class AbstractConstructorClassProcessor extends AbstractClassPro
Collection<PsiField> 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<PsiField> 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) {

4
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AllArgsConstructorProcessor.java
View File

@@ -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;
}
}

17
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/NoArgsConstructorProcessor.java
View File

@@ -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<PsiField> 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;

4
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/RequiredArgsConstructorProcessor.java
View File

@@ -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;
}
}

44
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/AbstractFieldNameConstantsProcessor.java
View File

@@ -49,20 +49,34 @@ public abstract class AbstractFieldNameConstantsProcessor extends AbstractClassP
Collection<PsiMember> filterMembers(@NotNull PsiClass psiClass, PsiAnnotation psiAnnotation) {
final Collection<PsiMember> result = new ArrayList<>();
final boolean onlyExplicitlyIncluded = PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "onlyExplicitlyIncluded", false);
final boolean onlyExplicitlyIncluded = isOnlyExplicitlyIncluded(psiAnnotation);
Collection<? extends PsiMember> 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);
}
}

41
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/fieldnameconstants/FieldNameConstantsOldProcessor.java
View File

@@ -65,7 +65,9 @@ public final class FieldNameConstantsOldProcessor extends AbstractClassProcessor
}
@Override
protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target,
protected void generatePsiElements(@NotNull PsiClass psiClass,
@NotNull PsiAnnotation psiAnnotation,
@NotNull List<? super PsiElement> target,
@Nullable String nameHint) {
final Collection<PsiField> psiFields = filterFields(psiClass);
for (PsiField psiField : psiFields) {
@@ -79,35 +81,34 @@ public final class FieldNameConstantsOldProcessor extends AbstractClassProcessor
private static Collection<PsiField> filterFields(@NotNull PsiClass psiClass) {
final Collection<PsiField> 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;
}
}

10
plugins/lombok/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java
View File

@@ -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;