com.intellij.psi.search.LocalSearchScope#com.intellij.psi.search.searches.ReferencesSearch源码实例Demo

private void process(
    final ReferencesSearch.SearchParameters queryParameters,
    final PsiElement elementToSearch,
    final Project project) {
  Optional.ofNullable(((PsiNamedElement) elementToSearch).getName())
      .ifPresent(
          word -> {
            final String escaped = PathExpressionUtil.escapeJsonPointer(word);

            if (!escaped.equals(word)) {
              queryParameters
                  .getOptimizer()
                  .searchWord(
                      escaped,
                      GlobalSearchScope.allScope(project),
                      CASE_SENSITIVE,
                      elementToSearch);
            }
          });
}
 

@Nullable
@Override
public List<UsageInfo> findUsages(final PsiFile psiFile, final PsiDirectory newParent, final boolean searchInComments, final boolean searchInNonJavaFiles) {
  Query<PsiReference> search = ReferencesSearch.search(psiFile);
  final List<PsiExtraFileReference> extraFileRefs = new ArrayList<PsiExtraFileReference>();
  search.forEach(new Processor<PsiReference>() {
    @Override
    public boolean process(PsiReference psiReference) {
      if (psiReference instanceof PsiExtraFileReference) {
        extraFileRefs.add((PsiExtraFileReference) psiReference);
      }
      return true;
    }
  });

  if (extraFileRefs.isEmpty()) {
    return null;
  } else {
    final List<UsageInfo> result = new ArrayList<UsageInfo>(extraFileRefs.size());
    for (final PsiExtraFileReference e : extraFileRefs) {
      result.add(new FileUsageInfo(e));
    }
    return result;
  }
}
 

@Nonnull
@Override
@RequiredReadAction
protected UsageInfo[] findUsages()
{
	List<UsageInfo> result = new ArrayList<>();
	Set<Couple<DotNetNamedElement>> children = CSharpMoveClassesUtil.findTypesAndNamespaces(myDeclaration);

	for(Couple<DotNetNamedElement> couple : children)
	{
		DotNetNamedElement second = couple.getSecond();

		for(PsiReference reference : ReferencesSearch.search(second, CSharpClassesMoveProcessor.mapScope(second)))
		{
			result.add(new CSharpClassesMoveProcessor.MyUsageInfo(reference.getElement(), couple, reference));
		}
	}

	return result.toArray(new UsageInfo[result.size()]);
}
 

@Override
public void processQuery(@Nonnull ReferencesSearch.SearchParameters queryParameters, @Nonnull Processor<? super PsiReference> consumer)
{
	PsiElement elementToSearch = queryParameters.getElementToSearch();

	PsiElement declaration = elementToSearch.getUserData(CSharpResolveUtil.EXTENSION_METHOD_WRAPPER);
	if(declaration == null)
	{
		declaration = elementToSearch.getUserData(CSharpResolveUtil.ACCESSOR_VALUE_VARIABLE_OWNER);
	}

	if(declaration == null)
	{
		return;
	}

	ReferencesSearch.search(declaration, queryParameters.getEffectiveSearchScope(), queryParameters.isIgnoreAccessScope()).forEach(consumer);
}
 

@NotNull
protected UsageInfo[] findUsages() {
  PsiReference[] refs = ReferencesSearch.search(myClass, GlobalSearchScope.projectScope(myProject), false).toArray(new PsiReference[0]);
  final ArrayList<UsageInfo> result = new ArrayList<UsageInfo>();
  detectTurnToSuperRefs(refs, result);
  final PsiPackage originalPackage = JavaDirectoryService.getInstance().getPackage(myClass.getContainingFile().getContainingDirectory());
  if (Comparing.equal(JavaDirectoryService.getInstance().getPackage(myTargetDirectory), originalPackage)) {
    result.clear();
  }
  for (final PsiReference ref : refs) {
    final PsiElement element = ref.getElement();
    if (!canTurnToSuper(element) && !RefactoringUtil.inImportStatement(ref, element)) {
      result.add(new BindToOldUsageInfo(element, ref, myClass));
    }
  }
  UsageInfo[] usageInfos = result.toArray(new UsageInfo[result.size()]);
  return UsageViewUtil.removeDuplicatedUsages(usageInfos);
}
 

