com.intellij.psi.search.SearchScope Java Examples

private static void removeUnusedCode(PsiFile file) {
	while (true) {
		Collection<PsiElement> toDelete = new ArrayList<>();
		Project project = file.getProject();
		SearchScope scope = GlobalSearchScope.fileScope(project, file.getVirtualFile());
		file.acceptChildren(new DeletionMarkingVisitor(toDelete, scope));
		if (toDelete.isEmpty()) {
			break;
		}
		WriteCommandAction.writeCommandAction(project).run(
				() -> {
					for (PsiElement element : toDelete) {
						element.delete();
					}
				}
		);

	}
}
 

SearchForUsagesRunnable(@Nonnull UsageViewManagerImpl usageViewManager,
                        @Nonnull Project project,
                        @Nonnull AtomicReference<UsageViewImpl> usageViewRef,
                        @Nonnull UsageViewPresentation presentation,
                        @Nonnull UsageTarget[] searchFor,
                        @Nonnull Factory<UsageSearcher> searcherFactory,
                        @Nonnull FindUsagesProcessPresentation processPresentation,
                        @Nonnull SearchScope searchScopeToWarnOfFallingOutOf,
                        @javax.annotation.Nullable UsageViewManager.UsageViewStateListener listener) {
  myProject = project;
  myUsageViewRef = usageViewRef;
  myPresentation = presentation;
  mySearchFor = searchFor;
  mySearcherFactory = searcherFactory;
  myProcessPresentation = processPresentation;
  mySearchScopeToWarnOfFallingOutOf = searchScopeToWarnOfFallingOutOf;
  myListener = listener;
  myUsageViewManager = usageViewManager;
}
 

@Override
public void highlightUsages(@Nonnull PsiFile file, @Nonnull Editor editor, boolean clearHighlights) {
  PsiElement target = getElement();

  if (file instanceof PsiCompiledFile) file = ((PsiCompiledFile)file).getDecompiledPsiFile();

  Project project = target.getProject();
  final FindUsagesManager findUsagesManager = ((FindManagerImpl)FindManager.getInstance(project)).getFindUsagesManager();
  final FindUsagesHandler handler = findUsagesManager.getFindUsagesHandler(target, true);

  // in case of injected file, use host file to highlight all occurrences of the target in each injected file
  PsiFile context = InjectedLanguageManager.getInstance(project).getTopLevelFile(file);
  SearchScope searchScope = new LocalSearchScope(context);
  Collection<PsiReference> refs = handler == null ? ReferencesSearch.search(target, searchScope, false).findAll() : handler.findReferencesToHighlight(target, searchScope);

  new HighlightUsagesHandler.DoHighlightRunnable(new ArrayList<>(refs), project, target, editor, context, clearHighlights).run();
}
 

@Nonnull
private static SearchScope calcScope(@Nonnull Project project, @Nullable DataContext dataContext) {
  String defaultScopeName = FindSettings.getInstance().getDefaultScopeName();
  List<SearchScope> predefined = PredefinedSearchScopeProvider.getInstance().getPredefinedScopes(project, dataContext, true, false, false,
                                                                                                 false);
  SearchScope resultScope = null;
  for (SearchScope scope : predefined) {
    if (scope.getDisplayName().equals(defaultScopeName)) {
      resultScope = scope;
      break;
    }
  }
  if (resultScope == null) {
    resultScope = ProjectScope.getProjectScope(project);
  }
  return resultScope;
}
 

@Test
public void testUseScope() throws Exception {
    PsiReference variableReference = configure();
    PsiFile included = addFile("included.bash");
    PsiFile notIncluded = addFile("notIncluded.bash");

    PsiElement varDef = variableReference.resolve();
    Assert.assertNotNull("Var must resolve", varDef);
    Assert.assertTrue("var def must resolve to the definition in included.bash", included.equals(varDef.getContainingFile()));

    SearchScope varDefUseScope = varDef.getUseScope();
    Assert.assertTrue("Invalid type of scope: " + varDefUseScope, varDefUseScope instanceof GlobalSearchScope);

    GlobalSearchScope useScope = (GlobalSearchScope) varDefUseScope;
    Assert.assertTrue("The use scope must contain the original file itself.", useScope.contains(included.getVirtualFile()));

    //must contain the file which contains the include statement
    Assert.assertTrue("The use scope must contain the files which include the source file.", useScope.contains(myFile.getVirtualFile()));

    //must not contain the file which does not include the inspected file
    Assert.assertFalse("The use scope must not contain any other file.", useScope.contains(notIncluded.getVirtualFile()));
}
 

