Java ElementPattern类代码示例

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
private void assertNavigationMatch(ElementPattern<?> pattern) {

        PsiElement psiElement = myFixture.getFile().findElementAt(myFixture.getCaretOffset());

        Set<String> targetStrings = new HashSet<String>();

        for (GotoDeclarationHandler gotoDeclarationHandler : Extensions.getExtensions(GotoDeclarationHandler.EP_NAME)) {

            PsiElement[] gotoDeclarationTargets = gotoDeclarationHandler.getGotoDeclarationTargets(psiElement, 0, myFixture.getEditor());
            if(gotoDeclarationTargets == null || gotoDeclarationTargets.length == 0) {
                continue;
            }

            for (PsiElement gotoDeclarationTarget : gotoDeclarationTargets) {
                targetStrings.add(gotoDeclarationTarget.toString());
                if(pattern.accepts(gotoDeclarationTarget)) {
                    return;
                }
            }
        }

        fail(String.format("failed that PsiElement (%s) navigate matches one of %s", psiElement.toString(), targetStrings.toString()));
    }
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
@NotNull
@Override
protected ElementPattern<PsiElement> compute() {
  return psiElement().andNot(psiElement().afterLeaf("@", ".")).
    andOr(
      psiElement().and(new FilterPattern(CLASS_BODY.getValue())).
        andOr(
          new FilterPattern(END_OF_BLOCK.getValue()),
          psiElement().afterLeaf(or(
            psiElement().inside(PsiModifierList.class),
            psiElement().withElementType(JavaTokenType.GT).inside(PsiTypeParameterList.class)
          ))),
      psiElement().withParents(PsiJavaCodeReferenceElement.class, PsiTypeElement.class, PsiMember.class),
      psiElement().withParents(PsiJavaCodeReferenceElement.class, PsiTypeElement.class, PsiClassLevelDeclarationStatement.class)
    );
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public void registerProvider(@NonNls @NotNull String[] names,
                             @NotNull ElementPattern filter,
                             boolean caseSensitive,
                             @NotNull PsiReferenceProvider provider,
                             final double priority) {
  final Map<String, List<ProviderInfo<ElementPattern>>> map = caseSensitive ? myNamesToProvidersMap : myNamesToProvidersMapInsensitive;

  for (final String attributeName : names) {
    String key = caseSensitive ? attributeName : attributeName.toLowerCase();
    List<ProviderInfo<ElementPattern>> psiReferenceProviders = map.get(key);

    if (psiReferenceProviders == null) {
      map.put(key, psiReferenceProviders = new SmartList<ProviderInfo<ElementPattern>>());
    }

    psiReferenceProviders.add(new ProviderInfo<ElementPattern>(provider, filter, priority));
  }
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public static String findIdentifierPrefix(PsiElement insertedElement, int offset, ElementPattern<Character> idPart,
                                           ElementPattern<Character> idStart) {
  if(insertedElement == null) return "";
  final String text = insertedElement.getText();

  final int offsetInElement = offset - insertedElement.getTextRange().getStartOffset();
  int start = offsetInElement - 1;
  while (start >=0 ) {
    if (!idPart.accepts(text.charAt(start))) break;
    --start;
  }
  while (start + 1 < offsetInElement && !idStart.accepts(text.charAt(start + 1))) {
    start++;
  }

  return text.substring(start + 1, offsetInElement).trim();
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public static String findPrefixStatic(final PsiElement insertedElement, final int offsetInFile, ElementPattern<Character> prefixStartTrim) {
  if(insertedElement == null) return "";

  final Document document = insertedElement.getContainingFile().getViewProvider().getDocument();
  assert document != null;
  LOG.assertTrue(!PsiDocumentManager.getInstance(insertedElement.getProject()).isUncommited(document), "Uncommitted");

  final String prefix = getReferencePrefix(insertedElement, offsetInFile);
  if (prefix != null) return prefix;

  if (insertedElement instanceof PsiPlainText || insertedElement instanceof PsiComment) {
    return CompletionUtil.findJavaIdentifierPrefix(insertedElement, offsetInFile);
  }

  return findPrefixDefault(insertedElement, offsetInFile, prefixStartTrim);
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public void prefixUpdated() {
  final int caretOffset = myEditor.getCaretModel().getOffset();
  if (caretOffset < myStartCaret) {
    scheduleRestart();
    myRestartingPrefixConditions.clear();
    return;
  }

  final CharSequence text = myEditor.getDocument().getCharsSequence();
  for (Pair<Integer, ElementPattern<String>> pair : myRestartingPrefixConditions) {
    int start = pair.first;
    if (caretOffset >= start && start >= 0) {
      final String newPrefix = text.subSequence(start, caretOffset).toString();
      if (pair.second.accepts(newPrefix)) {
        scheduleRestart();
        myRestartingPrefixConditions.clear();
        return;
      }
    }
  }

  hideAutopopupIfMeaningless();
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public boolean accepts(PrattBuilder builder) {
  ListIterator<IElementType> iterator = null;
  for (final ElementPattern pattern : myPath) {
    if (builder == null) return false;

    if (iterator == null) {
      iterator = builder.getBackResultIterator();
    }

    if (pattern == null) {
      if (iterator.hasPrevious()) return false;
      builder = builder.getParent();
      iterator = null;
    } else {
      if (!iterator.hasPrevious()) return false;
      if (!pattern.accepts(iterator.previous())) return false;
    }
  }

  return true;
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
private MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>> collectProducers() {
  final MultiMap<SemKey, NullableFunction<PsiElement, ? extends SemElement>> map = MultiMap.createSmart();

  final SemRegistrar registrar = new SemRegistrar() {
    @Override
    public <T extends SemElement, V extends PsiElement> void registerSemElementProvider(SemKey<T> key,
                                                                                        final ElementPattern<? extends V> place,
                                                                                        final NullableFunction<V, T> provider) {
      map.putValue(key, new NullableFunction<PsiElement, SemElement>() {
        @Override
        public SemElement fun(PsiElement element) {
          if (place.accepts(element)) {
            return provider.fun((V)element);
          }
          return null;
        }
      });
    }
  };

  for (SemContributorEP contributor : myProject.getExtensions(SemContributor.EP_NAME)) {
    contributor.registerSemProviders(myProject.getPicoContainer(), registrar);
  }

  return map;
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
@Override
public boolean isInContext(@NotNull PsiFile file, int offset) {
  if (!super.isInContext(file, offset)) {
    return false;
  }
  final ElementPattern<PsiElement> illegalPattern = or(psiElement().inside(JsonStringLiteral.class),
                                                       psiElement().inside(psiElement(JsonValue.class)
                                                                             .with(new PatternCondition<PsiElement>("insidePropertyKey") {
                                                                               @Override
                                                                               public boolean accepts(@NotNull PsiElement element,
                                                                                                      ProcessingContext context) {
                                                                                 return JsonPsiUtil.isPropertyKey(element);
                                                                               }
                                                                             })));
  return !illegalPattern.accepts(file.findElementAt(offset));
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
private Trinity<Long, Pattern, Collection<String>> getXmlAnnotatedElementsValue() {
  Trinity<Long, Pattern, Collection<String>> index = myXmlIndex;
  if (index == null || myConfiguration.getModificationCount() != index.first.longValue()) {
    final Map<ElementPattern<?>, BaseInjection> map = new THashMap<ElementPattern<?>, BaseInjection>();
    for (BaseInjection injection : myConfiguration.getInjections(XmlLanguageInjectionSupport.XML_SUPPORT_ID)) {
      for (InjectionPlace place : injection.getInjectionPlaces()) {
        if (!place.isEnabled() || place.getElementPattern() == null) continue;
        map.put(place.getElementPattern(), injection);
      }
    }
    final Collection<String> stringSet = PatternValuesIndex.buildStringIndex(map.keySet());
    index = Trinity.create(myConfiguration.getModificationCount(), buildPattern(stringSet), stringSet);
    myXmlIndex = index;
  }
  return index;
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
private static void registerKeyProviders(PsiReferenceRegistrar registrar) {
  ElementPattern pattern = createPattern(EXTENSION_TAG_NAMES, "key", "groupKey");
  registrar.registerReferenceProvider(pattern,
                                      new PropertyKeyReferenceProvider(false, "groupKey", "groupBundle"),
                                      PsiReferenceRegistrar.DEFAULT_PRIORITY);

  ElementPattern typeNameKeyPattern = createPattern(TYPE_NAME_TAG, "resourceKey");
  registrar.registerReferenceProvider(typeNameKeyPattern,
                                      new PropertyKeyReferenceProvider(false, "resourceKey", "resourceBundle"),
                                      PsiReferenceRegistrar.DEFAULT_PRIORITY);

  final XmlTagPattern.Capture intentionActionKeyTagPattern =
    XmlPatterns.xmlTag().withName("categoryKey").
      withParent(XmlPatterns.xmlTag().withName(INTENTION_ACTION_TAG).
        withSuperParent(2, XmlPatterns.xmlTag().withName("idea-plugin")));
  registrar.registerReferenceProvider(intentionActionKeyTagPattern,
                                      new PropertyKeyReferenceProvider(true, null, INTENTION_ACTION_BUNDLE_TAG));
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public GroovyMethodCallPattern withArguments(final ElementPattern<? extends GrExpression>... arguments) {
  return with(new PatternCondition<GrCallExpression>("withArguments") {
    @Override
    public boolean accepts(@NotNull GrCallExpression callExpression, ProcessingContext context) {
      final GrArgumentList argumentList = callExpression.getArgumentList();
      if (argumentList == null) return false;
      final GrExpression[] actualArguments = argumentList.getExpressionArguments();
      if (arguments.length != actualArguments.length) {
        return false;
      }
      for (int i = 0; i < actualArguments.length; i++) {
        if (!arguments[i].accepts(actualArguments[i], context)) {
          return false;
        }
      }
      return true;
    }
  });
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public static ElementPattern<PsiElement> getUriDefinition() {

        return PlatformPatterns.or(
                PlatformPatterns
                        .psiElement()
                        .withText(
                                StandardPatterns.string().startsWith("app://")
                        )
                        .withLanguage(PhpLanguage.INSTANCE)
                ,
                PlatformPatterns
                        .psiElement()
                        .withText(
                                StandardPatterns.string().startsWith("page://")
                        )
                        .withLanguage(PhpLanguage.INSTANCE)
        );
    }
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
/**
 * Check for {{ include('|')  }}
 *
 * @param functionName twig function name
 */
public static ElementPattern<PsiElement> getPrintBlockFunctionPattern(String... functionName) {
    //noinspection unchecked
    return PlatformPatterns
        .psiElement(TwigTokenTypes.STRING_TEXT)
        .withParent(PlatformPatterns.or(
            PlatformPatterns.psiElement(TwigElementTypes.PRINT_BLOCK),
            PlatformPatterns.psiElement(TwigElementTypes.SET_TAG),
            PlatformPatterns.psiElement(TwigElementTypes.IF_TAG)
        ))
        .afterLeafSkipping(
            PlatformPatterns.or(
                PlatformPatterns.psiElement(TwigTokenTypes.LBRACE),
                PlatformPatterns.psiElement(PsiWhiteSpace.class),
                PlatformPatterns.psiElement(TwigTokenTypes.WHITE_SPACE),
                PlatformPatterns.psiElement(TwigTokenTypes.SINGLE_QUOTE),
                PlatformPatterns.psiElement(TwigTokenTypes.DOUBLE_QUOTE)
            ),
            PlatformPatterns.psiElement(TwigTokenTypes.IDENTIFIER).withText(PlatformPatterns.string().oneOf(functionName))
        )
        .withLanguage(TwigLanguage.INSTANCE);
}
 

import com.intellij.patterns.ElementPattern; //导入依赖的package包/类
public void assertNavigationMatch(LanguageFileType languageFileType, String configureByText, ElementPattern<?> pattern) {

        myFixture.configureByText(languageFileType, configureByText);
        PsiElement psiElement = myFixture.getFile().findElementAt(myFixture.getCaretOffset());

        Set<String> targetStrings = new HashSet<>();

        for (GotoDeclarationHandler gotoDeclarationHandler : Extensions.getExtensions(GotoDeclarationHandler.EP_NAME)) {

            PsiElement[] gotoDeclarationTargets = gotoDeclarationHandler.getGotoDeclarationTargets(psiElement, 0, myFixture.getEditor());
            if(gotoDeclarationTargets == null || gotoDeclarationTargets.length == 0) {
                continue;
            }

            for (PsiElement gotoDeclarationTarget : gotoDeclarationTargets) {
                targetStrings.add(gotoDeclarationTarget.toString());
                if(pattern.accepts(gotoDeclarationTarget)) {
                    return;
                }
            }
        }

        fail(String.format("failed that PsiElement (%s) navigate matches one of %s", psiElement.toString(), targetStrings.toString()));
    }