Search in sources :

Example 56 with SearchScope

use of com.intellij.psi.search.SearchScope in project intellij-community by JetBrains.

the class TargetElementUtil method getSearchScope.

@Override
@NotNull
public SearchScope getSearchScope(Editor editor, @NotNull PsiElement element) {
    TargetElementEvaluatorEx2 evaluator = getElementEvaluatorsEx2(element.getLanguage());
    SearchScope result = evaluator != null ? evaluator.getSearchScope(editor, element) : null;
    if (result != null)
        return result;
    PsiFile file = element.getContainingFile();
    return PsiSearchHelper.SERVICE.getInstance(element.getProject()).getUseScope(file != null ? file : element);
}
Also used : SearchScope(com.intellij.psi.search.SearchScope) NotNull(org.jetbrains.annotations.NotNull)

Example 57 with SearchScope

use of com.intellij.psi.search.SearchScope in project intellij-community by JetBrains.

the class BaseAnalysisActionDialog method getScope.

@NotNull
public AnalysisScope getScope(@NotNull AnalysisUIOptions uiOptions, @NotNull AnalysisScope defaultScope, @NotNull Project project, Module module) {
    AnalysisScope scope;
    if (isProjectScopeSelected()) {
        scope = new AnalysisScope(project);
        uiOptions.SCOPE_TYPE = AnalysisScope.PROJECT;
    } else {
        final SearchScope customScope = getCustomScope();
        if (customScope != null) {
            scope = new AnalysisScope(customScope, project);
            uiOptions.SCOPE_TYPE = AnalysisScope.CUSTOM;
            uiOptions.CUSTOM_SCOPE_NAME = customScope.getDisplayName();
        } else if (isModuleScopeSelected()) {
            scope = new AnalysisScope(module);
            uiOptions.SCOPE_TYPE = AnalysisScope.MODULE;
        } else if (isUncommitedFilesSelected()) {
            final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
            List<VirtualFile> files;
            if (myChangeLists.getSelectedItem() == ALL) {
                files = changeListManager.getAffectedFiles();
            } else {
                files = new ArrayList<>();
                for (ChangeList list : changeListManager.getChangeListsCopy()) {
                    if (!Comparing.strEqual(list.getName(), (String) myChangeLists.getSelectedItem()))
                        continue;
                    final Collection<Change> changes = list.getChanges();
                    for (Change change : changes) {
                        final ContentRevision afterRevision = change.getAfterRevision();
                        if (afterRevision != null) {
                            final VirtualFile vFile = afterRevision.getFile().getVirtualFile();
                            if (vFile != null) {
                                files.add(vFile);
                            }
                        }
                    }
                }
            }
            scope = new AnalysisScope(project, new HashSet<>(files));
            uiOptions.SCOPE_TYPE = AnalysisScope.UNCOMMITTED_FILES;
        } else {
            scope = defaultScope;
            //just not project scope
            uiOptions.SCOPE_TYPE = defaultScope.getScopeType();
        }
    }
    uiOptions.ANALYZE_TEST_SOURCES = isInspectTestSources();
    scope.setIncludeTestSource(isInspectTestSources());
    FindSettings.getInstance().setDefaultScopeName(scope.getDisplayName());
    return scope;
}
Also used : VirtualFile(com.intellij.openapi.vfs.VirtualFile) ChangeList(com.intellij.openapi.vcs.changes.ChangeList) SearchScope(com.intellij.psi.search.SearchScope) GlobalSearchScope(com.intellij.psi.search.GlobalSearchScope) ContentRevision(com.intellij.openapi.vcs.changes.ContentRevision) Change(com.intellij.openapi.vcs.changes.Change) ChangeListManager(com.intellij.openapi.vcs.changes.ChangeListManager) NotNull(org.jetbrains.annotations.NotNull)

Example 58 with SearchScope

use of com.intellij.psi.search.SearchScope in project intellij-community by JetBrains.

the class GlobalInspectionContextImpl method runTools.

