com.intellij.psi.PsiReferenceProvider Java Examples

PsiReferenceProvider createLocalReferenceProvider() {
  return new PsiReferenceProvider() {
    @NotNull
    @Override
    public PsiReference[] getReferencesByElement(
        @NotNull PsiElement element, @NotNull ProcessingContext context) {
      return Optional.ofNullable(element.getText())
          .map(
              text ->
                  new PsiReference[] {
                    new LocalReference(element, StringUtils.removeAllQuotes(text))
                  })
          .orElse(LocalReference.EMPTY_ARRAY);
    }
  };
}
 

PsiReferenceProvider createSchemaNameReferenceProvider() {
  return new PsiReferenceProvider() {
    @NotNull
    @Override
    public PsiReference[] getReferencesByElement(
        @NotNull PsiElement element, @NotNull ProcessingContext context) {
      return Optional.ofNullable(element.getText())
          .map(
              text ->
                  new PsiReference[] {
                    new SchemaNameReference(element, StringUtils.removeAllQuotes(text))
                  })
          .orElse(SchemaNameReference.EMPTY_ARRAY);
    }
  };
}
 

PsiReferenceProvider createFileReferenceProvider() {
  return new PsiReferenceProvider() {
    @NotNull
    @Override
    public PsiReference[] getReferencesByElement(
        @NotNull PsiElement element, @NotNull ProcessingContext context) {
      return Optional.ofNullable(element.getText())
          .map(
              text ->
                  new PsiReference[] {
                    new FileReference(element, StringUtils.removeAllQuotes(text))
                  })
          .orElse(FileReference.EMPTY_ARRAY);
    }
  };
}
 

@Override
public void registerReferenceProviders(@NotNull PsiReferenceRegistrar registrar) {

  registrar.registerReferenceProvider(
      PlatformPatterns.psiElement(BuckIdentifier.class),
      new PsiReferenceProvider() {
        @NotNull
        @Override
        public PsiReference[] getReferencesByElement(
            @NotNull PsiElement element, @NotNull ProcessingContext context) {
          if (element instanceof BuckIdentifier) {
            BuckIdentifier identifier = (BuckIdentifier) element;
            return new PsiReference[] {new BuckIdentifierReference(identifier)};
          } else {
            return new PsiReference[0];
          }
        }
      });
}
 

@Override
public void addAcceptableReferenceProviders(@Nonnull PsiElement position,
                                            @Nonnull List<ProviderInfo<Provider, ProcessingContext>> list,
                                            @Nonnull PsiReferenceService.Hints hints) {
  for (ProviderInfo<Provider, ElementPattern> trinity : myProviderPairs) {
    if (hints != PsiReferenceService.Hints.NO_HINTS && !((PsiReferenceProvider)trinity.provider).acceptsHints(position, hints)) {
      continue;
    }

    final ProcessingContext context = new ProcessingContext();
    if (hints != PsiReferenceService.Hints.NO_HINTS) {
      context.put(PsiReferenceService.HINTS, hints);
    }
    boolean suitable = false;
    try {
      suitable = trinity.processingContext.accepts(position, context);
    }
    catch (IndexNotReadyException ignored) {
    }
    if (suitable) {
      list.add(new ProviderInfo<Provider, ProcessingContext>(trinity.provider, context, trinity.priority));
    }
  }
}
 

private void registerNamedReferenceProvider(@Nonnull String[] names,
                                            final PsiNamePatternCondition<?> nameCondition,
                                            @Nonnull Class scopeClass,
                                            final boolean caseSensitive,
                                            @Nonnull PsiReferenceProvider provider,
                                            final double priority,
                                            @Nonnull ElementPattern pattern) {
  NamedObjectProviderBinding<PsiReferenceProvider> providerBinding = myNamedBindingsMap.get(scopeClass);

  if (providerBinding == null) {
    providerBinding = ConcurrencyUtil.cacheOrGet(myNamedBindingsMap, scopeClass, new NamedObjectProviderBinding<PsiReferenceProvider>() {
      @Override
      protected String getName(final PsiElement position) {
        return nameCondition.getPropertyValue(position);
      }
    });
  }

  providerBinding.registerProvider(names, pattern, caseSensitive, provider, priority);
}
 