@Nonnull
private static MyModel setTableModel(@Nonnull JTable table,
                                     @Nonnull UsageViewImpl usageView,
                                     @Nonnull final List<UsageNode> data,
                                     @Nonnull AtomicInteger outOfScopeUsages,
                                     @Nonnull SearchScope searchScope) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  final int columnCount = calcColumnCount(data);
  MyModel model = table.getModel() instanceof MyModel ? (MyModel)table.getModel() : null;
  if (model == null || model.getColumnCount() != columnCount) {
    model = new MyModel(data, columnCount);
    table.setModel(model);

    ShowUsagesTableCellRenderer renderer = new ShowUsagesTableCellRenderer(usageView, outOfScopeUsages, searchScope);
    for (int i = 0; i < table.getColumnModel().getColumnCount(); i++) {
      TableColumn column = table.getColumnModel().getColumn(i);
      column.setPreferredWidth(0);
      column.setCellRenderer(renderer);
    }
  }
  return model;
}
 

@Override
public boolean execute(@Nonnull final AllTypesSearch.SearchParameters queryParameters, @Nonnull final Processor<? super DotNetTypeDeclaration> consumer)
{
	SearchScope scope = queryParameters.getScope();

	if(scope instanceof GlobalSearchScope)
	{
		return processAllClassesInGlobalScope((GlobalSearchScope) scope, consumer, queryParameters);
	}

	PsiElement[] scopeRoots = ((LocalSearchScope) scope).getScope();
	for(final PsiElement scopeRoot : scopeRoots)
	{
		if(!processScopeRootForAllClasses(scopeRoot, consumer))
		{
			return false;
		}
	}
	return true;
}
 

@NotNull
@SuppressWarnings("unused")
public Collection<PsiReference> findReferences(@NotNull PsiElement element, @NotNull SearchScope searchScope,
                                               boolean searchInCommentsAndStrings) {
    if (element instanceof LSPPsiElement) {
        if (elements.contains(element)) {
            return elements.stream().map(PsiElement::getReference).filter(Objects::nonNull).collect(Collectors.toList());
        }
        EditorEventManager manager = EditorEventManagerBase.forEditor(FileUtils.editorFromPsiFile(element.getContainingFile()));
        if (manager != null) {
            Pair<List<PsiElement>, List<VirtualFile>> refs = manager.references(element.getTextOffset(), true, false);
            if (refs.getFirst() != null && refs.getSecond() != null) {
                addEditors(refs.getSecond());
                return refs.getFirst().stream().map(PsiElement::getReference).filter(Objects::nonNull).collect(Collectors.toList());
            }
        }
    }
    return new ArrayList<>();
}
 

public MicroProfileProjectInfo getMicroProfileProjectInfo(Module module,
                                                          List<MicroProfilePropertiesScope> scopes, ClasspathKind classpathKind, IPsiUtils utils,
                                                          DocumentFormat documentFormat) {
    MicroProfileProjectInfo info = createInfo(module, classpathKind);
    long startTime = System.currentTimeMillis();
    boolean excludeTestCode = classpathKind == ClasspathKind.SRC;
    PropertiesCollector collector = new PropertiesCollector(info, scopes);
    SearchScope scope = createSearchScope(module, scopes, classpathKind == ClasspathKind.TEST);
    SearchContext context = new SearchContext(module, scope, collector, utils, documentFormat);
    DumbService.getInstance(module.getProject()).runReadActionInSmartMode(() -> {
        Query<PsiModifierListOwner> query = createSearchQuery(context);
        beginSearch(context);
        query.forEach((Consumer<? super PsiModifierListOwner>) psiMember -> collectProperties(psiMember, context));
        endSearch(context);
    });
    LOGGER.info("End computing MicroProfile properties for '" + info.getProjectURI() + "' in "
            + (System.currentTimeMillis() - startTime) + "ms.");
    return info;
}
 