@Override
protected void runTools(@NotNull final AnalysisScope scope, boolean runGlobalToolsOnly, boolean isOfflineInspections) {
    final ProgressIndicator progressIndicator = ProgressIndicatorProvider.getGlobalProgressIndicator();
    if (progressIndicator == null) {
        throw new IncorrectOperationException("Must be run under progress");
    }
    if (!isOfflineInspections && ApplicationManager.getApplication().isDispatchThread()) {
        throw new IncorrectOperationException("Must not start inspections from within EDT");
    }
    if (ApplicationManager.getApplication().isWriteAccessAllowed()) {
        throw new IncorrectOperationException("Must not start inspections from within write action");
    }
    // in offline inspection application we don't care about global read action
    if (!isOfflineInspections && ApplicationManager.getApplication().isReadAccessAllowed()) {
        throw new IncorrectOperationException("Must not start inspections from within global read action");
    }
    final InspectionManager inspectionManager = InspectionManager.getInstance(getProject());
    ((RefManagerImpl) getRefManager()).initializeAnnotators();
    final List<Tools> globalTools = new ArrayList<>();
    final List<Tools> localTools = new ArrayList<>();
    final List<Tools> globalSimpleTools = new ArrayList<>();
    initializeTools(globalTools, localTools, globalSimpleTools);
    appendPairedInspectionsForUnfairTools(globalTools, globalSimpleTools, localTools);
    runGlobalTools(scope, inspectionManager, globalTools, isOfflineInspections);
    if (runGlobalToolsOnly || localTools.isEmpty() && globalSimpleTools.isEmpty())
        return;
    SearchScope searchScope = ReadAction.compute(scope::toSearchScope);
    final Set<VirtualFile> localScopeFiles = searchScope instanceof LocalSearchScope ? new THashSet<>() : null;
    for (Tools tools : globalSimpleTools) {
        GlobalInspectionToolWrapper toolWrapper = (GlobalInspectionToolWrapper) tools.getTool();
        GlobalSimpleInspectionTool tool = (GlobalSimpleInspectionTool) toolWrapper.getTool();
        tool.inspectionStarted(inspectionManager, this, getPresentation(toolWrapper));
    }
    final boolean headlessEnvironment = ApplicationManager.getApplication().isHeadlessEnvironment();
    final Map<String, InspectionToolWrapper> map = getInspectionWrappersMap(localTools);
    final BlockingQueue<PsiFile> filesToInspect = new ArrayBlockingQueue<>(1000);
    // use original progress indicator here since we don't want it to cancel on write action start
    ProgressIndicator iteratingIndicator = new SensitiveProgressWrapper(progressIndicator);
    Future<?> future = startIterateScopeInBackground(scope, localScopeFiles, headlessEnvironment, filesToInspect, iteratingIndicator);
    Processor<PsiFile> processor = file -> {
        ProgressManager.checkCanceled();
        if (!ApplicationManagerEx.getApplicationEx().tryRunReadAction(() -> {
            if (!file.isValid()) {
                return;
            }
            LOG.assertTrue(scope.contains(file.getVirtualFile()), file.getName());
            inspectFile(file, inspectionManager, localTools, globalSimpleTools, map);
        })) {
            throw new ProcessCanceledException();
        }
        boolean includeDoNotShow = includeDoNotShow(getCurrentProfile());
        Stream.concat(getWrappersFromTools(localTools, file, includeDoNotShow).stream(), getWrappersFromTools(globalSimpleTools, file, includeDoNotShow).stream()).filter(wrapper -> wrapper.getTool() instanceof ExternalAnnotatorBatchInspection).forEach(wrapper -> {
            ProblemDescriptor[] descriptors = ((ExternalAnnotatorBatchInspection) wrapper.getTool()).checkFile(file, this, inspectionManager);
            InspectionToolPresentation toolPresentation = getPresentation(wrapper);
            ReadAction.run(() -> LocalDescriptorsUtil.addProblemDescriptors(Arrays.asList(descriptors), false, this, null, CONVERT, toolPresentation));
        });
        return true;
    };
    try {
        final Queue<PsiFile> filesFailedToInspect = new LinkedBlockingQueue<>();
        while (true) {
            Disposable disposable = Disposer.newDisposable();
            ProgressIndicator wrapper = new SensitiveProgressWrapper(progressIndicator);
            wrapper.start();
            ProgressIndicatorUtils.forceWriteActionPriority(wrapper, disposable);
            try {
                // use wrapper here to cancel early when write action start but do not affect the original indicator
                ((JobLauncherImpl) JobLauncher.getInstance()).processQueue(filesToInspect, filesFailedToInspect, wrapper, TOMBSTONE, processor);
                break;
            } catch (ProcessCanceledException ignored) {
                progressIndicator.checkCanceled();
                // go on with the write and then resume processing the rest of the queue
                assert !ApplicationManager.getApplication().isReadAccessAllowed();
                assert !ApplicationManager.getApplication().isDispatchThread();
                // wait for write action to complete
                ApplicationManager.getApplication().runReadAction(EmptyRunnable.getInstance());
            } finally {
                Disposer.dispose(disposable);
            }
        }
    } finally {
        // tell file scanning thread to stop
        iteratingIndicator.cancel();
        // let file scanning thread a chance to put TOMBSTONE and complete
        filesToInspect.clear();
        try {
            future.get(30, TimeUnit.SECONDS);
        } catch (Exception e) {
            LOG.error("Thread dump: \n" + ThreadDumper.dumpThreadsToString(), e);
        }
    }
    progressIndicator.checkCanceled();
    for (Tools tools : globalSimpleTools) {
        GlobalInspectionToolWrapper toolWrapper = (GlobalInspectionToolWrapper) tools.getTool();
        GlobalSimpleInspectionTool tool = (GlobalSimpleInspectionTool) toolWrapper.getTool();
        ProblemDescriptionsProcessor problemDescriptionProcessor = getProblemDescriptionProcessor(toolWrapper, map);
        tool.inspectionFinished(inspectionManager, this, problemDescriptionProcessor);
    }
    addProblemsToView(globalSimpleTools);
}
Also used : VirtualFile(com.intellij.openapi.vfs.VirtualFile) InjectedLanguageManager(com.intellij.lang.injection.InjectedLanguageManager) com.intellij.openapi.util(com.intellij.openapi.util) UIUtil(com.intellij.util.ui.UIUtil) ToolWindowManager(com.intellij.openapi.wm.ToolWindowManager) MessageType(com.intellij.openapi.ui.MessageType) ToggleAction(com.intellij.openapi.actionSystem.ToggleAction) VirtualFile(com.intellij.openapi.vfs.VirtualFile) HashMap(com.intellij.util.containers.HashMap) Document(com.intellij.openapi.editor.Document) HashSet(com.intellij.util.containers.HashSet) DefaultInspectionToolPresentation(com.intellij.codeInspection.ui.DefaultInspectionToolPresentation) THashSet(gnu.trove.THashSet) TripleFunction(com.intellij.util.TripleFunction) com.intellij.openapi.application(com.intellij.openapi.application) ProjectUtilCore(com.intellij.openapi.project.ProjectUtilCore) ProblemHighlightFilter(com.intellij.codeInsight.daemon.ProblemHighlightFilter) FileIndex(com.intellij.openapi.roots.FileIndex) PsiTreeUtil(com.intellij.psi.util.PsiTreeUtil) FileUtil(com.intellij.openapi.util.io.FileUtil) Logger(com.intellij.openapi.diagnostic.Logger) ProjectRootManager(com.intellij.openapi.roots.ProjectRootManager) InspectionToolPresentation(com.intellij.codeInspection.ui.InspectionToolPresentation) FileModificationService(com.intellij.codeInsight.FileModificationService) com.intellij.openapi.progress(com.intellij.openapi.progress) RefElement(com.intellij.codeInspection.reference.RefElement) IncorrectOperationException(com.intellij.util.IncorrectOperationException) IndexNotReadyException(com.intellij.openapi.project.IndexNotReadyException) PathMacroManager(com.intellij.openapi.components.PathMacroManager) java.util.concurrent(java.util.concurrent) InspectionResultsView(com.intellij.codeInspection.ui.InspectionResultsView) ProjectUtil(com.intellij.openapi.project.ProjectUtil) Collectors(java.util.stream.Collectors) Nullable(org.jetbrains.annotations.Nullable) Stream(java.util.stream.Stream) PsiUtilCore(com.intellij.psi.util.PsiUtilCore) Processor(com.intellij.util.Processor) com.intellij.psi(com.intellij.psi) NotNull(org.jetbrains.annotations.NotNull) JobLauncherImpl(com.intellij.concurrency.JobLauncherImpl) com.intellij.ui.content(com.intellij.ui.content) java.util(java.util) LocalInspectionsPass(com.intellij.codeInsight.daemon.impl.LocalInspectionsPass) CharsetToolkit(com.intellij.openapi.vfs.CharsetToolkit) CleanupInspectionIntention(com.intellij.codeInspection.actions.CleanupInspectionIntention) PerformAnalysisInBackgroundOption(com.intellij.analysis.PerformAnalysisInBackgroundOption) JobLauncher(com.intellij.concurrency.JobLauncher) GlobalInspectionContextExtension(com.intellij.codeInspection.lang.GlobalInspectionContextExtension) SensitiveProgressWrapper(com.intellij.concurrency.SensitiveProgressWrapper) NonNls(org.jetbrains.annotations.NonNls) ProgressIndicatorUtils(com.intellij.openapi.progress.util.ProgressIndicatorUtils) SearchScope(com.intellij.psi.search.SearchScope) ContainerUtil(com.intellij.util.containers.ContainerUtil) Constructor(java.lang.reflect.Constructor) ThreadDumper(com.intellij.diagnostic.ThreadDumper) LocalSearchScope(com.intellij.psi.search.LocalSearchScope) NamedScope(com.intellij.psi.search.scope.packageSet.NamedScope) CoreProgressManager(com.intellij.openapi.progress.impl.CoreProgressManager) ProblemGroup(com.intellij.lang.annotation.ProblemGroup) NotificationGroup(com.intellij.notification.NotificationGroup) ToolWindowId(com.intellij.openapi.wm.ToolWindowId) Project(com.intellij.openapi.project.Project) OutputStreamWriter(java.io.OutputStreamWriter) RefVisitor(com.intellij.codeInspection.reference.RefVisitor) RefManagerImpl(com.intellij.codeInspection.reference.RefManagerImpl) StringUtil(com.intellij.openapi.util.text.StringUtil) HighlightInfoProcessor(com.intellij.codeInsight.daemon.impl.HighlightInfoProcessor) AnalysisScope(com.intellij.analysis.AnalysisScope) FileOutputStream(java.io.FileOutputStream) ConcurrencyUtil(com.intellij.util.ConcurrencyUtil) IOException(java.io.IOException) com.intellij.codeInspection(com.intellij.codeInspection) AnalysisUIOptions(com.intellij.analysis.AnalysisUIOptions) GuiUtils(com.intellij.ui.GuiUtils) InspectionTreeState(com.intellij.codeInspection.ui.InspectionTreeState) Disposable(com.intellij.openapi.Disposable) File(java.io.File) ApplicationManagerEx(com.intellij.openapi.application.ex.ApplicationManagerEx) Element(org.jdom.Element) RefEntity(com.intellij.codeInspection.reference.RefEntity) DefaultInspectionToolPresentation(com.intellij.codeInspection.ui.DefaultInspectionToolPresentation) InspectionToolPresentation(com.intellij.codeInspection.ui.InspectionToolPresentation) RefManagerImpl(com.intellij.codeInspection.reference.RefManagerImpl) LocalSearchScope(com.intellij.psi.search.LocalSearchScope) Disposable(com.intellij.openapi.Disposable) JobLauncherImpl(com.intellij.concurrency.JobLauncherImpl) IncorrectOperationException(com.intellij.util.IncorrectOperationException) IndexNotReadyException(com.intellij.openapi.project.IndexNotReadyException) IOException(java.io.IOException) SearchScope(com.intellij.psi.search.SearchScope) LocalSearchScope(com.intellij.psi.search.LocalSearchScope) SensitiveProgressWrapper(com.intellij.concurrency.SensitiveProgressWrapper) IncorrectOperationException(com.intellij.util.IncorrectOperationException)