@Override
public void invoke(@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement,
                   @NotNull PsiElement endElement) {
  super.invoke(project, file, startElement, endElement);

  final PsiNamedElement psiNamedElement = elementToRemove.getElement();
  if (null != psiNamedElement) {
    final Collection<PsiReference> all = ReferencesSearch.search(psiNamedElement).findAll();

    final String loggerName = getLoggerName(PsiTreeUtil.getParentOfType(psiNamedElement, PsiClass.class));
    for (PsiReference psiReference : all) {
      psiReference.handleElementRename(loggerName);
    }

    psiNamedElement.delete();

    JavaCodeStyleManager.getInstance(project).removeRedundantImports((PsiJavaFile) file);
  }
}
 

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

@Override
@Nonnull
protected UsageInfo[] findUsages() {
  ArrayList<UsageInfo> result = new ArrayList<>();
  for (int i = 0; i < myElementsToMove.length; i++) {
    PsiElement element = myElementsToMove[i];
    if (mySearchForReferences) {
      for (PsiReference reference : ReferencesSearch.search(element, GlobalSearchScope.projectScope(myProject))) {
        result.add(new MyUsageInfo(reference.getElement(), i, reference));
      }
    }
    findElementUsages(result, element);
  }

  return result.toArray(new UsageInfo[result.size()]);
}
 

private static void validateInterfaceType(PsiClass interfaceType, List<Diagnostic> diagnostics,
		JavaDiagnosticsContext context) {
	boolean hasRegisterRestClient = AnnotationUtils.hasAnnotation(interfaceType, REGISTER_REST_CLIENT_ANNOTATION);
	if (hasRegisterRestClient) {
		return;
	}

	final AtomicInteger nbReferences = new AtomicInteger(0);
	Query<PsiReference> query = ReferencesSearch.search(interfaceType, createSearchScope(context.getJavaProject()));
	query.forEach(match -> {
		PsiElement o = PsiTreeUtil.getParentOfType(match.getElement(), PsiField.class);
		if (o instanceof PsiField) {
			PsiField field = (PsiField) o;
			boolean hasInjectAnnotation = AnnotationUtils.hasAnnotation(field, INJECT_ANNOTATION);
			boolean hasRestClientAnnotation = AnnotationUtils.hasAnnotation(field, REST_CLIENT_ANNOTATION);
			if (hasInjectAnnotation && hasRestClientAnnotation) {
				nbReferences.incrementAndGet();
			}
		}
	});

	if (nbReferences.get() > 0) {
		String uri = context.getUri();
		Range restInterfaceRange = PositionUtils.toNameRange(interfaceType, context.getUtils());
		Diagnostic d = context.createDiagnostic(uri,
				"The interface `" + interfaceType.getName()
						+ "` does not have the @RegisterRestClient annotation. The " + nbReferences.get()
						+ " fields references will not be injected as CDI beans.",
				restInterfaceRange, MicroProfileRestClientConstants.DIAGNOSTIC_SOURCE,
				MicroProfileRestClientErrorCode.RegisterRestClientAnnotationMissing);
		diagnostics.add(d);
	}
}
 

@Override
public void processQuery(@NotNull ReferencesSearch.SearchParameters queryParameters, @NotNull Processor<? super PsiReference> consumer) {
    PsiElement refElement = queryParameters.getElementToSearch();
    if (!(refElement instanceof DotEnvProperty)) return;

    addPropertyUsages((DotEnvProperty)refElement, queryParameters.getEffectiveSearchScope(), queryParameters.getOptimizer());
}
 

private void warn(
    final PsiElement psiElement,
    final AnnotationHolder annotationHolder,
    final PsiElement searchableCurrentElement,
    final String warning) {
  final PsiReference first = ReferencesSearch.search(searchableCurrentElement).findFirst();

  if (first == null) {
    Annotation annotation = annotationHolder.createWeakWarningAnnotation(psiElement, warning);
    annotation.setHighlightType(ProblemHighlightType.LIKE_UNUSED_SYMBOL);
  }
}
 

private void warn(
    final PsiElement psiElement,
    final AnnotationHolder annotationHolder,
    final PsiElement searchableCurrentElement,
    final String warning) {
  final PsiReference first = ReferencesSearch.search(searchableCurrentElement).findFirst();

  if (first == null) {
    Annotation annotation = annotationHolder.createWeakWarningAnnotation(psiElement, warning);
    annotation.setHighlightType(ProblemHighlightType.LIKE_UNUSED_SYMBOL);
  }
}
 

@Override
public void processQuery(
    @NotNull final ReferencesSearch.SearchParameters queryParameters,
    @NotNull final Processor<? super PsiReference> consumer) {
  final PsiElement elementToSearch = queryParameters.getElementToSearch();

  final Project project = queryParameters.getProject();

  if (indexFacade.isIndexReady(project)) {
    if (isSpec(elementToSearch, project)) {
      process(queryParameters, elementToSearch, project);
    }
  }
}
 