@Override
public void applyTo(@Nonnull FindModel findModel, @Nonnull FindPopupScopeUI.ScopeType selectedScope) {
  if (selectedScope == PROJECT) {
    findModel.setProjectScope(true);
  }
  else if (selectedScope == DIRECTORY) {
    String directory = myDirectoryChooser.getDirectory();
    findModel.setDirectoryName(directory);
  }
  else if (selectedScope == MODULE) {
    findModel.setModuleName((String)myModuleComboBox.getSelectedItem());
  }
  else if (selectedScope == SCOPE) {
    SearchScope selectedCustomScope = myScopeCombo.getSelectedScope();
    String customScopeName = selectedCustomScope == null ? null : selectedCustomScope.getDisplayName();
    findModel.setCustomScopeName(customScopeName);
    findModel.setCustomScope(selectedCustomScope);
    findModel.setCustomScope(true);
  }
}
 

@Override
public void prepareRenaming(@NotNull PsiElement element,
                            @NotNull String newName,
                            @NotNull Map<PsiElement, String> allRenames,
                            @NotNull SearchScope scope) {
  super.prepareRenaming(element, newName, allRenames, scope);
}
 

@Override
protected void analyze(@Nonnull final Project project, final AnalysisScope scope) {
  scope.setSearchInLibraries(true); //find library usages in project
  final SearchScope selectedScope = myPanel.myCombo.getSelectedScope();
  new BackwardDependenciesHandler(project, scope, selectedScope != null ? new AnalysisScope(selectedScope, project) : new AnalysisScope(project)).analyze();
  dispose();
}
 

public static Query<PsiMethod> search(final PsiMethod method, SearchScope scope, final boolean checkDeep, HaxeHierarchyTimeoutHandler timeoutHandler) {
  if (ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
    @Override
    public Boolean compute() {
      return cannotBeOverriden(method);
    }
  })) return EmptyQuery.getEmptyQuery(); // Optimization
  return INSTANCE.createUniqueResultsQuery(new SearchParameters(method, scope, checkDeep));
}
 

@Nullable
@Override
public SearchScope getAdditionalUseScope(PsiElement element) {
  if (isImplicitUsageMethod(element)) {
    return GlobalSearchScope.allScope(element.getProject());
  }
  return null;
}
 

@Nonnull
public SearchScope getScope() {
  return ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() {
    @Override
    public SearchScope compute() {
      return myScope.intersectWith(PsiSearchHelper.SERVICE.getInstance(myElement.getProject()).getUseScope(myElement));
    }
  });
}
 

private Set<UnloadedModuleDescription> computeUnloadedModulesFromUseScope(UsageViewDescriptor descriptor) {
  if (ModuleManager.getInstance(myProject).getUnloadedModuleDescriptions().isEmpty()) {
    //optimization
    return Collections.emptySet();
  }

  Set<UnloadedModuleDescription> unloadedModulesInUseScope = new LinkedHashSet<>();
  for (PsiElement element : descriptor.getElements()) {
    SearchScope useScope = element.getUseScope();
    if (useScope instanceof GlobalSearchScope) {
      unloadedModulesInUseScope.addAll(((GlobalSearchScope)useScope).getUnloadedModulesBelongingToScope());
    }
  }
  return unloadedModulesInUseScope;
}
 

@Nullable
@Override
public SearchScope getAdditionalResolveScope(VirtualFile file, Project project) {
  if (ProjectRootManager.getInstance(project).getFileIndex().isInContent(file)) {
    return ComponentScope.getInstance();
  }
  return null;
}
 

public void setCustomScope(final SearchScope customScope) {
  boolean changed = this.customScope != null ? this.customScope.equals(customScope) : customScope != null;
  this.customScope = customScope;
  if (changed) {
    notifyObservers();
  }
}
 

@Nullable
@Override
public SearchScope getAdditionalUseScope(PsiElement element) {
  if (isAutoFactoryClass(element)) {
    return GlobalSearchScope.allScope(element.getProject());
  }
  return null;
}
 