Example 59 with SearchScope

use of com.intellij.psi.search.SearchScope in project intellij-community by JetBrains.

the class GlobalInspectionContextImpl method cleanup.

private void cleanup(@NotNull final AnalysisScope scope, @NotNull InspectionProfile profile, @Nullable final Runnable postRunnable, @Nullable final String commandName) {
    setCurrentScope(scope);
    final int fileCount = scope.getFileCount();
    final ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator();
    final SearchScope searchScope = ReadAction.compute(scope::toSearchScope);
    final TextRange range;
    if (searchScope instanceof LocalSearchScope) {
        final PsiElement[] elements = ((LocalSearchScope) searchScope).getScope();
        range = elements.length == 1 ? ReadAction.compute(elements[0]::getTextRange) : null;
    } else {
        range = null;
    }
    final Iterable<Tools> inspectionTools = ContainerUtil.filter(profile.getAllEnabledInspectionTools(getProject()), tools -> {
        assert tools != null;
        return tools.getTool().getTool() instanceof CleanupLocalInspectionTool;
    });
    boolean includeDoNotShow = includeDoNotShow(profile);
    final RefManagerImpl refManager = (RefManagerImpl) getRefManager();
    refManager.inspectionReadActionStarted();
    List<ProblemDescriptor> descriptors = new ArrayList<>();
    Set<PsiFile> files = new HashSet<>();
    try {
        scope.accept(new PsiElementVisitor() {

            private int myCount;

            @Override
            public void visitFile(PsiFile file) {
                if (progressIndicator != null) {
                    progressIndicator.setFraction((double) ++myCount / fileCount);
                }
                if (isBinary(file))
                    return;
                final List<LocalInspectionToolWrapper> lTools = new ArrayList<>();
                for (final Tools tools : inspectionTools) {
                    final InspectionToolWrapper tool = tools.getEnabledTool(file, includeDoNotShow);
                    if (tool instanceof LocalInspectionToolWrapper) {
                        lTools.add((LocalInspectionToolWrapper) tool);
                        tool.initialize(GlobalInspectionContextImpl.this);
                    }
                }
                if (!lTools.isEmpty()) {
                    try {
                        final LocalInspectionsPass pass = new LocalInspectionsPass(file, PsiDocumentManager.getInstance(getProject()).getDocument(file), range != null ? range.getStartOffset() : 0, range != null ? range.getEndOffset() : file.getTextLength(), LocalInspectionsPass.EMPTY_PRIORITY_RANGE, true, HighlightInfoProcessor.getEmpty());
                        Runnable runnable = () -> pass.doInspectInBatch(GlobalInspectionContextImpl.this, InspectionManager.getInstance(getProject()), lTools);
                        ApplicationManager.getApplication().runReadAction(runnable);
                        final Set<ProblemDescriptor> localDescriptors = new TreeSet<>(CommonProblemDescriptor.DESCRIPTOR_COMPARATOR);
                        for (LocalInspectionToolWrapper tool : lTools) {
                            InspectionToolPresentation toolPresentation = getPresentation(tool);
                            for (CommonProblemDescriptor descriptor : toolPresentation.getProblemDescriptors()) {
                                if (descriptor instanceof ProblemDescriptor) {
                                    localDescriptors.add((ProblemDescriptor) descriptor);
                                }
                            }
                        }
                        if (searchScope instanceof LocalSearchScope) {
                            for (Iterator<ProblemDescriptor> iterator = localDescriptors.iterator(); iterator.hasNext(); ) {
                                final ProblemDescriptor descriptor = iterator.next();
                                final TextRange infoRange = descriptor instanceof ProblemDescriptorBase ? ((ProblemDescriptorBase) descriptor).getTextRange() : null;
                                if (infoRange != null && !((LocalSearchScope) searchScope).containsRange(file, infoRange)) {
                                    iterator.remove();
                                }
                            }
                        }
                        if (!localDescriptors.isEmpty()) {
                            descriptors.addAll(localDescriptors);
                            files.add(file);
                        }
                    } finally {
                        myPresentationMap.clear();
                    }
                }
            }
        });
    } finally {
        refManager.inspectionReadActionFinished();
    }
    if (files.isEmpty()) {
        GuiUtils.invokeLaterIfNeeded(() -> {
            if (commandName != null) {
                NOTIFICATION_GROUP.createNotification(InspectionsBundle.message("inspection.no.problems.message", scope.getFileCount(), scope.getDisplayName()), MessageType.INFO).notify(getProject());
            }
            if (postRunnable != null) {
                postRunnable.run();
            }
        }, ModalityState.defaultModalityState());
        return;
    }
    Runnable runnable = () -> {
        if (!FileModificationService.getInstance().preparePsiElementsForWrite(files))
            return;
        CleanupInspectionIntention.applyFixesNoSort(getProject(), "Code Cleanup", descriptors, null);
        if (postRunnable != null) {
            postRunnable.run();
        }
    };
    TransactionGuard.submitTransaction(getProject(), runnable);
}
Also used : DefaultInspectionToolPresentation(com.intellij.codeInspection.ui.DefaultInspectionToolPresentation) InspectionToolPresentation(com.intellij.codeInspection.ui.InspectionToolPresentation) HashSet(com.intellij.util.containers.HashSet) THashSet(gnu.trove.THashSet) RefManagerImpl(com.intellij.codeInspection.reference.RefManagerImpl) LocalInspectionsPass(com.intellij.codeInsight.daemon.impl.LocalInspectionsPass) HashSet(com.intellij.util.containers.HashSet) THashSet(gnu.trove.THashSet) LocalSearchScope(com.intellij.psi.search.LocalSearchScope) SearchScope(com.intellij.psi.search.SearchScope) LocalSearchScope(com.intellij.psi.search.LocalSearchScope)

