/
GetterFieldProcessor.java
152 lines (129 loc) · 6.1 KB
/
GetterFieldProcessor.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package de.plushnikov.intellij.plugin.processor.field;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.PsiAnnotation;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiField;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
import com.intellij.psi.PsiModifierList;
import com.intellij.psi.PsiType;
import de.plushnikov.intellij.plugin.problem.ProblemBuilder;
import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage;
import de.plushnikov.intellij.plugin.psi.LombokLightMethodBuilder;
import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory;
import de.plushnikov.intellij.plugin.thirdparty.LombokUtils;
import de.plushnikov.intellij.plugin.util.LombokProcessorUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil;
import de.plushnikov.intellij.plugin.util.PsiClassUtil;
import de.plushnikov.intellij.plugin.util.PsiMethodUtil;
import lombok.Getter;
import org.jetbrains.annotations.NotNull;
import java.lang.annotation.Annotation;
import java.util.Collection;
import java.util.List;
/**
* Inspect and validate @Getter lombok annotation on a field
* Creates getter method for this field
*
* @author Plushnikov Michail
*/
public class GetterFieldProcessor extends AbstractFieldProcessor {
public GetterFieldProcessor() {
super(Getter.class, PsiMethod.class);
}
protected GetterFieldProcessor(@NotNull Class<? extends Annotation> supportedAnnotationClass, @NotNull Class<? extends PsiElement> supportedClass) {
super(supportedAnnotationClass, supportedClass);
}
protected void generatePsiElements(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {
final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation);
final PsiClass psiClass = psiField.getContainingClass();
if (null != methodVisibility && null != psiClass) {
target.add(createGetterMethod(psiField, psiClass, methodVisibility));
}
}
@Override
protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
boolean result;
final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation);
result = null != methodVisibility;
final boolean lazy = isLazyGetter(psiAnnotation);
if (null == methodVisibility && lazy) {
builder.addWarning("'lazy' does not work with AccessLevel.NONE.");
}
if (result && lazy) {
if (!psiField.hasModifierProperty(PsiModifier.FINAL) || !psiField.hasModifierProperty(PsiModifier.PRIVATE)) {
builder.addError("'lazy' requires the field to be private and final",
PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.PRIVATE, true, false),
PsiQuickFixFactory.createModifierListFix(psiField, PsiModifier.FINAL, true, false));
result = false;
}
if (null == psiField.getInitializer()) {
builder.addError("'lazy' requires field initialization.");
result = false;
}
}
if (result) {
result = validateExistingMethods(psiField, builder);
}
if (result) {
result = validateAccessorPrefix(psiField, builder);
}
return result;
}
protected boolean isLazyGetter(@NotNull PsiAnnotation psiAnnotation) {
return PsiAnnotationUtil.getBooleanAnnotationValue(psiAnnotation, "lazy", false);
}
protected boolean validateExistingMethods(@NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
boolean result = true;
final PsiClass psiClass = psiField.getContainingClass();
if (null != psiClass) {
final boolean isBoolean = PsiType.BOOLEAN.equals(psiField.getType());
final AccessorsInfo accessorsInfo = AccessorsInfo.build(psiField);
final Collection<String> methodNames = LombokUtils.toAllGetterNames(accessorsInfo, psiField.getName(), isBoolean);
final Collection<PsiMethod> classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
filterToleratedElements(classMethods);
for (String methodName : methodNames) {
if (PsiMethodUtil.hasSimilarMethod(classMethods, methodName, 0)) {
final String setterMethodName = getGetterName(psiField);
builder.addWarning("Not generated '%s'(): A method with similar name '%s' already exists", setterMethodName, methodName);
result = false;
}
}
}
return result;
}
protected boolean validateAccessorPrefix(@NotNull PsiField psiField, @NotNull ProblemBuilder builder) {
boolean result = true;
if (!AccessorsInfo.build(psiField).prefixDefinedAndStartsWith(psiField.getName())) {
builder.addWarning("Not generating getter for this field: It does not fit your @Accessors prefix list.");
result = false;
}
return result;
}
@NotNull
public PsiMethod createGetterMethod(@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier) {
final String methodName = getGetterName(psiField);
LombokLightMethodBuilder method = new LombokLightMethodBuilder(psiField.getManager(), methodName)
.withMethodReturnType(psiField.getType())
.withContainingClass(psiClass)
.withNavigationElement(psiField);
if (StringUtil.isNotEmpty(methodModifier)) {
method.withModifier(methodModifier);
}
boolean isStatic = psiField.hasModifierProperty(PsiModifier.STATIC);
if (isStatic) {
method.withModifier(PsiModifier.STATIC);
}
method.withBody(PsiMethodUtil.createCodeBlockFromText(String.format("return %s.%s;", isStatic ? psiClass.getName() : "this", psiField.getName()), psiClass));
PsiModifierList modifierList = method.getModifierList();
copyAnnotations(psiField, modifierList,
LombokUtils.NON_NULL_PATTERN, LombokUtils.NULLABLE_PATTERN, LombokUtils.DEPRECATED_PATTERN);
addOnXAnnotations(PsiAnnotationUtil.findAnnotation(psiField, Getter.class), modifierList, "onMethod");
return method;
}
@Override
public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) {
return LombokPsiElementUsage.READ;
}
}