@Nonnull
List<ProviderBinding.ProviderInfo<PsiReferenceProvider,ProcessingContext>> getPairsByElement(@Nonnull PsiElement element,
                                                                                             @Nonnull PsiReferenceService.Hints hints) {
  final Class<? extends PsiElement> clazz = element.getClass();
  List<ProviderBinding.ProviderInfo<PsiReferenceProvider, ProcessingContext>> ret = null;

  for (Class aClass : myKnownSupers.get(clazz)) {
    SimpleProviderBinding<PsiReferenceProvider> simpleBinding = myBindingsMap.get(aClass);
    NamedObjectProviderBinding<PsiReferenceProvider> namedBinding = myNamedBindingsMap.get(aClass);
    if (simpleBinding == null && namedBinding == null) continue;

    if (ret == null) ret = new SmartList<ProviderBinding.ProviderInfo<PsiReferenceProvider, ProcessingContext>>();
    if (simpleBinding != null) {
      simpleBinding.addAcceptableReferenceProviders(element, ret, hints);
    }
    if (namedBinding != null) {
      namedBinding.addAcceptableReferenceProviders(element, ret, hints);
    }
  }
  return ret == null ? Collections.<ProviderBinding.ProviderInfo<PsiReferenceProvider, ProcessingContext>>emptyList() : ret;
}
 

private void addMatchingProviders(final PsiElement position,
                                  @Nullable final List<ProviderInfo<Provider, ElementPattern>> providerList,
                                  @Nonnull List<ProviderInfo<Provider, ProcessingContext>> ret,
                                  PsiReferenceService.Hints hints) {
  if (providerList == null) return;

  for (ProviderInfo<Provider, ElementPattern> trinity : providerList) {
    if (hints != PsiReferenceService.Hints.NO_HINTS && !((PsiReferenceProvider)trinity.provider).acceptsHints(position, hints)) {
      continue;
    }

    final ProcessingContext context = new ProcessingContext();
    if (hints != PsiReferenceService.Hints.NO_HINTS) {
      context.put(PsiReferenceService.HINTS, hints);
    }
    boolean suitable = false;
    try {
      suitable = trinity.processingContext.accepts(position, context);
    }
    catch (IndexNotReadyException ignored) {
    }
    if (suitable) {
      ret.add(new ProviderInfo<Provider, ProcessingContext>(trinity.provider, context, trinity.priority));
    }
  }
}
 

/**
 * @deprecated {@see com.intellij.psi.PsiReferenceContributor
 */
public void registerReferenceProvider(@Nullable ElementFilter elementFilter,
                                      @Nonnull Class scope,
                                      @Nonnull PsiReferenceProvider provider,
                                      double priority) {
  PsiElementPattern.Capture<PsiElement> capture = PlatformPatterns.psiElement(scope);
  registerReferenceProvider(capture.and(new FilterPattern(elementFilter)), provider, priority);
}
 

/**
 * @deprecated {@link com.intellij.psi.PsiReferenceContributor}
 */
public void registerReferenceProvider(@Nullable ElementFilter elementFilter,
                                      @Nonnull Class scope,
                                      @Nonnull PsiReferenceProvider provider) {
  registerReferenceProvider(elementFilter, scope, provider, DEFAULT_PRIORITY);
}
 

public void unregisterReferenceProvider(@Nonnull Class scope, @Nonnull PsiReferenceProvider provider) {
  ProviderBinding<PsiReferenceProvider> providerBinding = myBindingsMap.get(scope);
  providerBinding.unregisterProvider(provider);
}
 

/**
 * @see com.intellij.psi.PsiReferenceContributor
 * @deprecated
 */
public void registerReferenceProvider(@Nonnull Class scope, @Nonnull PsiReferenceProvider provider) {
  registerReferenceProvider(null, scope, provider);
}