Java PsiElementPattern.Capture方法代码示例

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
public static PsiElementPattern.Capture<PsiElement> tagAttributePattern(
    String tag,
    String attributeName,
    String fileName
) {
    return XmlPatterns
        .psiElement()
        .inside(XmlPatterns
                    .xmlAttributeValue()
                    .inside(XmlPatterns
                                .xmlAttribute()
                                .withName(attributeName)
                                .withParent(XmlPatterns
                                                .xmlTag()
                                                .withName(tag)
                                )
                    )
        ).inFile(getXmlFilePattern(fileName));
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
private static PsiElementPattern.Capture<PsiElement> topLevel() {
    return psiElement()
        .withLanguage(ImpexLanguage.getInstance())
        .andNot(psiElement()
                    // FIXME bad code, but working
                    .andOr(
                        psiElement(ImpexTypes.HEADER_TYPE),
                        psiElement(ImpexTypes.MACRO_NAME_DECLARATION),
                        psiElement(ImpexTypes.ROOT_MACRO_USAGE),
                        psiElement(ImpexTypes.MACRO_DECLARATION),
                        psiElement(ImpexTypes.ASSIGN_VALUE),
                        psiElement(ImpexTypes.MACRO_VALUE),
                        psiElement(ImpexTypes.ATTRIBUTE),
                        psiElement(ImpexTypes.HEADER_TYPE_NAME),
                        psiElement(ImpexTypes.HEADER_PARAMETER_NAME),
                        psiElement(ImpexTypes.ATTRIBUTE_NAME),
                        psiElement(ImpexTypes.FIELD_VALUE),
                        psiElement(ImpexTypes.ATTRIBUTE_VALUE)
                    )
        );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
private void addStatements() {
  PsiElementPattern.Capture<PsiElement> inStatement = psiElement()
    .withLanguage(PythonLanguage.getInstance())
    .and(IN_BEGIN_STMT)
    .andNot(IN_IMPORT_STMT)
    .andNot(IN_PARAM_LIST)
    .andNot(IN_ARG_LIST)
    .andNot(BEFORE_COND)
    .andNot(AFTER_QUALIFIER);

  extend(
    CompletionType.BASIC,
    inStatement,
    new CompletionProvider<CompletionParameters>() {
      protected void addCompletions(
        @NotNull final CompletionParameters parameters, final ProcessingContext context, @NotNull final CompletionResultSet result
      ) {
        putKeywords(result, TailType.SPACE, PyNames.ASSERT, PyNames.DEL, PyNames.EXEC, PyNames.FROM, PyNames.IMPORT, PyNames.RAISE);
        putKeywords(result, TailType.NONE, PyNames.PASS);
      }
    }
  );

  extend(CompletionType.BASIC, inStatement.andNot(PY3K), new PyKeywordCompletionProvider(TailType.SPACE, PyNames.PRINT));
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * Not all tags are known, we need some custom syntax check
 *
 * {oxmultilang ident="FOO"}
 * { oxmultilang ident="FOO"}
 */
public static PsiElementPattern.Capture<PsiElement> getAttributeInsideTagPattern(@NotNull String attribute, @NotNull String tag) {
    return PlatformPatterns.psiElement(SmartyTokenTypes.STRING_LITERAL).afterLeafSkipping(
            PlatformPatterns.or(
                    PlatformPatterns.psiElement(SmartyTokenTypes.DOUBLE_QUOTE),
                    PlatformPatterns.psiElement(SmartyTokenTypes.SINGLE_QUOTE),
                    PlatformPatterns.psiElement(SmartyTokenTypes.EQ),
                    PlatformPatterns.psiElement(SmartyTokenTypes.WHITE_SPACE),
                    PlatformPatterns.psiElement(PsiWhiteSpace.class)
            ),
            PlatformPatterns.psiElement(SmartyTokenTypes.IDENTIFIER).withText(attribute)
    ).withParent(
            PlatformPatterns.psiElement(SmartyTag.class).withText(
                    PlatformPatterns.string().matches("\\{\\s*" + tag + ".*")
            )
    );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * foo:[{"key": "<caret>"}]
 */
public PsiElementPattern.Capture<PsiElement> getAfterPropertyAndInsideArrayObjectPattern(@NotNull String key) {
    return PlatformPatterns.psiElement().inFile(getMetadataFilePattern()).withParent(
        PlatformPatterns.psiElement(JsonStringLiteral.class).with(FirstItemInTreePatternCondition.getInstance()).withParent(
            PlatformPatterns.psiElement(JsonProperty.class).withParent(
                PlatformPatterns.psiElement(JsonObject.class).withParent(
                    PlatformPatterns.psiElement(JsonArray.class).withParent(
                        PlatformPatterns.psiElement(JsonProperty.class).withFirstChild(
                            PlatformPatterns.psiElement(JsonStringLiteral.class).withText("\"" + key + "\"")
                        )
                    )
                )
            )
        )
    );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * foo:{"key": "<caret>"}
 */
public PsiElementPattern.Capture<PsiElement> getAfterPropertyAndInsideObjectPattern(@NotNull String key) {
    return PlatformPatterns.psiElement().inFile(getMetadataFilePattern()).withParent(
        PlatformPatterns.psiElement(JsonStringLiteral.class).with(FirstItemInTreePatternCondition.getInstance()).withParent(
            PlatformPatterns.psiElement(JsonProperty.class).withParent(
                PlatformPatterns.psiElement(JsonObject.class).withParent(

                        PlatformPatterns.psiElement(JsonProperty.class).withFirstChild(
                            PlatformPatterns.psiElement(JsonStringLiteral.class).withText("\"" + key + "\"")
                        )

                )
            )
        )
    );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * [$this, '']
 * array($this, '')
 */
@NotNull
@Override
public PsiElementPattern.Capture<PsiElement> getPattern() {
    return PlatformPatterns.psiElement().withParent(
        PlatformPatterns.psiElement(StringLiteralExpression.class).withParent(
            PlatformPatterns.psiElement().withElementType(PhpElementTypes.ARRAY_VALUE).afterLeafSkipping(
                PlatformPatterns.psiElement(PsiWhiteSpace.class),
                PlatformPatterns.psiElement().withText(",")
            ).afterSiblingSkipping(
                PlatformPatterns.psiElement(PsiWhiteSpace.class),
                PlatformPatterns.psiElement().withElementType(PhpElementTypes.ARRAY_VALUE).withFirstNonWhitespaceChild(
                    PlatformPatterns.psiElement(Variable.class)
                ).afterLeafSkipping(
                    PlatformPatterns.psiElement(PsiWhiteSpace.class),
                    PlatformPatterns.psiElement().withText(PlatformPatterns.string().oneOf("[", "("))
                )
            )
        )
    );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
private static PsiElementPattern.Capture<JSLiteralExpression> literalInProperty(final String propertyName) {
    return PlatformPatterns.psiElement(JSLiteralExpression.class).and(new FilterPattern(new ElementFilter() {
        @Override
        public boolean isAcceptable(Object element, @Nullable PsiElement context) {
            if (element instanceof JSLiteralExpression) {
                final JSLiteralExpression literal = (JSLiteralExpression)element;
                if (literal.isQuotedLiteral()) {
                    final PsiElement parent = literal.getParent();
                    if (parent instanceof JSProperty && propertyName.equals(((JSProperty)parent).getName())) {
                        return EmberIndexUtil.hasEmberJS(literal.getProject());
                    }
                }
            }
            return false;
        }

        @Override
        public boolean isClassAcceptable(Class hintClass) {
            return true;
        }
    }));
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * "@foobar(['<caret>'])"
 *
 * whereas "foobar" is registered a directive
 */
public static PsiElementPattern.Capture<PsiElement> getArrayParameterDirectiveForElementType(@NotNull IElementType... elementType) {
    return PlatformPatterns.psiElement()
        .withParent(
            PlatformPatterns.psiElement(StringLiteralExpression.class)
                .withParent(
                    PlatformPatterns.psiElement(PhpElementTypes.ARRAY_VALUE).withParent(
                        PlatformPatterns.psiElement(ArrayCreationExpression.class)
                            .withParent(ParameterList.class)
                    )
                )
                .with(
                    new MyDirectiveInjectionElementPatternCondition(elementType)
                )
        )
        .withLanguage(PhpLanguage.INSTANCE);
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
/**
 * Provide array key pattern. we need incomplete array key support, too.
 *
 * foo(['<caret>'])
 * foo(['<caret>' => 'foobar'])
 */
@NotNull
public static PsiElementPattern.Capture<PsiElement> getParameterListArrayValuePattern() {
    return PlatformPatterns.psiElement()
        .withParent(PlatformPatterns.psiElement(StringLiteralExpression.class).withParent(
            PlatformPatterns.or(
                PlatformPatterns.psiElement().withElementType(PhpElementTypes.ARRAY_VALUE)
                    .withParent(PlatformPatterns.psiElement(ArrayCreationExpression.class)
                        .withParent(ParameterList.class)
                    ),

                PlatformPatterns.psiElement().withElementType(PhpElementTypes.ARRAY_KEY)
                    .withParent(PlatformPatterns.psiElement(ArrayHashElement.class)
                        .withParent(PlatformPatterns.psiElement(ArrayCreationExpression.class)
                            .withParent(ParameterList.class)
                        )
                    )
            ))
        );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
public static PsiElementPattern.Capture appFieldPattern() {
    return PlatformPatterns.psiElement()
            .withParent(PlatformPatterns.psiElement().withElementType(PhpElementTypes.FIELD_REFERENCE)
                    .withChild(
                            PlatformPatterns.psiElement().withElementType(PhpElementTypes.METHOD_REFERENCE)
                                    .referencing(
                                            PhpPatterns.psiElement().withElementType(PhpElementTypes.CLASS_METHOD)
                                                    .withName("app").withParent(
                                                    PhpPatterns.psiElement()
                                                            .withElementType(PhpElementTypes.CLASS)
                                                            .withName(StandardPatterns.string().oneOf("Yii", "YiiBase"))
                                            )
                                    )
                    )
            ).withLanguage(PhpLanguage.INSTANCE);

}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
public ApplicationNameCompletionContributor() {
  final PsiElementPattern.Capture<PsiElement> inAppReferenceString = psiElement().withSuperParent(1, AppleScriptApplicationReference.class);

  extend(CompletionType.BASIC,
      inAppReferenceString,
      new CompletionProvider<CompletionParameters>() {
        @Override
        protected void addCompletions(@NotNull CompletionParameters parameters,
                                      ProcessingContext context,
                                      @NotNull CompletionResultSet result) {

          AppleScriptSystemDictionaryRegistryService systemDictionaryRegistry = ServiceManager.getService
              (AppleScriptSystemDictionaryRegistryService.class);
          if (systemDictionaryRegistry != null) {
            List<String> appNameList = new ArrayList<>();
            if (SystemInfo.isMac) {
              appNameList.addAll(systemDictionaryRegistry.getDiscoveredApplicationNames());
              appNameList.removeAll(systemDictionaryRegistry.getNotScriptableApplicationList());
              appNameList.removeAll(systemDictionaryRegistry.getScriptingAdditions());
              appNameList.remove(ApplicationDictionary.SCRIPTING_ADDITIONS_LIBRARY);
              appNameList.remove(ApplicationDictionary.COCOA_STANDARD_LIBRARY);
            } else {
              appNameList.addAll(systemDictionaryRegistry.getCachedApplicationNames());
            }
            for (String appName : appNameList) {
              result.addElement(LookupElementBuilder.create(appName));
            }
          }
        }
      });

}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
@NotNull
public static PsiElementPattern.Capture<PsiElement> isStringArrayValue() {

    return PhpPatterns.psiElement()
            .andOr(
                    PhpPatterns.psiElement().withParent(
                        PlatformPatterns.psiElement(StringLiteralExpression.class)
                            .withParent(PlatformPatterns.psiElement(PhpElementTypes.ARRAY_VALUE))
                    ),
                    PlatformPatterns.psiElement(StringLiteralExpression.class)
                                    .withParent(PlatformPatterns.psiElement(PhpElementTypes.ARRAY_VALUE))
            );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
static ElementPattern<PsiElement> arrowedReference() {
    final PsiElementPattern.Capture<PsiElement> arrowedCase = PlatformPatterns.psiElement(PhpTokenTypes.IDENTIFIER).afterLeaf("->");

    return StandardPatterns.or(
        arrowedCase.withParent(FieldReference.class),
        arrowedCase.withParent(MethodReference.class)
    );
}
 

import com.intellij.patterns.PsiElementPattern; //导入方法依赖的package包/类
protected PsiElementPattern.Capture<PsiElement> getNodeTypeElementMatcher(@NotNull String... keys) {
    return PlatformPatterns
            .psiElement()
            .with(new ParentKeysPatternCondition(keys))
            .with(new FilenamePrefixPatternCondition("NodeTypes."))
            .withLanguage(YAMLLanguage.INSTANCE);
}