@Nullable
@Override
public SearchScope getAdditionalUseScope(PsiElement element) {
  if (!Blaze.isBlazeProject(element.getProject())) {
    return null;
  }
  if (isPyPackageOutsideProject(element) || isPyFileOutsideProject(element)) {
    return GlobalSearchScope.projectScope(element.getProject());
  }
  return null;
}
 

@NotNull
@Override
public SearchScope getUseScope() {
  if(this instanceof HaxeLocalFunctionDeclaration) {
    final PsiElement outerBlock = UsefulPsiTreeUtil.getParentOfType(this, HaxeBlockStatement.class);
    if(outerBlock != null) {
      return new LocalSearchScope(outerBlock);
    }
  }
  return super.getUseScope();
}
 

public static void registerScopeFilter(@Nonnull AbstractLayoutCodeProcessor processor, @Nullable final SearchScope scope) {
  if (scope == null) {
    return;
  }

  processor.addFileFilter(scope::contains);
}
 

/**
 * Returns references to the given element. If it is a BashPsiElement a special search scope is used to locate the elements referencing the file.
 *
 * @param element References to the given element
 * @return
 */
@NotNull
@Override
public Collection<PsiReference> findReferences(PsiElement element) {
    //fixme fix the custom scope
    SearchScope scope = (element instanceof BashPsiElement)
            ? BashElementSharedImpl.getElementUseScope((BashPsiElement) element, element.getProject())
            : GlobalSearchScope.projectScope(element.getProject());

    Query<PsiReference> search = ReferencesSearch.search(element, scope);
    return search.findAll();
}
 

@Nullable
SearchScope getSearchScope() {
  if (!myUseFileMask.isSelected()) return null;
  String text = (String)myFileMask.getSelectedItem();
  if (text == null) return null;

  final Condition<CharSequence> patternCondition = FindInProjectUtil.createFileMaskCondition(text);
  return new GlobalSearchScope() {
    @Override
    public boolean contains(@Nonnull VirtualFile file) {
      return patternCondition.value(file.getNameSequence());
    }

    @Override
    public int compare(@Nonnull VirtualFile file1, @Nonnull VirtualFile file2) {
      return 0;
    }

    @Override
    public boolean isSearchInModuleContent(@Nonnull Module aModule) {
      return true;
    }

    @Override
    public boolean isSearchInLibraries() {
      return true;
    }
  };
}
 

@NotNull
@Override
public SearchScope getUseScope() {
  final PsiElement localVar = UsefulPsiTreeUtil.getParentOfType(this, HaxeLocalVarDeclaration.class);
  if (localVar != null) {
    final PsiElement outerBlock = UsefulPsiTreeUtil.getParentOfType(localVar, HaxeBlockStatement.class);
    if (outerBlock != null) {
      return new LocalSearchScope(outerBlock);
    }
  }
  return super.getUseScope();
}
 

@Nullable
@Override
public SearchScope getSearchScope() {
  if (myUseScopeFilteringCb.isSelected()) {
    return myScopeCombo.getSelectedScope();
  }

  return null;
}
 

@Override
public void setUp() throws Exception {
    super.setUp();
    project = myFixture.getProject();
    moduleHelper = mock(ModuleHelper.class);
    scope = mock(SearchScope.class);
    collector = mock(StepCollector.class);
}
 

@Nonnull
@Override
public SearchScope getUseScope()
{
	PsiElement parent = getParent();
	if(parent instanceof DotNetParameterList)
	{
		return new LocalSearchScope(parent.getParent());
	}
	return super.getUseScope();
}
 

public AnalysisScope(@Nonnull SearchScope scope, @Nonnull Project project) {
  myProject = project;
  myElement = null;
  myModule = null;
  myModules = null;
  myScope = scope;
  myType = CUSTOM;
  mySearchInLibraries = scope instanceof GlobalSearchScope && ((GlobalSearchScope)scope).isSearchInLibraries();
  myVFiles = null;
}
 

@NotNull
private static SearchScope notNullizeScope(@NotNull FindUsagesOptions options,
    @NotNull Project project) {
  SearchScope scope = options.searchScope;
  if (scope == null) return ProjectScope.getAllScope(project);
  return scope;
}