Example 60 with SearchScope

use of com.intellij.psi.search.SearchScope in project intellij-community by JetBrains.

the class InspectionRVContentProviderImpl method checkReportedProblems.

@Override
public boolean checkReportedProblems(@NotNull GlobalInspectionContextImpl context, @NotNull final InspectionToolWrapper toolWrapper) {
    InspectionToolPresentation presentation = context.getPresentation(toolWrapper);
    presentation.updateContent();
    final SearchScope searchScope = context.getCurrentScope().toSearchScope();
    if (searchScope instanceof LocalSearchScope) {
        final Map<String, Set<RefEntity>> contents = presentation.getContent();
        final Map<RefEntity, CommonProblemDescriptor[]> problemElements = presentation.getProblemElements();
        for (Set<RefEntity> entities : contents.values()) {
            for (Iterator<RefEntity> iterator = entities.iterator(); iterator.hasNext(); ) {
                RefEntity entity = iterator.next();
                if (entity instanceof RefElement) {
                    final PsiElement element = ((RefElement) entity).getElement();
                    if (element != null) {
                        final TextRange range = element.getTextRange();
                        if (range != null && ((LocalSearchScope) searchScope).containsRange(element.getContainingFile(), range)) {
                            continue;
                        }
                    }
                }
                problemElements.remove(entity);
                iterator.remove();
            }
        }
    }
    return presentation.hasReportedProblems();
}
Also used : LocalSearchScope(com.intellij.psi.search.LocalSearchScope) HashSet(com.intellij.util.containers.HashSet) Set(java.util.Set) TextRange(com.intellij.openapi.util.TextRange) RefElement(com.intellij.codeInspection.reference.RefElement) RefEntity(com.intellij.codeInspection.reference.RefEntity) SearchScope(com.intellij.psi.search.SearchScope) LocalSearchScope(com.intellij.psi.search.LocalSearchScope) PsiElement(com.intellij.psi.PsiElement)

