separated PsiAnnotation logik into multiple classes (added PsiAnnotat…

…ionSearchUtil)

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<PsiField, PsiMethod> fieldMethodMap, @
   }
 
   private boolean isNotAnnotatedWithOrSameAccessLevelAs(PsiClass psiClass, PsiMethod firstPropertyMethod, Class<? extends Annotation> 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<? e
 
   private void addAnnotation(@NotNull PsiModifierListOwner targetElement, @NotNull PsiAnnotation newPsiAnnotation,
                              @NotNull Class<? extends Annotation> 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<? extends Annotation> annotationClass) {
-    final PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(targetElement, annotationClass);
+    final PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(targetElement, annotationClass);
     if (null != psiAnnotation) {
       boolean hasOnlyDefaultValues = true;
 

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<PsiMethod> 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);
             }
           }

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

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

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<? extends PsiModifier
     final Iterator<? extends PsiModifierListOwner> methodIterator = definedMethods.iterator();
     while (methodIterator.hasNext()) {
       PsiModifierListOwner definedMethod = methodIterator.next();
-      if (PsiAnnotationUtil.isAnnotatedWith(definedMethod, Tolerate.class)) {
+      if (PsiAnnotationSearchUtil.isAnnotatedWith(definedMethod, Tolerate.class)) {
         methodIterator.remove();
       }
     }

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<? extends Annotation> supportedA
   public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
     List<? super PsiElement> 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<PsiElement>();
@@ -56,7 +57,7 @@ public List<? super PsiElement> process(@NotNull PsiClass psiClass) {
   @NotNull
   public Collection<PsiAnnotation> collectProcessedAnnotations(@NotNull PsiClass psiClass) {
     Collection<PsiAnnotation> result = new ArrayList<PsiAnnotation>();
-    PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiClass, getSupportedAnnotationClass());
+    PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiClass, getSupportedAnnotationClass());
     if (null != psiAnnotation) {
       result.add(psiAnnotation);
     }

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<? super PsiElement> 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<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass);
       filterToleratedElements(definedConstructors);
 

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

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

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

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<PsiMethod> definedConstructors = PsiClassUtil.collectClassConstructorIntern(psiClass);
       filterToleratedElements(definedConstructors);

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

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<? super PsiElement> process(@NotNull PsiClass psiClass) {
       result = new ArrayList<PsiElement>();
 
       final PsiClass psiParentClass = (PsiClass) parentElement;
-      PsiAnnotation psiAnnotation = PsiAnnotationUtil.findAnnotation(psiParentClass, getSupportedAnnotationClass());
+      PsiAnnotation psiAnnotation = PsiAnnotationSearchUtil.findAnnotation(psiParentClass, getSupportedAnnotationClass());
       if (null == psiAnnotation) {
         final Collection<PsiMethod> 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);
           }