package de.plushnikov.intellij.lombok.processor.clazz;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.jetbrains.annotations.NotNull;
import com.intellij.psi.Modifier;
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.lombok.LombokConstants;
import de.plushnikov.intellij.lombok.problem.ProblemBuilder;
import de.plushnikov.intellij.lombok.processor.field.SetterFieldProcessor;
import de.plushnikov.intellij.lombok.util.LombokProcessorUtil;
import de.plushnikov.intellij.lombok.util.PsiClassUtil;
import de.plushnikov.intellij.lombok.util.PsiMethodUtil;
import de.plushnikov.intellij.lombok.util.PsiPrimitiveTypeFactory;
import lombok.Setter;
/**
* Inspect and validate @Setter lombok annotation on a class
* Creates setter methods for fields of this class
*
* @author Plushnikov Michail
*/
public class SetterProcessor extends AbstractLombokClassProcessor {
private final SetterFieldProcessor fieldProcessor = new SetterFieldProcessor();
public SetterProcessor() {
this(Setter.class, PsiMethod.class);
}
protected SetterProcessor(@NotNull Class<? extends Annotation> supportedAnnotationClass, @NotNull Class<?> supportedClass) {
super(supportedAnnotationClass, supportedClass);
}
protected SetterFieldProcessor getFieldProcessor() {
return fieldProcessor;
}
@Override
protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
return validateAnnotationOnRigthType(psiAnnotation, psiClass, builder) && validateVisibility(psiAnnotation);
}
protected boolean validateAnnotationOnRigthType(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) {
boolean result = true;
if (psiClass.isAnnotationType() || psiClass.isInterface() || psiClass.isEnum()) {
builder.addError(String.format("'@%s' is only supported on a class or field type", psiAnnotation.getQualifiedName()));
result = false;
}
return result;
}
protected boolean validateVisibility(@NotNull PsiAnnotation psiAnnotation) {
final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation);
return null != methodVisibility;
}
protected <Psi extends PsiElement> void processIntern(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List<Psi> target) {
@Modifier final String methodVisibility = LombokProcessorUtil.getMethodModifier(psiAnnotation);
if (methodVisibility != null) {
target.addAll((Collection<? extends Psi>) createFieldSetters(psiClass, methodVisibility));
}
}
public Collection<PsiMethod> createFieldSetters(@NotNull PsiClass psiClass, @Modifier @NotNull String methodModifier) {
Collection<PsiMethod> result = new ArrayList<PsiMethod>();
final PsiMethod[] classMethods = PsiClassUtil.collectClassMethodsIntern(psiClass);
final PsiType booleanType = PsiPrimitiveTypeFactory.getInstance().getBooleanType();
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 &= !hasFieldProcessorAnnotation(modifierList);
//Skip fields that start with $
createSetter &= !psiField.getName().startsWith(LombokConstants.LOMBOK_INTERN_FIELD_MARKER);
//Skip fields if a method with same name already exists
final Collection<String> methodNames = getFieldProcessor().getAllSetterNames(psiField, booleanType.equals(psiField.getType()));
createSetter &= !PsiMethodUtil.hasMethodByName(classMethods, methodNames);
}
if (createSetter) {
result.add(fieldProcessor.createSetterMethod(psiField, methodModifier));
}
}
return result;
}
private boolean hasFieldProcessorAnnotation(PsiModifierList modifierList) {
boolean hasSetterAnnotation = false;
for (PsiAnnotation fieldAnnotation : modifierList.getAnnotations()) {
hasSetterAnnotation |= getFieldProcessor().acceptAnnotation(fieldAnnotation, PsiMethod.class);
}
return hasSetterAnnotation;
}
}