/**
 * 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();
}
 

@NotNull
@Override
protected Collection<PsiReference> resolveOuterReferences(PsiElement psiElement) {
    Collection<PsiReference> result = new ArrayList<>();
    if (!(psiElement instanceof PsiJavaFile)) {
        return result;
    }
    PsiClass[] classes = ((PsiJavaFile) psiElement).getClasses();
    for (PsiClass psiClass : classes) {
        result.addAll(ReferencesSearch.search(psiClass, GlobalSearchScopes.projectProductionScope(getProject())).findAll());
    }
    return result;
}
 

@NotNull
@Override
protected IncrementableSet<SourceTargetPair> resolveRelationships() {
    PsiElement psiElement = getBaseElement();
    IncrementableSet<SourceTargetPair> incrementableSet = new IncrementableSet<>();

    for (DiagramNode<PsiElement> node : getNodes()) {
        PsiElement callee = node.getIdentifyingElement();

        Collection<PsiReference> all = ReferencesSearch.search(callee, new LocalSearchScope
                (psiElement)).findAll();

        for (PsiReference psiReference : all) {
            if (!(psiReference instanceof CompositePsiElement)) {
                continue;
            }
            PsiElement caller = PsiUtils.getRootPsiElement((PsiClass) psiElement, (CompositePsiElement) psiReference);

            if (caller == null) {
                continue;
            }

            incrementableSet.increment(new SourceTargetPair(caller, callee));
        }
    }
    return incrementableSet;
}
 

private void removeIfNoReference(OCElement element) {
	for (PsiReference reference : ReferencesSearch.search(element, searchScope)) {
		PsiElement referenceElement = reference.getElement();
		if (!isParentFor(element, referenceElement)) {
			return;
		}
	}
	toDelete.add(element);
}
 

@Override
public void processQuery(@Nonnull ReferencesSearch.SearchParameters searchParameters, @Nonnull Processor<? super PsiReference> processor)
{
	SearchScope scope = ReadAction.compute(searchParameters::getEffectiveSearchScope);
	if(!(scope instanceof GlobalSearchScope))
	{
		return;
	}

	Project project = searchParameters.getProject();

	PsiElement element = searchParameters.getElementToSearch();
	if(ReadAction.compute(() -> Unity3dModuleExtensionUtil.getRootModule(searchParameters.getProject()) != null))
	{
		if(element instanceof CSharpFieldDeclaration)
		{
			String name = ReadAction.compute(((CSharpFieldDeclaration) element)::getName);
			MultiMap<VirtualFile, Unity3dYMLAsset> map = ReadAction.compute(() -> Unity3dYMLAsset.findAssetAsAttach(project, PsiUtilCore.getVirtualFile(element)));

			for(VirtualFile virtualFile : map.keySet())
			{
				ProgressManager.checkCanceled();

				searchParameters.getOptimizer().searchWord(name + ":", GlobalSearchScope.fileScope(project, virtualFile), true, element);
			}
		}
		else if(element instanceof YAMLFile)
		{
			String guid = ReadAction.compute(() -> Unity3dMetaManager.getInstance(project).getGUID(PsiUtilCore.getVirtualFile(element)));
			if(guid != null)
			{
				searchParameters.getOptimizer().searchWord(guid, GlobalSearchScope.allScope(project), true, element);
			}
		}
	}
}
 

@Override
public void processQuery(@NotNull ReferencesSearch.SearchParameters searchParameters, @NotNull Processor<? super PsiReference> processor) {
    ApplicationManager.getApplication().runReadAction(() -> {
        if (!helper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch())) return;
        if (EventQueue.isDispatchThread())
            ProgressManager.getInstance().runProcessWithProgressSynchronously(() -> processElements(searchParameters, processor), "Find Usages", true, searchParameters.getElementToSearch().getProject());
        else
            processElements(searchParameters, processor);
    });
}
 

private void processElements(final ReferencesSearch.SearchParameters searchParameters, final Processor<? super PsiReference> processor) {
    ApplicationManager.getApplication().runReadAction(() -> {
        StepCollector collector = helper.getStepCollector(searchParameters.getElementToSearch());
        collector.collect();
        final List<PsiElement> elements = helper.getPsiElements(collector, searchParameters.getElementToSearch());
        for (PsiElement element : elements)
            processor.process(element.getReference());
    });
}
 

@Test
public void testShouldFindReferencesOfGaugeElement() throws Exception {
    SpecStepImpl element = mock(SpecStepImpl.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, GlobalSearchScope.allScope(project), true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(true);

    boolean shouldFindReferences = new ReferenceSearchHelper(moduleHelper).shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    assertTrue("Should find reference for SpecStep(Expected: true, Actual: false)", shouldFindReferences);
}
 

@Test
public void testShouldNotFindReferencesOfNonGaugeElement() throws Exception {
    PsiClass element = mock(PsiClass.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, GlobalSearchScope.allScope(project), true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(true);

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper(moduleHelper);
    boolean shouldFindReferences = referenceSearchHelper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    assertFalse("Should find reference for PsiClass(Expected: false, Actual: true)", shouldFindReferences);
}
 

@Test
public void testShouldNotFindReferencesWhenUnknownScope() throws Exception {
    PsiClass element = mock(PsiClass.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(true);
    when(scope.getDisplayName()).thenReturn(ReferenceSearchHelper.UNKNOWN_SCOPE);

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper(moduleHelper);
    boolean shouldFindReferences = referenceSearchHelper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    assertFalse("Should find reference When unknown scope(Expected: false, Actual: true)", shouldFindReferences);
}
 

@Test
public void testShouldFindReferencesWhenNotUnknownScope() throws Exception {
    PsiClass element = mock(PsiClass.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(true);
    when(scope.getDisplayName()).thenReturn("Other Scope");

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper(moduleHelper);
    boolean shouldFindReferences = referenceSearchHelper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    assertFalse("Should find reference When scope is not unknown(Expected: true, Actual: false)", shouldFindReferences);
}
 

@Test
public void testGetReferenceElements() throws Exception {
    SpecStepImpl element = mock(SpecStepImpl.class);
    when(element.getProject()).thenReturn(project);
    StepValue stepValue = new StepValue("hello", "", new ArrayList<>());
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(element.getStepValue()).thenReturn(stepValue);

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper();
    referenceSearchHelper.getPsiElements(collector, searchParameters.getElementToSearch());

    verify(collector, times(1)).get("hello");
}
 

@Test
public void testGetReferenceElementsForConceptStep() throws Exception {
    ConceptStepImpl element = mock(ConceptStepImpl.class);
    when(element.getProject()).thenReturn(project);
    StepValue stepValue = new StepValue("# hello", "", new ArrayList<>());
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(element.getStepValue()).thenReturn(stepValue);

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper();
    referenceSearchHelper.getPsiElements(collector, searchParameters.getElementToSearch());

    verify(collector, times(1)).get("hello");
}
 

@Test
public void testShouldNotFindReferencesIfNotGaugeModule() throws Exception {
    SpecStepImpl element = mock(SpecStepImpl.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(false);

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper(moduleHelper);
    boolean shouldFindReferences = referenceSearchHelper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    assertFalse("Should find reference for non Gauge Module(Expected: false, Actual: true)", shouldFindReferences);

    verify(scope, never()).getDisplayName();
}
 

@Test
public void testShouldFindReferencesIfGaugeModule() throws Exception {
    SpecStepImpl element = mock(SpecStepImpl.class);
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, scope, true);

    when(moduleHelper.isGaugeModule(element)).thenReturn(true);
    when(scope.getDisplayName()).thenReturn("Other Scope");

    ReferenceSearchHelper referenceSearchHelper = new ReferenceSearchHelper(moduleHelper);
    referenceSearchHelper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch());

    verify(scope, times(1)).getDisplayName();
}
 

@Test
public void testShouldNotFindReferencesOfNonGaugeElement() throws Exception {
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, GlobalSearchScope.allScope(project), true);
    when(helper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch())).thenReturn(false);

    new ReferenceSearch(helper).processQuery(searchParameters, psiReference -> false);

    verify(helper, never()).getPsiElements(any(StepCollector.class), any(PsiElement.class));
}
 

@Test
public void testShouldFindReferencesOfGaugeElement() throws Exception {
    when(element.getProject()).thenReturn(project);
    ReferencesSearch.SearchParameters searchParameters = new ReferencesSearch.SearchParameters(element, GlobalSearchScope.allScope(project), true);

    when(helper.shouldFindReferences(searchParameters, searchParameters.getElementToSearch())).thenReturn(true);
    when(helper.getStepCollector(element)).thenReturn(collector);

    new ReferenceSearch(helper).processQuery(searchParameters, psiReference -> false);

    verify(helper, times(1)).getPsiElements(collector, element);
}