removed caches from inspection

jvm/jvm-analysis-api/src/com/intellij/codeInspection/blockingCallsDetection/PersistentStateChecker.java

-// Copyright 2000-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
-package com.intellij.codeInspection.blockingCallsDetection;
-
-import org.jetbrains.annotations.ApiStatus;
-
-/**
- * Marks extension points {@link BlockingMethodChecker} or {@link NonBlockingContextChecker} that uses externally stored settings
- * and due to that can not be used in {@link com.intellij.psi.util.CachedValuesManager}
- * <p>
- * Likely for internal usage since third party extensions may not have access to inspection settings etc
- */
-@ApiStatus.Experimental
-public interface PersistentStateChecker {
-}

jvm/jvm-analysis-impl/src/com/intellij/codeInspection/blockingCallsDetection/AnnotationBasedBlockingMethodChecker.java

@@ -2,12 +2,15 @@
 package com.intellij.codeInspection.blockingCallsDetection;
 
 import com.intellij.codeInsight.AnnotationUtil;
-import com.intellij.psi.*;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
 
-public class AnnotationBasedBlockingMethodChecker implements BlockingMethodChecker, PersistentStateChecker {
+public class AnnotationBasedBlockingMethodChecker implements BlockingMethodChecker {
 
   private final List<String> myBlockingAnnotations;
 
@@ -25,11 +28,6 @@ public class AnnotationBasedBlockingMethodChecker implements BlockingMethodCheck
 
   @Override
   public boolean isMethodBlocking(@NotNull PsiMethod method) {
-    return hasAnnotation(method, myBlockingAnnotations);
-  }
-
-  static boolean hasAnnotation(PsiModifierListOwner owner, List<String> annotationsFQNames) {
-    // AnnotationUtil#isAnnotated doesn't use caching inside
-    return AnnotationUtil.findAnnotation(owner, annotationsFQNames, false) != null;
+    return AnnotationUtil.findAnnotation(method, myBlockingAnnotations, false) != null;
   }
 }

jvm/jvm-analysis-impl/src/com/intellij/codeInspection/blockingCallsDetection/AnnotationBasedNonBlockingContextChecker.java

 // Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
 package com.intellij.codeInspection.blockingCallsDetection;
 
+import com.intellij.codeInsight.AnnotationUtil;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.uast.UCallExpression;
@@ -10,9 +11,7 @@ import org.jetbrains.uast.UastUtils;
 
 import java.util.List;
 
-import static com.intellij.codeInspection.blockingCallsDetection.AnnotationBasedBlockingMethodChecker.hasAnnotation;
-
-public class AnnotationBasedNonBlockingContextChecker implements NonBlockingContextChecker, PersistentStateChecker {
+public class AnnotationBasedNonBlockingContextChecker implements NonBlockingContextChecker {
 
   private final List<String> myNonBlockingAnnotations;
 
@@ -37,6 +36,6 @@ public class AnnotationBasedNonBlockingContextChecker implements NonBlockingCont
     if (callingMethod == null) return false;
     PsiMethod psiCallingMethod = callingMethod.getJavaPsi();
 
-    return hasAnnotation(psiCallingMethod, myNonBlockingAnnotations);
+    return AnnotationUtil.findAnnotation(psiCallingMethod, myNonBlockingAnnotations, false) != null;
   }
 }

jvm/jvm-analysis-impl/src/com/intellij/codeInspection/blockingCallsDetection/BlockingMethodInNonBlockingContextInspection.java

@@ -17,9 +17,6 @@ import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiMethod;
-import com.intellij.psi.util.CachedValueProvider;
-import com.intellij.psi.util.CachedValuesManager;
-import com.intellij.psi.util.PsiModificationTracker;
 import com.intellij.util.SmartList;
 import com.intellij.util.containers.ContainerUtil;
 import one.util.streamex.StreamEx;
@@ -32,8 +29,6 @@ import javax.swing.*;
 import java.awt.*;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
-import java.util.stream.Collectors;
 
 public class BlockingMethodInNonBlockingContextInspection extends AbstractBaseUastLocalInspectionTool {
 
@@ -130,14 +125,14 @@ public class BlockingMethodInNonBlockingContextInspection extends AbstractBaseUa
 
   private static class BlockingMethodInNonBlockingContextVisitor extends PsiElementVisitor {
     private final ProblemsHolder myHolder;
-    private final Map<Boolean, ? extends List<? extends BlockingMethodChecker>> myBlockingMethodCheckers;
+    private final List<? extends BlockingMethodChecker> myBlockingMethodCheckers;
     private final List<? extends NonBlockingContextChecker> myNonBlockingContextCheckers;
 
     BlockingMethodInNonBlockingContextVisitor(@NotNull ProblemsHolder holder,
                                               List<? extends BlockingMethodChecker> blockingMethodCheckers,
                                               List<? extends NonBlockingContextChecker> nonBlockingContextCheckers) {
       myHolder = holder;
-      this.myBlockingMethodCheckers = blockingMethodCheckers.stream().collect(Collectors.partitioningBy(checker -> checker instanceof PersistentStateChecker));
+      this.myBlockingMethodCheckers = blockingMethodCheckers;
       this.myNonBlockingContextCheckers = nonBlockingContextCheckers;
     }
 
@@ -152,10 +147,7 @@ public class BlockingMethodInNonBlockingContextInspection extends AbstractBaseUa
       PsiMethod referencedMethod = callExpression.resolve();
       if (referencedMethod == null) return;
 
-      final boolean isBlockingCachedValue = queryCacheIfMethodIsBlocking(referencedMethod, myBlockingMethodCheckers.get(false));
-      if (!isBlockingCachedValue && !queryProvidersIfMethodIsBlocking(referencedMethod, myBlockingMethodCheckers.get(true))) {
-        return;
-      }
+      if (!isMethodOrSupersBlocking(referencedMethod, myBlockingMethodCheckers)) return;
 
       PsiElement elementToHighLight = AnalysisUastUtil.getMethodIdentifierSourcePsi(callExpression);
       if (elementToHighLight == null) return;
@@ -164,14 +156,8 @@ public class BlockingMethodInNonBlockingContextInspection extends AbstractBaseUa
     }
   }
 
-  private static boolean queryCacheIfMethodIsBlocking(PsiMethod referencedMethod, List<? extends BlockingMethodChecker> myBlockingMethodCheckers) {
-    return CachedValuesManager.getCachedValue(referencedMethod, () -> CachedValueProvider.Result.create(
-      queryProvidersIfMethodIsBlocking(referencedMethod, myBlockingMethodCheckers),
-      PsiModificationTracker.MODIFICATION_COUNT));
-  }
-
-  private static boolean queryProvidersIfMethodIsBlocking(PsiMethod referencedMethod,
-                                                          List<? extends BlockingMethodChecker> blockingMethodCheckers) {
+  private static boolean isMethodOrSupersBlocking(PsiMethod referencedMethod,
+                                                  List<? extends BlockingMethodChecker> blockingMethodCheckers) {
     return StreamEx.of(referencedMethod).append(referencedMethod.findDeepestSuperMethods())
       .anyMatch(method -> isMethodBlocking(method, blockingMethodCheckers));
   }