diff --git a/src/main/java/de/plushnikov/intellij/plugin/action/lombok/BaseLombokHandler.java b/src/main/java/de/plushnikov/intellij/plugin/action/lombok/BaseLombokHandler.java index 305e42a0b..004e1f698 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/action/lombok/BaseLombokHandler.java +++ b/src/main/java/de/plushnikov/intellij/plugin/action/lombok/BaseLombokHandler.java @@ -21,6 +21,7 @@ import com.intellij.psi.codeStyle.JavaCodeStyleManager; import com.intellij.psi.util.PsiUtil; import de.plushnikov.intellij.plugin.util.LombokProcessorUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -80,7 +81,7 @@ protected void processIntern(@NotNull Map fieldMethodMap, @ } private boolean isNotAnnotatedWithOrSameAccessLevelAs(PsiClass psiClass, PsiMethod firstPropertyMethod, Class annotationClass) { - final PsiAnnotation presentAnnotation = PsiAnnotationUtil.findAnnotation(psiClass, annotationClass); + final PsiAnnotation presentAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, annotationClass); if (null != presentAnnotation) { final String presentAccessModifier = LombokProcessorUtil.getMethodModifier(presentAnnotation); @@ -115,7 +116,7 @@ protected void addAnnotation(@NotNull PsiClass targetElement, @NotNull Class annotationClass) { - final PsiAnnotation presentAnnotation = PsiAnnotationUtil.findAnnotation(targetElement, annotationClass); + final PsiAnnotation presentAnnotation = PsiAnnotationSearchUtil.findAnnotation(targetElement, annotationClass); final Project project = targetElement.getProject(); final JavaCodeStyleManager javaCodeStyleManager = JavaCodeStyleManager.getInstance(project); @@ -133,7 +134,7 @@ private void addAnnotation(@NotNull PsiModifierListOwner targetElement, @NotNull } protected void removeDefaultAnnotation(@NotNull PsiModifierListOwner targetElement, @NotNull Class annotationClass) { - final PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(targetElement, annotationClass); + final PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(targetElement, annotationClass); if (null != psiAnnotation) { boolean hasOnlyDefaultValues = true; diff --git a/src/main/java/de/plushnikov/intellij/plugin/extension/LombokElementFinder.java b/src/main/java/de/plushnikov/intellij/plugin/extension/LombokElementFinder.java index a1e3ed5ca..2b24c8bec 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/extension/LombokElementFinder.java +++ b/src/main/java/de/plushnikov/intellij/plugin/extension/LombokElementFinder.java @@ -7,7 +7,7 @@ import com.intellij.psi.PsiMethod; import com.intellij.psi.impl.file.impl.JavaFileManager; import com.intellij.psi.search.GlobalSearchScope; -import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import lombok.Builder; import org.jetbrains.annotations.NotNull; @@ -40,12 +40,12 @@ public PsiClass findClass(@NotNull String qualifiedName, @NotNull GlobalSearchSc if (null != javaFileManager) { final PsiClass parentClass = javaFileManager.findClass(parentName, scope); if (null != parentClass) { - if (PsiAnnotationUtil.isAnnotatedWith(parentClass, Builder.class, lombok.experimental.Builder.class)) { + if (PsiAnnotationSearchUtil.isAnnotatedWith(parentClass, Builder.class, lombok.experimental.Builder.class)) { return parentClass.findInnerClassByName(shortName, false); } else { final Collection psiMethods = PsiClassUtil.collectClassMethodsIntern(parentClass); for (PsiMethod psiMethod : psiMethods) { - if (PsiAnnotationUtil.isAnnotatedWith(psiMethod, Builder.class, lombok.experimental.Builder.class)) { + if (PsiAnnotationSearchUtil.isAnnotatedWith(psiMethod, Builder.class, lombok.experimental.Builder.class)) { return parentClass.findInnerClassByName(shortName, false); } } diff --git a/src/main/java/de/plushnikov/intellij/plugin/handler/LazyGetterHandler.java b/src/main/java/de/plushnikov/intellij/plugin/handler/LazyGetterHandler.java index 11d7790cf..886c51681 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/handler/LazyGetterHandler.java +++ b/src/main/java/de/plushnikov/intellij/plugin/handler/LazyGetterHandler.java @@ -7,13 +7,12 @@ import com.intellij.psi.PsiFile; import com.intellij.psi.PsiIdentifier; import com.intellij.psi.util.PsiTreeUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import lombok.Getter; public class LazyGetterHandler { - private static final String GETTERN_FQN = Getter.class.getName(); - public static boolean isLazyGetterHandled(HighlightInfo highlightInfo, PsiFile file) { PsiElement element = file.findElementAt(highlightInfo.getStartOffset()); if (!(element instanceof PsiIdentifier)) { @@ -24,7 +23,7 @@ public static boolean isLazyGetterHandled(HighlightInfo highlightInfo, PsiFile f return false; } - final PsiAnnotation getterAnnotation = PsiAnnotationUtil.findAnnotation(field, GETTERN_FQN); + final PsiAnnotation getterAnnotation = PsiAnnotationSearchUtil.findAnnotation(field, Getter.class); return null != getterAnnotation && PsiAnnotationUtil.getBooleanAnnotationValue(getterAnnotation, "lazy", false); } } diff --git a/src/main/java/de/plushnikov/intellij/plugin/handler/SneakyThrowsExceptionHandler.java b/src/main/java/de/plushnikov/intellij/plugin/handler/SneakyThrowsExceptionHandler.java index 1b2b4d06f..e4f23e031 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/handler/SneakyThrowsExceptionHandler.java +++ b/src/main/java/de/plushnikov/intellij/plugin/handler/SneakyThrowsExceptionHandler.java @@ -10,6 +10,7 @@ import com.intellij.psi.PsiModifierListOwner; import com.intellij.psi.PsiType; import com.intellij.psi.util.PsiTreeUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import lombok.SneakyThrows; import org.jetbrains.annotations.NotNull; @@ -18,7 +19,6 @@ import java.util.Collection; public class SneakyThrowsExceptionHandler extends CustomExceptionHandler { - private static final String ANNOTATION_FQN = SneakyThrows.class.getName(); private static final String JAVA_LANG_THROWABLE = "java.lang.Throwable"; @@ -31,8 +31,8 @@ public boolean isHandled(@Nullable PsiElement element, @NotNull PsiClassType exc return false; } - public boolean isExceptionHandled(@NotNull PsiModifierListOwner psiModifierListOwner, PsiClassType exceptionClassType) { - final PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiModifierListOwner, ANNOTATION_FQN); + private boolean isExceptionHandled(@NotNull PsiModifierListOwner psiModifierListOwner, PsiClassType exceptionClassType) { + final PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiModifierListOwner, SneakyThrows.class); if (psiAnnotation == null) { return false; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/AbstractProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/AbstractProcessor.java index 48df46cfb..0603c4b6a 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/AbstractProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/AbstractProcessor.java @@ -13,6 +13,7 @@ import de.plushnikov.intellij.plugin.processor.field.AccessorsInfo; import de.plushnikov.intellij.plugin.thirdparty.LombokUtils; import de.plushnikov.intellij.plugin.util.LombokProcessorUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import lombok.experimental.Tolerate; import org.jetbrains.annotations.NotNull; @@ -93,7 +94,7 @@ protected void filterToleratedElements(@NotNull Collection methodIterator = definedMethods.iterator(); while (methodIterator.hasNext()) { PsiModifierListOwner definedMethod = methodIterator.next(); - if (PsiAnnotationUtil.isAnnotatedWith(definedMethod, Tolerate.class)) { + if (PsiAnnotationSearchUtil.isAnnotatedWith(definedMethod, Tolerate.class)) { methodIterator.remove(); } } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/AbstractClassProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/AbstractClassProcessor.java index 60498609b..3d37decef 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/AbstractClassProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/AbstractClassProcessor.java @@ -15,6 +15,7 @@ import de.plushnikov.intellij.plugin.processor.AbstractProcessor; import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory; import de.plushnikov.intellij.plugin.thirdparty.LombokUtils; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -43,7 +44,7 @@ protected AbstractClassProcessor(@NotNull Class supportedA public List process(@NotNull PsiClass psiClass) { List result = Collections.emptyList(); - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiClass, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClass()); if (null != psiAnnotation) { if (validate(psiAnnotation, psiClass, ProblemEmptyBuilder.getInstance())) { result = new ArrayList(); @@ -56,7 +57,7 @@ public List process(@NotNull PsiClass psiClass) { @NotNull public Collection collectProcessedAnnotations(@NotNull PsiClass psiClass) { Collection result = new ArrayList(); - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiClass, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClass()); if (null != psiAnnotation) { result.add(psiAnnotation); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/DataProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/DataProcessor.java index 229ab0ffd..7f5fdbc7a 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/DataProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/DataProcessor.java @@ -11,6 +11,7 @@ import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage; import de.plushnikov.intellij.plugin.processor.clazz.constructor.RequiredArgsConstructorProcessor; import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import lombok.AllArgsConstructor; @@ -55,7 +56,7 @@ protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiCla } protected void validateCallSuperParam(PsiAnnotation psiAnnotation, PsiClass psiClass, ProblemBuilder builder, String generatedMethodName) { - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { if (PsiClassUtil.hasSuperClass(psiClass)) { builder.addWarning("Generating " + generatedMethodName + " implementation but without a call to superclass" + "If this is not intentional, add '@EqualsAndHashCode(callSuper=true)' to your type.", @@ -74,20 +75,20 @@ private boolean validateAnnotationOnRightType(@NotNull PsiClass psiClass, @NotNu } protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List target) { - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, Getter.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, Getter.class)) { target.addAll(getterProcessor.createFieldGetters(psiClass, PsiModifier.PUBLIC)); } - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, Setter.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, Setter.class)) { target.addAll(setterProcessor.createFieldSetters(psiClass, PsiModifier.PUBLIC)); } - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { target.addAll(equalsAndHashCodeProcessor.createEqualAndHashCode(psiClass, psiAnnotation)); } - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, ToString.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, ToString.class)) { target.addAll(toStringProcessor.createToStringMethod(psiClass, psiAnnotation)); } // create required constructor only if there are no other constructor annotations - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class)) { final Collection definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); filterToleratedElements(definedConstructors); diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/EqualsAndHashCodeProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/EqualsAndHashCodeProcessor.java index 27cb5c783..4ee738b61 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/EqualsAndHashCodeProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/EqualsAndHashCodeProcessor.java @@ -20,6 +20,7 @@ import de.plushnikov.intellij.plugin.psi.LombokLightMethodBuilder; import de.plushnikov.intellij.plugin.psi.LombokLightParameter; import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -129,7 +130,7 @@ private boolean shouldGenerateCanEqual(@NotNull PsiClass psiClass) { } final boolean isFinal = psiClass.hasModifierProperty(PsiModifier.FINAL) || - (PsiAnnotationUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class) && PsiAnnotationUtil.isNotAnnotatedWith(psiClass, NonFinal.class)); + (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class) && PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NonFinal.class)); return !isFinal; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java index d1c2fd5c0..2f3888f25 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/GetterProcessor.java @@ -14,6 +14,7 @@ import de.plushnikov.intellij.plugin.processor.field.GetterFieldProcessor; import de.plushnikov.intellij.plugin.thirdparty.LombokUtils; 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 de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -95,7 +96,7 @@ private Collection filterGetterFields(@NotNull PsiClass psiClass) { //Skip static fields. createGetter = !modifierList.hasModifierProperty(PsiModifier.STATIC); //Skip fields having Getter annotation already - createGetter &= PsiAnnotationUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClass()); + createGetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClass()); //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 diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java index 4fd06f18c..d1dd909b9 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/SetterProcessor.java @@ -13,7 +13,7 @@ import de.plushnikov.intellij.plugin.processor.field.SetterFieldProcessor; 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.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; import lombok.Setter; @@ -90,7 +90,7 @@ private Collection filterSetterFields(@NotNull PsiClass psiClass) { //Skip static fields. createSetter &= !modifierList.hasModifierProperty(PsiModifier.STATIC); //Skip fields having Setter annotation already - createSetter &= PsiAnnotationUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClass()); + createSetter &= PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, fieldProcessor.getSupportedAnnotationClass()); //Skip fields that start with $ createSetter &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); //Skip fields if a method with same name already exists diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/ValueProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/ValueProcessor.java index 3cf5265f7..a38fb5708 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/ValueProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/ValueProcessor.java @@ -11,6 +11,7 @@ import de.plushnikov.intellij.plugin.processor.LombokPsiElementUsage; import de.plushnikov.intellij.plugin.processor.clazz.constructor.AllArgsConstructorProcessor; import de.plushnikov.intellij.plugin.quickfix.PsiQuickFixFactory; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import lombok.AllArgsConstructor; @@ -59,7 +60,7 @@ protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiCla } protected void validateCallSuperParam(PsiAnnotation psiAnnotation, PsiClass psiClass, ProblemBuilder builder, String generatedMethodName) { - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { if (PsiClassUtil.hasSuperClass(psiClass)) { builder.addWarning("Generating " + generatedMethodName + " implementation but without a call to superclass, " + "even though this class does not extend java.lang.Object." + @@ -87,17 +88,17 @@ protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnot } */ - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, Getter.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, Getter.class)) { target.addAll(getterProcessor.createFieldGetters(psiClass, PsiModifier.PUBLIC)); } - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, EqualsAndHashCode.class)) { target.addAll(equalsAndHashCodeProcessor.createEqualAndHashCode(psiClass, psiAnnotation)); } - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, ToString.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, ToString.class)) { target.addAll(toStringProcessor.createToStringMethod(psiClass, psiAnnotation)); } // create required constructor only if there are no other constructor annotations - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class, + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, NoArgsConstructor.class, RequiredArgsConstructor.class, AllArgsConstructor.class, lombok.experimental.Builder.class, lombok.Builder.class)) { final Collection definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); filterToleratedElements(definedConstructors); diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java index b39cb3be9..c26afe830 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/WitherProcessor.java @@ -13,7 +13,7 @@ import de.plushnikov.intellij.plugin.processor.field.WitherFieldProcessor; 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.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import lombok.experimental.Wither; import org.jetbrains.annotations.NotNull; @@ -87,7 +87,7 @@ private Collection getWitherFields(@NotNull PsiClass psiClass) { // Skip fields that start with $ createWither &= !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); // Skip fields having Wither annotation already - createWither &= !PsiAnnotationUtil.isAnnotatedWith(psiField, Wither.class); + createWither &= !PsiAnnotationSearchUtil.isAnnotatedWith(psiField, Wither.class); } if (createWither) { witherFields.add(psiField); diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/AbstractBuilderPreDefinedInnerClassProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/AbstractBuilderPreDefinedInnerClassProcessor.java index e904ddecc..98a809e14 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/AbstractBuilderPreDefinedInnerClassProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/AbstractBuilderPreDefinedInnerClassProcessor.java @@ -12,7 +12,7 @@ import de.plushnikov.intellij.plugin.processor.handler.BuilderHandler; import de.plushnikov.intellij.plugin.psi.LombokLightClassBuilder; import de.plushnikov.intellij.plugin.settings.ProjectSettings; -import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -49,11 +49,11 @@ public List process(@NotNull PsiClass psiClass) { result = new ArrayList(); final PsiClass psiParentClass = (PsiClass) parentElement; - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiParentClass, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiParentClass, getSupportedAnnotationClass()); if (null == psiAnnotation) { final Collection psiMethods = PsiClassUtil.collectClassMethodsIntern(psiParentClass); for (PsiMethod psiMethod : psiMethods) { - psiAnnotation = PsiAnnotationUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); + psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); if (null != psiAnnotation) { processMethodAnnotation(result, psiMethod, psiAnnotation, psiClass, psiParentClass); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderProcessor.java index 83f3be573..340867718 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/builder/BuilderProcessor.java @@ -14,7 +14,7 @@ import de.plushnikov.intellij.plugin.processor.clazz.constructor.AllArgsConstructorProcessor; import de.plushnikov.intellij.plugin.processor.handler.BuilderHandler; import de.plushnikov.intellij.plugin.settings.ProjectSettings; -import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import lombok.AllArgsConstructor; import lombok.Builder; @@ -59,7 +59,7 @@ protected boolean validate(@NotNull PsiAnnotation psiAnnotation, @NotNull PsiCla } protected void generatePsiElements(@NotNull PsiClass psiClass, @NotNull PsiAnnotation psiAnnotation, @NotNull List target) { - if (PsiAnnotationUtil.isNotAnnotatedWith(psiClass, AllArgsConstructor.class)) { + if (PsiAnnotationSearchUtil.isNotAnnotatedWith(psiClass, AllArgsConstructor.class)) { // Create all args constructor only if there is no declared constructors and no lombok constructor annotations final Collection definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass); if (definedConstructors.isEmpty()) { diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java index 8ed56b769..b119bf06d 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/clazz/constructor/AbstractConstructorClassProcessor.java @@ -25,6 +25,7 @@ import de.plushnikov.intellij.plugin.settings.ProjectSettings; import de.plushnikov.intellij.plugin.thirdparty.LombokUtils; 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 de.plushnikov.intellij.plugin.util.PsiElementUtil; @@ -164,7 +165,7 @@ private boolean containsMethod(final Collection definedMethods, final @SuppressWarnings("deprecation") protected Collection getAllNotInitializedAndNotStaticFields(@NotNull PsiClass psiClass) { Collection allNotInitializedNotStaticFields = new ArrayList(); - final boolean classAnnotatedWithValue = PsiAnnotationUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class); + final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class); for (PsiField psiField : psiClass.getFields()) { // skip fields named $ boolean addField = !psiField.getName().startsWith(LombokUtils.LOMBOK_INTERN_FIELD_MARKER); @@ -190,13 +191,13 @@ protected Collection getAllNotInitializedAndNotStaticFields(@NotNull P @SuppressWarnings("deprecation") public Collection getRequiredFields(@NotNull PsiClass psiClass) { Collection result = new ArrayList(); - final boolean classAnnotatedWithValue = PsiAnnotationUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class); + final boolean classAnnotatedWithValue = PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, Value.class, lombok.experimental.Value.class); for (PsiField psiField : getAllNotInitializedAndNotStaticFields(psiClass)) { final PsiModifierList modifierList = psiField.getModifierList(); if (null != modifierList) { final boolean isFinal = isFieldFinal(psiField, modifierList, classAnnotatedWithValue); - final boolean isNonNull = PsiAnnotationUtil.isAnnotatedWith(psiField, LombokUtils.NON_NULL_PATTERN); + final boolean isNonNull = PsiAnnotationSearchUtil.isAnnotatedWith(psiField, LombokUtils.NON_NULL_PATTERN); // accept initialized final or nonnull fields if ((isFinal || isNonNull) && null == psiField.getInitializer()) { result.add(psiField); @@ -209,7 +210,7 @@ public Collection getRequiredFields(@NotNull PsiClass psiClass) { private boolean isFieldFinal(@NotNull PsiField psiField, @NotNull PsiModifierList modifierList, boolean classAnnotatedWithValue) { boolean isFinal = modifierList.hasModifierProperty(PsiModifier.FINAL); if (!isFinal && classAnnotatedWithValue) { - isFinal = PsiAnnotationUtil.isNotAnnotatedWith(psiField, NonFinal.class); + isFinal = PsiAnnotationSearchUtil.isNotAnnotatedWith(psiField, NonFinal.class); } return isFinal; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/field/AbstractFieldProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/field/AbstractFieldProcessor.java index 128b278ce..3a511df81 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/field/AbstractFieldProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/field/AbstractFieldProcessor.java @@ -11,6 +11,7 @@ import de.plushnikov.intellij.plugin.problem.ProblemEmptyBuilder; import de.plushnikov.intellij.plugin.problem.ProblemNewBuilder; import de.plushnikov.intellij.plugin.processor.AbstractProcessor; +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; @@ -38,7 +39,7 @@ public abstract class AbstractFieldProcessor extends AbstractProcessor implement public List process(@NotNull PsiClass psiClass) { List result = new ArrayList(); for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) { - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiField, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, getSupportedAnnotationClass()); if (null != psiAnnotation) { if (validate(psiAnnotation, psiField, ProblemEmptyBuilder.getInstance())) { generatePsiElements(psiField, psiAnnotation, result); @@ -52,7 +53,7 @@ public List process(@NotNull PsiClass psiClass) { public Collection collectProcessedAnnotations(@NotNull PsiClass psiClass) { List result = new ArrayList(); for (PsiField psiField : PsiClassUtil.collectClassFieldsIntern(psiClass)) { - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiField, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, getSupportedAnnotationClass()); if (null != psiAnnotation) { result.add(psiAnnotation); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/field/AccessorsInfo.java b/src/main/java/de/plushnikov/intellij/plugin/processor/field/AccessorsInfo.java index f8b677ddb..f39305f21 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/field/AccessorsInfo.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/field/AccessorsInfo.java @@ -6,6 +6,7 @@ import de.plushnikov.intellij.plugin.lombokconfig.ConfigDiscovery; import de.plushnikov.intellij.plugin.lombokconfig.ConfigKeys; import de.plushnikov.intellij.plugin.processor.AbstractProcessor; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import lombok.experimental.Accessors; import org.jetbrains.annotations.NotNull; @@ -17,7 +18,6 @@ * @author Plushnikov Michail */ public class AccessorsInfo { - private static final String ACCESSORS_ANNOTATION_NAME = Accessors.class.getName(); public static final AccessorsInfo EMPTY = new AccessorsInfo(false, false, false); private final boolean fluent; @@ -37,7 +37,7 @@ public static AccessorsInfo build(boolean fluentValue, boolean chainValue, boole } public static AccessorsInfo build(@NotNull PsiField psiField) { - final PsiAnnotation accessorsFieldAnnotation = PsiAnnotationUtil.findAnnotation(psiField, ACCESSORS_ANNOTATION_NAME); + final PsiAnnotation accessorsFieldAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, Accessors.class); final PsiClass containingClass = psiField.getContainingClass(); if (null != accessorsFieldAnnotation) { return buildFromAnnotation(accessorsFieldAnnotation, containingClass); @@ -49,7 +49,7 @@ public static AccessorsInfo build(@NotNull PsiField psiField) { public static AccessorsInfo build(@Nullable PsiClass psiClass) { PsiClass containingClass = psiClass; while (null != containingClass) { - final PsiAnnotation accessorsClassAnnotation = PsiAnnotationUtil.findAnnotation(containingClass, ACCESSORS_ANNOTATION_NAME); + final PsiAnnotation accessorsClassAnnotation = PsiAnnotationSearchUtil.findAnnotation(containingClass, Accessors.class); if (null != accessorsClassAnnotation) { return buildFromAnnotation(accessorsClassAnnotation, containingClass); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java index f2dfaf65d..e202332ed 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/field/GetterFieldProcessor.java @@ -15,6 +15,7 @@ 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.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -136,7 +137,7 @@ public PsiMethod createGetterMethod(@NotNull PsiField psiField, @NotNull PsiClas 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"); + addOnXAnnotations(PsiAnnotationSearchUtil.findAnnotation(psiField, Getter.class), modifierList, "onMethod"); return method; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/field/SetterFieldProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/field/SetterFieldProcessor.java index 92f4eea3c..51b4b7aaf 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/field/SetterFieldProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/field/SetterFieldProcessor.java @@ -17,6 +17,7 @@ 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.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -124,7 +125,7 @@ private String getSetterName(@NotNull PsiField psiField, boolean isBoolean) { public PsiMethod createSetterMethod(@NotNull PsiField psiField, @NotNull PsiClass psiClass, @NotNull String methodModifier) { final String fieldName = psiField.getName(); final PsiType psiFieldType = psiField.getType(); - final PsiAnnotation setterAnnotation = PsiAnnotationUtil.findAnnotation(psiField, Setter.class); + final PsiAnnotation setterAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, Setter.class); final String methodName = getSetterName(psiField, PsiType.BOOLEAN.equals(psiFieldType)); diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/field/WitherFieldProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/field/WitherFieldProcessor.java index 3d2bb2742..bf573087b 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/field/WitherFieldProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/field/WitherFieldProcessor.java @@ -19,7 +19,7 @@ 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.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; import lombok.AllArgsConstructor; @@ -120,13 +120,13 @@ private boolean validIsWitherUnique(@NotNull PsiField psiField, @NotNull final P @SuppressWarnings("deprecation") public boolean validConstructor(@NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) { - if (PsiAnnotationUtil.isAnnotatedWith(psiClass, AllArgsConstructor.class, Value.class, lombok.experimental.Value.class)) { + if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, AllArgsConstructor.class, Value.class, lombok.experimental.Value.class)) { return true; } final Collection constructorParameters = filterFields(psiClass); - if (PsiAnnotationUtil.isAnnotatedWith(psiClass, RequiredArgsConstructor.class, Data.class)) { + if (PsiAnnotationSearchUtil.isAnnotatedWith(psiClass, RequiredArgsConstructor.class, Data.class)) { final Collection requiredConstructorParameters = requiredArgsConstructorProcessor.getRequiredFields(psiClass); if (constructorParameters.size() == requiredConstructorParameters.size()) { return true; @@ -185,7 +185,7 @@ public PsiMethod createWitherMethod(@NotNull PsiField psiField, @NotNull String .withNavigationElement(psiField) .withModifier(methodModifier); - PsiAnnotation witherAnnotation = PsiAnnotationUtil.findAnnotation(psiField, Wither.class); + PsiAnnotation witherAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiField, Wither.class); addOnXAnnotations(witherAnnotation, result.getModifierList(), "onMethod"); final LombokLightParameter methodParameter = new LombokLightParameter(psiFieldName, psiFieldType, result, JavaLanguage.INSTANCE); diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/handler/BuilderHandler.java b/src/main/java/de/plushnikov/intellij/plugin/processor/handler/BuilderHandler.java index c93b58cac..296dda3c3 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/handler/BuilderHandler.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/handler/BuilderHandler.java @@ -30,6 +30,7 @@ import de.plushnikov.intellij.plugin.psi.LombokLightMethodBuilder; import de.plushnikov.intellij.plugin.thirdparty.ErrorMessages; import de.plushnikov.intellij.plugin.thirdparty.LombokUtils; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import de.plushnikov.intellij.plugin.util.PsiMethodUtil; @@ -109,7 +110,7 @@ private boolean validateSingular(@NotNull PsiClass psiClass, @NotNull ProblemBui final AccessorsInfo accessorsInfo = AccessorsInfo.build(psiClass); final Collection builderFields = getBuilderFields(psiClass, Collections.emptySet(), accessorsInfo); for (PsiVariable builderVariable : builderFields) { - final PsiAnnotation singularAnnotation = PsiAnnotationUtil.findAnnotation(builderVariable, Singular.class); + final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(builderVariable, Singular.class); if (null != singularAnnotation) { final String qualifiedName = PsiTypeUtil.getQualifiedName(builderVariable.getType()); if (SingularHandlerFactory.isInvalidSingularType(qualifiedName)) { @@ -140,7 +141,7 @@ private boolean validateBuilderClassName(@NotNull String builderClassName, @NotN private boolean validateExistingBuilderClass(@NotNull String builderClassName, @NotNull PsiClass psiClass, @NotNull ProblemBuilder builder) { for (PsiClass psiInnerClass : PsiClassUtil.collectInnerClassesIntern(psiClass)) { if (builderClassName.equals(psiInnerClass.getName())) { - if (PsiAnnotationUtil.checkAnnotationsSimpleNameExistsIn(psiInnerClass, INVALID_ON_BUILDERS)) { + if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiInnerClass, INVALID_ON_BUILDERS)) { builder.addError("Lombok annotations are not allowed on builder class."); return false; } @@ -337,7 +338,7 @@ public Collection createMethods(@NotNull PsiClass psiParentClass, @Nu for (PsiVariable psiVariable : psiVariables) { final String fieldName = accessorsInfo.removePrefix(psiVariable.getName()); - final PsiAnnotation singularAnnotation = PsiAnnotationUtil.findAnnotation(psiVariable, Singular.class); + final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiVariable, Singular.class); final BuilderElementHandler handler = SingularHandlerFactory.getHandlerFor(psiVariable, singularAnnotation, isShouldGenerateFullBodyBlock()); // skip methods already defined in builder class @@ -434,7 +435,7 @@ public Collection getBuilderFields(@NotNull PsiClass psiClass, @NotNul public Collection generateFields(@NotNull Collection psiVariables, @NotNull PsiClass psiBuilderClass, @NotNull AccessorsInfo accessorsInfo) { List fields = new ArrayList(); for (PsiVariable psiVariable : psiVariables) { - final PsiAnnotation singularAnnotation = PsiAnnotationUtil.findAnnotation(psiVariable, Singular.class); + final PsiAnnotation singularAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiVariable, Singular.class); BuilderElementHandler handler = SingularHandlerFactory.getHandlerFor(psiVariable, singularAnnotation, isShouldGenerateFullBodyBlock()); handler.addBuilderField(fields, psiVariable, psiBuilderClass, accessorsInfo); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/processor/method/AbstractMethodProcessor.java b/src/main/java/de/plushnikov/intellij/plugin/processor/method/AbstractMethodProcessor.java index 2e8f92ace..995f9208d 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/processor/method/AbstractMethodProcessor.java +++ b/src/main/java/de/plushnikov/intellij/plugin/processor/method/AbstractMethodProcessor.java @@ -10,7 +10,7 @@ import de.plushnikov.intellij.plugin.problem.ProblemEmptyBuilder; import de.plushnikov.intellij.plugin.problem.ProblemNewBuilder; import de.plushnikov.intellij.plugin.processor.AbstractProcessor; -import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; @@ -36,7 +36,7 @@ public abstract class AbstractMethodProcessor extends AbstractProcessor implemen public List process(@NotNull PsiClass psiClass) { List result = new ArrayList(); for (PsiMethod psiMethod : PsiClassUtil.collectClassMethodsIntern(psiClass)) { - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); if (null != psiAnnotation) { if (validate(psiAnnotation, psiMethod, ProblemEmptyBuilder.getInstance())) { processIntern(psiMethod, psiAnnotation, result); @@ -50,7 +50,7 @@ public List process(@NotNull PsiClass psiClass) { public Collection collectProcessedAnnotations(@NotNull PsiClass psiClass) { List result = new ArrayList(); for (PsiMethod psiMethod : PsiClassUtil.collectClassMethodsIntern(psiClass)) { - PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); + PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiMethod, getSupportedAnnotationClass()); if (null != psiAnnotation) { result.add(psiAnnotation); } diff --git a/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorData.java b/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorData.java index 826113110..b18472a48 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorData.java +++ b/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorData.java @@ -7,7 +7,7 @@ public class LombokProcessorData { private final Processor processor; private final PsiAnnotation psiAnnotation; - public LombokProcessorData(Processor processor, PsiAnnotation psiAnnotation) { + LombokProcessorData(Processor processor, PsiAnnotation psiAnnotation) { this.processor = processor; this.psiAnnotation = psiAnnotation; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorProvider.java b/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorProvider.java index 77b8e1845..d054331f0 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorProvider.java +++ b/src/main/java/de/plushnikov/intellij/plugin/provider/LombokProcessorProvider.java @@ -12,7 +12,7 @@ import com.intellij.psi.PsiModifierList; import de.plushnikov.intellij.plugin.extension.LombokProcessorExtensionPoint; import de.plushnikov.intellij.plugin.processor.Processor; -import de.plushnikov.intellij.plugin.util.PsiAnnotationUtil; +import de.plushnikov.intellij.plugin.util.PsiAnnotationSearchUtil; import de.plushnikov.intellij.plugin.util.PsiClassUtil; import org.jetbrains.annotations.NotNull; @@ -93,19 +93,19 @@ public Collection getProcessors(@NotNull PsiAnnotation psiAnnotation) return result == null ? Collections.emptySet() : result; } - public boolean verifyLombokAnnotationPresent(@NotNull PsiClass psiClass) { - if (PsiAnnotationUtil.checkAnnotationsSimpleNameExistsIn(psiClass, registeredAnnotationNames)) { + private boolean verifyLombokAnnotationPresent(@NotNull PsiClass psiClass) { + if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiClass, registeredAnnotationNames)) { return true; } Collection psiFields = PsiClassUtil.collectClassFieldsIntern(psiClass); for (PsiField psiField : psiFields) { - if (PsiAnnotationUtil.checkAnnotationsSimpleNameExistsIn(psiField, registeredAnnotationNames)) { + if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiField, registeredAnnotationNames)) { return true; } } Collection psiMethods = PsiClassUtil.collectClassMethodsIntern(psiClass); for (PsiMethod psiMethod : psiMethods) { - if (PsiAnnotationUtil.checkAnnotationsSimpleNameExistsIn(psiMethod, registeredAnnotationNames)) { + if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiMethod, registeredAnnotationNames)) { return true; } } @@ -117,8 +117,8 @@ public boolean verifyLombokAnnotationPresent(@NotNull PsiClass psiClass) { return false; } - public boolean verifyLombokAnnotationPresent(@NotNull PsiMember psiMember) { - if (PsiAnnotationUtil.checkAnnotationsSimpleNameExistsIn(psiMember, registeredAnnotationNames)) { + private boolean verifyLombokAnnotationPresent(@NotNull PsiMember psiMember) { + if (PsiAnnotationSearchUtil.checkAnnotationsSimpleNameExistsIn(psiMember, registeredAnnotationNames)) { return true; } diff --git a/src/main/java/de/plushnikov/intellij/plugin/util/LombokProcessorUtil.java b/src/main/java/de/plushnikov/intellij/plugin/util/LombokProcessorUtil.java index 52eae9f22..7a1b0ec19 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/util/LombokProcessorUtil.java +++ b/src/main/java/de/plushnikov/intellij/plugin/util/LombokProcessorUtil.java @@ -23,6 +23,13 @@ */ public class LombokProcessorUtil { + private static final Map ACCESS_LEVEL_MAP = new HashMap() {{ + put(PsiModifier.PUBLIC, AccessLevel.PUBLIC); + put(PsiModifier.PACKAGE_LOCAL, AccessLevel.PACKAGE); + put(PsiModifier.PROTECTED, AccessLevel.PROTECTED); + put(PsiModifier.PRIVATE, AccessLevel.PRIVATE); + }}; + @Nullable public static String getMethodModifier(@NotNull PsiAnnotation psiAnnotation) { return convertAccessLevelToJavaModifier(PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "value")); @@ -32,7 +39,7 @@ public static String getMethodModifier(@NotNull PsiAnnotation psiAnnotation) { public static String getAccessVisibility(@NotNull PsiAnnotation psiAnnotation) { return convertAccessLevelToJavaModifier(PsiAnnotationUtil.getStringAnnotationValue(psiAnnotation, "access")); } - + @NotNull public static Collection getOnX(@NotNull PsiAnnotation psiAnnotation, @NotNull String parameterName) { PsiAnnotationMemberValue onXValue = psiAnnotation.findAttributeValue(parameterName); @@ -43,14 +50,18 @@ public static Collection getOnX(@NotNull PsiAnnotation psiAnnotation, @N Collection annotationStrings = new ArrayList(); for (PsiAnnotation annotation : annotations) { PsiAnnotationParameterList params = annotation.getParameterList(); - annotationStrings.add(PsiAnnotationUtil.getSimpleNameOf(annotation) + params.getText()); + annotationStrings.add(PsiAnnotationSearchUtil.getSimpleNameOf(annotation) + params.getText()); } return annotationStrings; } @Nullable private static String convertAccessLevelToJavaModifier(String value) { - if (null == value || value.isEmpty() || "PUBLIC".equals(value)) { + if (null == value || value.isEmpty()) { + return PsiModifier.PUBLIC; + } + + if ("PUBLIC".equals(value)) { return PsiModifier.PUBLIC; } if ("MODULE".equals(value)) { @@ -67,9 +78,8 @@ private static String convertAccessLevelToJavaModifier(String value) { } if ("NONE".equals(value)) { return null; - } else { - return null; } + return null; } @NotNull @@ -79,7 +89,7 @@ public static PsiAnnotation createAnnotationWithAccessLevel(@NotNull Class map = new HashMap(); - map.put(PsiModifier.PUBLIC, AccessLevel.PUBLIC); - map.put(PsiModifier.PACKAGE_LOCAL, AccessLevel.PACKAGE); - map.put(PsiModifier.PROTECTED, AccessLevel.PROTECTED); - map.put(PsiModifier.PRIVATE, AccessLevel.PRIVATE); - return map.get(psiModifier); - } } diff --git a/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationSearchUtil.java b/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationSearchUtil.java new file mode 100644 index 000000000..7f1bf3df3 --- /dev/null +++ b/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationSearchUtil.java @@ -0,0 +1,123 @@ +package de.plushnikov.intellij.plugin.util; + +import com.intellij.openapi.diagnostic.Logger; +import com.intellij.openapi.util.Key; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiAnnotationOwner; +import com.intellij.psi.PsiJavaCodeReferenceElement; +import com.intellij.psi.PsiModifierList; +import com.intellij.psi.PsiModifierListOwner; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.lang.annotation.Annotation; +import java.util.Collection; +import java.util.regex.Pattern; + +public class PsiAnnotationSearchUtil { + private static final Key LOMBOK_ANNOTATION_FQN_KEY = Key.create("LOMBOK_ANNOTATION_FQN"); + + private static final Logger LOG = Logger.getInstance(PsiAnnotationUtil.class.getName()); + private static int cacheHit = 0; + private static int cacheMiss = 0; + private static int notSame = 0; + + @Nullable + public static PsiAnnotation findAnnotation(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { + return findAnnotationQuick(psiModifierListOwner.getModifierList(), annotationType.getName()); + } + + @Nullable + private static PsiAnnotation findAnnotationQuick(@Nullable PsiAnnotationOwner annotationOwner, @NotNull String qualifiedName) { + if (annotationOwner == null) { + return null; + } + + PsiAnnotation[] annotations = annotationOwner.getAnnotations(); + if (annotations.length == 0) { + return null; + } + + final String shortName = StringUtil.getShortName(qualifiedName); + for (PsiAnnotation annotation : annotations) { + PsiJavaCodeReferenceElement referenceElement = annotation.getNameReferenceElement(); + if (referenceElement != null && shortName.equals(referenceElement.getReferenceName())) { + + String annotationQualifiedName = annotation.getCopyableUserData(LOMBOK_ANNOTATION_FQN_KEY); + if (null == annotationQualifiedName) { + annotationQualifiedName = annotation.getQualifiedName(); + if (null != annotationQualifiedName && annotationQualifiedName.indexOf('.') > 0) { + annotation.putCopyableUserData(LOMBOK_ANNOTATION_FQN_KEY, annotationQualifiedName); + } + cacheMiss++; + } else { + cacheHit++; + } + + if (qualifiedName.equals(annotationQualifiedName)) { + LOG.warn(String.format("CacheHit: %d, CacheMiss: %d, NotSame: %d\n", cacheHit, cacheMiss, notSame)); + return annotation; + } else { + LOG.warn("Different annotations: " + qualifiedName + " <-> " + annotationQualifiedName); + notSame++; + } + } + } + + return null; + } + + public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { + return null != findAnnotation(psiModifierListOwner, annotationType); + } + + public static boolean isNotAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { + return !isAnnotatedWith(psiModifierListOwner, annotationType); + } + + public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class... annotationTypes) { + for (Class annotationType : annotationTypes) { + if (isAnnotatedWith(psiModifierListOwner, annotationType)) { + return true; + } + } + return false; + } + + public static boolean isNotAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class... annotationTypes) { + return !isAnnotatedWith(psiModifierListOwner, annotationTypes); + } + + public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Pattern annotationPattern) { + final PsiModifierList psiModifierList = psiModifierListOwner.getModifierList(); + if (psiModifierList != null) { + for (PsiAnnotation psiAnnotation : psiModifierList.getAnnotations()) { + final String suspect = getSimpleNameOf(psiAnnotation); + if (annotationPattern.matcher(suspect).matches()) { + return true; + } + } + } + return false; + } + + @NotNull + static String getSimpleNameOf(@NotNull PsiAnnotation psiAnnotation) { + PsiJavaCodeReferenceElement referenceElement = psiAnnotation.getNameReferenceElement(); + return StringUtil.notNullize(null == referenceElement ? null : referenceElement.getReferenceName()); + } + + public static boolean checkAnnotationsSimpleNameExistsIn(@NotNull PsiModifierListOwner modifierListOwner, @NotNull Collection annotationNames) { + final PsiModifierList modifierList = modifierListOwner.getModifierList(); + if (null != modifierList) { + for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) { + final String simpleName = getSimpleNameOf(psiAnnotation); + if (annotationNames.contains(simpleName)) { + return true; + } + } + } + return false; + } +} diff --git a/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationUtil.java b/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationUtil.java index 8ba79cd3a..e97a77c58 100644 --- a/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationUtil.java +++ b/src/main/java/de/plushnikov/intellij/plugin/util/PsiAnnotationUtil.java @@ -1,11 +1,9 @@ package de.plushnikov.intellij.plugin.util; -import com.intellij.openapi.util.Key; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.JavaPsiFacade; import com.intellij.psi.PsiAnnotation; import com.intellij.psi.PsiAnnotationMemberValue; -import com.intellij.psi.PsiAnnotationOwner; import com.intellij.psi.PsiArrayInitializerMemberValue; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClassObjectAccessExpression; @@ -13,7 +11,6 @@ import com.intellij.psi.PsiElementFactory; import com.intellij.psi.PsiEnumConstant; import com.intellij.psi.PsiField; -import com.intellij.psi.PsiJavaCodeReferenceElement; import com.intellij.psi.PsiLiteralExpression; import com.intellij.psi.PsiModifierList; import com.intellij.psi.PsiModifierListOwner; @@ -52,92 +49,6 @@ public static PsiAnnotation createPsiAnnotation(@NotNull PsiModifierListOwner ps return elementFactory.createAnnotationFromText("@" + annotationClass.getName() + valueString, psiClass); } - @Nullable - public static PsiAnnotation findAnnotation(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { - return findAnnotation(psiModifierListOwner, annotationType.getName()); - } - - @Nullable - public static PsiAnnotation findAnnotation(@NotNull final PsiModifierListOwner psiModifierListOwner, @NotNull final String qualifiedName) { - return findAnnotationQuick(psiModifierListOwner.getModifierList(), qualifiedName); - } - - private static final Key lombokFqnAnnotation = Key.create("LOMBOK_ANNOTATION_FQN"); - - @Nullable - private static PsiAnnotation findAnnotationQuick(@Nullable PsiAnnotationOwner annotationOwner, @NotNull String qualifiedName) { - if (annotationOwner == null) { - return null; - } - - PsiAnnotation[] annotations = annotationOwner.getAnnotations(); - if (annotations.length == 0) { - return null; - } - - final String shortName = StringUtil.getShortName(qualifiedName); - for (PsiAnnotation annotation : annotations) { - PsiJavaCodeReferenceElement referenceElement = annotation.getNameReferenceElement(); - if (referenceElement != null && shortName.equals(referenceElement.getReferenceName())) { - - String annotationQualifiedName = annotation.getCopyableUserData(lombokFqnAnnotation); - if (null == annotationQualifiedName) { - annotationQualifiedName = annotation.getQualifiedName(); - - if (null != annotationQualifiedName && annotationQualifiedName.indexOf('.') > 0) { - annotation.putCopyableUserData(lombokFqnAnnotation, annotationQualifiedName); - } - } - - if (qualifiedName.equals(annotationQualifiedName)) { - return annotation; - } - } - } - - return null; - } - - public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { - return null != findAnnotation(psiModifierListOwner, annotationType); - } - - public static boolean isNotAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class annotationType) { - return !isAnnotatedWith(psiModifierListOwner, annotationType); - } - - public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class... annotationTypes) { - for (Class annotationType : annotationTypes) { - if (isAnnotatedWith(psiModifierListOwner, annotationType)) { - return true; - } - } - return false; - } - - public static boolean isNotAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Class... annotationTypes) { - return !isAnnotatedWith(psiModifierListOwner, annotationTypes); - } - - public static boolean isAnnotatedWith(@NotNull PsiModifierListOwner psiModifierListOwner, @NotNull final Pattern annotationPattern) { - final PsiModifierList psiModifierList = psiModifierListOwner.getModifierList(); - if (psiModifierList != null) { - for (PsiAnnotation psiAnnotation : psiModifierList.getAnnotations()) { - final String suspect = getSimpleNameOf(psiAnnotation); - if (annotationPattern.matcher(suspect).matches()) { - return true; - } - } - } - return false; - } - - @NotNull - public static String getSimpleNameOf(@NotNull PsiAnnotation psiAnnotation) { - PsiJavaCodeReferenceElement referenceElement = psiAnnotation.getNameReferenceElement(); - return StringUtil.notNullize(null == referenceElement ? null : referenceElement.getReferenceName()); - } - @NotNull public static Collection getAnnotationValues(@NotNull PsiAnnotation psiAnnotation, @NotNull String parameter, @NotNull Class asClass) { Collection result = Collections.emptyList(); @@ -224,7 +135,7 @@ public static Collection collectAnnotationsToCopy(@NotNull PsiField psiF PsiModifierList modifierList = psiField.getModifierList(); if (null != modifierList) { for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) { - final String annotationName = getSimpleNameOf(psiAnnotation); + final String annotationName = PsiAnnotationSearchUtil.getSimpleNameOf(psiAnnotation); for (Pattern pattern : patterns) { if (pattern.matcher(annotationName).matches()) { annotationsToCopy.add(psiAnnotation.getQualifiedName()); @@ -235,16 +146,4 @@ public static Collection collectAnnotationsToCopy(@NotNull PsiField psiF return annotationsToCopy; } - public static boolean checkAnnotationsSimpleNameExistsIn(@NotNull PsiModifierListOwner modifierListOwner, @NotNull Collection annotationNames) { - final PsiModifierList modifierList = modifierListOwner.getModifierList(); - if (null != modifierList) { - for (PsiAnnotation psiAnnotation : modifierList.getAnnotations()) { - final String simpleName = getSimpleNameOf(psiAnnotation); - if (annotationNames.contains(simpleName)) { - return true; - } - } - } - return false; - } }