Aggregations

SearchScope (com.intellij.psi.search.SearchScope)90 GlobalSearchScope (com.intellij.psi.search.GlobalSearchScope)39 LocalSearchScope (com.intellij.psi.search.LocalSearchScope)36 Project (com.intellij.openapi.project.Project)21 NotNull (org.jetbrains.annotations.NotNull)21 VirtualFile (com.intellij.openapi.vfs.VirtualFile)18 PsiElement (com.intellij.psi.PsiElement)16 PsiClass (com.intellij.psi.PsiClass)8 Processor (com.intellij.util.Processor)8 com.intellij.psi (com.intellij.psi)6 PsiMethod (com.intellij.psi.PsiMethod)6 HashMap (com.intellij.util.containers.HashMap)6 ClassInheritorsSearch (com.intellij.psi.search.searches.ClassInheritorsSearch)5 Nullable (org.jetbrains.annotations.Nullable)5 AnalysisScope (com.intellij.analysis.AnalysisScope)4 ProgressManager (com.intellij.openapi.progress.ProgressManager)4 TextRange (com.intellij.openapi.util.TextRange)4 PsiFile (com.intellij.psi.PsiFile)4 PsiSearchHelper (com.intellij.psi.search.PsiSearchHelper)4 QueryExecutor (com.intellij.util.QueryExecutor)4