/
ValueProcessor.java
101 lines (88 loc) · 4.7 KB
/
ValueProcessor.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
package de.plushnikov.intellij.plugin.processor.clazz;
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 de.plushnikov.intellij.plugin.problem.ProblemBuilder;
import de.plushnikov.intellij.plugin.problem.ProblemEmptyBuilder;
import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage;
import de.plushnikov.intellij.plugin.processor.clazz.constructor.AllArgsConstructorProcessor;
import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil;
import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil;
import de.plushnikov.intellij.plugin.util.PsiClassUtil;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
import lombok.ToString;
import lombok.Value;
import org.jetbrains.annotations.NotNull;
import java.util.Collection;
import java.util.List;
/**
* @author twillouer
*/
public class ValueProcessor extends AbstractClassProcessor {
private final GetterProcessor getterProcessor;
private final EqualsAndHashCodeProcessor equalsAndHashCodeProcessor;
private final ToStringProcessor toStringProcessor;
private final AllArgsConstructorProcessor allArgsConstructorProcessor;
@SuppressWarnings({"deprecation", "unchecked"})
public ValueProcessor(GetterProcessor getterProcessor, EqualsAndHashCodeProcessor equalsAndHashCodeProcessor,
ToStringProcessor toStringProcessor, AllArgsConstructorProcessor allArgsConstructorProcessor) {
super(PsiMethod.class, Value.class, lombok.experimental.Value.class);
this.getterProcessor = getterProcessor;
this.equalsAndHashCodeProcessor = equalsAndHashCodeProcessor;
this.toStringProcessor = toStringProcessor;
this.allArgsConstructorProcessor = allArgsConstructorProcessor;
}
@Override
protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
final PsiAnnotation equalsAndHashCodeAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, EqualsAndHashCode.class);
if (null == equalsAndHashCodeAnnotation) {
equalsAndHashCodeProcessor.validateCallSuperParamExtern(psiAnnotation, psiClass, builder);
}
return validateAnnotationOnRightType(psiClass, builder);
}
private boolean validateAnnotationOnRightType(@NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
boolean result = true;
if (psiClass.isAnnotationType() || psiClass.isInterface() || psiClass.isEnum()) {
builder.addError("'@Value' is only supported on a class type");
result = false;
}
return result;
}
@SuppressWarnings("deprecation")
protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<? super PsiElement> target) {
if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, Getter.class)) {
target.addAll(getterProcessor.createFieldGetters(psiClass, PsiModifier.PUBLIC));
}
if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) {
target.addAll(equalsAndHashCodeProcessor.createEqualAndHashCode(psiClass, psiAnnotation));
}
if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, ToString.class)) {
target.addAll(toStringProcessor.createToStringMethod(psiClass, psiAnnotation));
}
// create required constructor only if there are no other constructor annotations
if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class,
lombok.experimental.Builder.class, lombok.Builder.class)) {
final Collection<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass);
filterToleratedElements(definedConstructors);
// and only if there are no any other constructors!
if (definedConstructors.isEmpty()) {
final String staticName = PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "staticConstructor");
final Collection<PsiField> requiredFields = allArgsConstructorProcessor.getAllFields(psiClass);
if (allArgsConstructorProcessor.validateIsConstructorNotDefined(psiClass, staticName, requiredFields, ProblemEmptyBuilder.getInstance())) {
target.addAll(allArgsConstructorProcessor.createAllArgsConstructor(psiClass, PsiModifier.PUBLIC, psiAnnotation, staticName, requiredFields));
}
}
}
}
@Override
public LombokPsiElementUsage checkFieldUsage(@NotNull PsiField psiField, @NotNull PsiAnnotation psiAnnotation) {
return LombokPsiElementUsage.READ_WRITE;
}
}