@Override
  protected boolean queryExternalUsagesRequests(@NotNull final RefManager manager,
                                                @NotNull final GlobalJavaInspectionContext globalContext,
                                                @NotNull final ProblemDescriptionsProcessor processor) {
    final EntryPointsManager entryPointsManager = globalContext.getEntryPointsManager(manager);
    for (RefElement entryPoint : entryPointsManager.getEntryPoints(manager)) {
      //don't ignore entry points with explicit visibility requirements
      if (ReadAction.nonBlocking(() -> entryPoint instanceof RefJavaElement && getMinVisibilityLevel((RefJavaElement)entryPoint) > 0)
        .executeSynchronously()) {
        continue;
      }
      ignoreElement(processor, entryPoint);
    }

    for (VisibilityExtension addin : EP_NAME.getExtensionList()) {
      addin.fillIgnoreList(manager, processor);
    }
    manager.iterate(new RefJavaVisitor() {
      @Override
      public void visitField(@NotNull final RefField refField) {
        if (processor.getDescriptions(refField) == null) return;
        if (!PsiModifier.PRIVATE.equals(refField.getAccessModifier())) {
          globalContext.enqueueFieldUsagesProcessor(refField, psiReference -> {
            ignoreElement(processor, refField);
            return false;
          });
        }
      }

      @Override
      public void visitMethod(@NotNull final RefMethod refMethod) {
        if (processor.getDescriptions(refMethod) == null) return;
        if (!refMethod.isExternalOverride() && !PsiModifier.PRIVATE.equals(refMethod.getAccessModifier()) &&
            !(refMethod instanceof RefImplicitConstructor)) {
          globalContext.enqueueDerivedMethodsProcessor(refMethod, derivedMethod -> {
            ignoreElement(processor, refMethod);
            return false;
          });

          globalContext.enqueueMethodUsagesProcessor(refMethod, psiReference -> {
            ignoreElement(processor, refMethod);
            return false;
          });
        }
      }

      @Override
      public void visitClass(@NotNull final RefClass refClass) {
        if (processor.getDescriptions(refClass) == null) return;
        if (!refClass.isAnonymous() && !PsiModifier.PRIVATE.equals(refClass.getAccessModifier())) {
          globalContext.enqueueDerivedClassesProcessor(refClass, inheritor -> {
            ignoreElement(processor, refClass);
            return false;
          });

          globalContext.enqueueClassUsagesProcessor(refClass, psiReference -> {
            ignoreElement(processor, refClass);
            return false;
          });

          final RefMethod defaultConstructor = refClass.getDefaultConstructor();
          if (entryPointsManager.isAddNonJavaEntries() && defaultConstructor != null) {
            final PsiClass psiClass = ObjectUtils.tryCast(refClass.getPsiElement(), PsiClass.class);
            String qualifiedName = psiClass != null ? psiClass.getQualifiedName() : null;
            if (qualifiedName != null) {
              final Project project = manager.getProject();
              PsiSearchHelper.getInstance(project)
                             .processUsagesInNonJavaFiles(qualifiedName, (file, startOffset, endOffset) -> {
                               entryPointsManager.addEntryPoint(defaultConstructor, false);
                               ignoreElement(processor, defaultConstructor);
                               return false;
                             }, GlobalSearchScope.projectScope(project));
            }
          }
        }
      }
    });
    return false;
  }
@Override
  protected boolean queryExternalUsagesRequests(@NotNull final RefManager manager,
                                                @NotNull final GlobalJavaInspectionContext globalContext,
                                                @NotNull final ProblemDescriptionsProcessor processor)