下面列出了怎么用com.intellij.psi.tree.IElementType的API类实例代码及写法,或者点击链接到github查看源代码。
protected static void reportErrorUntil(CSharpBuilderWrapper builder, String error, TokenSet originalSet, TokenSet softSet)
{
while(!builder.eof())
{
if(originalSet.contains(builder.getTokenType()))
{
break;
}
if(builder.getTokenType() == CSharpTokens.IDENTIFIER)
{
builder.enableSoftKeywords(softSet);
IElementType tokenType = builder.getTokenType();
builder.disableSoftKeywords(softSet);
if(softSet.contains(tokenType))
{
// remap
builder.remapBackIfSoft();
break;
}
}
PsiBuilder.Marker mark = builder.mark();
builder.advanceLexer();
mark.error(error);
}
}
@Override
public void annotate(GLSLRedefinedToken identifier, AnnotationHolder holder) {
String definition;
final IElementType identifierType = identifier.getNode().getElementType();
if(identifierType instanceof GLSLElementTypes.RedefinedTokenElementType){
definition = ((GLSLElementTypes.RedefinedTokenElementType) identifierType).text;
}else{
GLSLMacroReference reference = identifier.getReference();
GLSLDefineDirective referent = (reference != null) ? reference.resolve() : null;
definition = (referent != null) ? referent.getBoundText() : null;
}
Annotation annotation = holder.createInfoAnnotation(identifier, definition);
annotation.setTextAttributes(GLSLHighlighter.GLSL_REDEFINED_TOKEN[0]);
}
@Nullable
private PsiElement getLastElement(@Nonnull final PsiElement element) {
final IElementType elementType = element.getNode().getElementType();
PsiElement nextSibling = element.getNextSibling();
PsiElement result = element;
while (nextSibling != null && (nextSibling.getNode().getElementType().equals(elementType) ||
(atWhitespaceToken(nextSibling) &&
StringUtil.countChars(nextSibling.getText(), '\n') <= 1))) {
String text = nextSibling.getText();
final String prefix = getPrefix(element);
final String postfix = getPostfix(element);
text = StringUtil.trimStart(text.trim(), prefix.trim());
text = StringUtil.trimEnd(text, postfix);
if (nextSibling.getNode().getElementType().equals(elementType) &&
StringUtil.isEmptyOrSpaces(text)) {
break;
}
if (nextSibling.getNode().getElementType().equals(elementType))
result = nextSibling;
nextSibling = nextSibling.getNextSibling();
}
return result;
}
private static PsiBuilder.Marker parseExpressionWithTypeInLParRPar(CSharpBuilderWrapper builder, int flags, PsiBuilder.Marker mark, IElementType to)
{
PsiBuilder.Marker newMarker = mark == null ? builder.mark() : mark.precede();
builder.advanceLexer();
if(expect(builder, LPAR, "'(' expected"))
{
if(parseType(builder, flags, TokenSet.EMPTY) == null)
{
builder.error("Type expected");
}
expect(builder, RPAR, "')' expected");
}
newMarker.done(to);
return newMarker;
}
@Override
public MergeFunction getMergeFunction() {
return ((final IElementType type, final Lexer originalLexer) -> {
if (type == SoyTypes.OTHER || type == TokenType.WHITE_SPACE) {
IElementType returnType = type;
while (originalLexer.getTokenType() == SoyTypes.OTHER
|| originalLexer.getTokenType() == TokenType.WHITE_SPACE) {
if (originalLexer.getTokenType() == SoyTypes.OTHER) {
returnType = SoyTypes.OTHER;
}
originalLexer.advance();
}
return returnType;
}
return type;
});
}
@Test
public void allParserRulesAreRegistered() throws Exception {
Map<IElementType, BlockFactory.Factory> registry = BlockFactory.REGISTRY;
Set<String> allRules = ImmutableSet.copyOf(ProtoParser.ruleNames);
Set<String> registeredRules = new HashSet<>();
for (IElementType type : registry.keySet()) {
registeredRules.add(type.toString());
}
Sets.SetView<String> diff = Sets.difference(allRules, registeredRules);
if (!diff.isEmpty()) {
Assert.fail("Following rules are not registered: " + diff);
}
}
@Override
protected ParseTree parse(Parser parser, IElementType root) {
int startRule;
if (root instanceof IFileElementType) {
startRule = ANTLRv4Parser.RULE_grammarSpec;
}
else if (root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.TOKEN_REF)
|| root == ANTLRv4TokenTypes.TOKEN_ELEMENT_TYPES.get(ANTLRv4Lexer.RULE_REF)) {
startRule = ANTLRv4Parser.RULE_atom;
}
else {
startRule = Token.INVALID_TYPE;
}
switch (startRule) {
case ANTLRv4Parser.RULE_grammarSpec:
return ((ANTLRv4Parser) parser).grammarSpec();
case ANTLRv4Parser.RULE_atom:
return ((ANTLRv4Parser) parser).atom();
default:
String ruleName = ANTLRv4Parser.ruleNames[startRule];
throw new UnsupportedOperationException(String.format("cannot start parsing using root element %s", root));
}
}
/**
* parses an optional arithmetic expression with an expected end token
*
* @param builder The builder which provides the tokens.
* @param endToken The token which is at the end of the arithmetic expression.
* @return True if the parsing has been successfull.
*/
private boolean parseArithmeticExpression(BashPsiBuilder builder, IElementType endToken) {
if (builder.getTokenType() == endToken) {//the expression can be empty
builder.advanceLexer();
return true;
}
while ((builder.getTokenType() != endToken) && !builder.eof()) {
if (!ArithmeticFactory.entryPoint().parse(builder)) {
return false;
}
}
final IElementType foundEndToken = ParserUtil.getTokenAndAdvance(builder);
return (!builder.eof() && foundEndToken == endToken);
}
@Override
public String transform(String testName, String[] data) throws Exception {
final StringBuilder output = new StringBuilder();
Lexer lexer = getLexer();
final String text = data[0].replaceAll("$(\\n+)", "");
lexer.start(text);
while (lexer.getTokenType() != null) {
final int s = lexer.getTokenStart();
final int e = lexer.getTokenEnd();
final IElementType tokenType = lexer.getTokenType();
final String str = tokenType + ": [" + s + ", " + e + "], {" + text.substring(s, e) + "}\n";
output.append(str);
lexer.advance();
}
return output.toString();
}
@Override
@Nonnull
public SyntaxHighlighter getSyntaxHighlighter(final Project project, final VirtualFile virtualFile) {
return new SyntaxHighlighterBase() {
@Nonnull
@Override
public Lexer getHighlightingLexer() {
return createPlainTextLexer();
}
@Nonnull
@Override
public TextAttributesKey[] getTokenHighlights(IElementType tokenType) {
return EMPTY;
}
};
}
public static <T extends CypherNamedElement> List<T> findAllAndFilter(Project project, IElementType elementType, Filter filter) {
Collection<VirtualFile> virtualFiles = FileBasedIndex.getInstance()
.getContainingFiles(FileTypeIndex.NAME, CypherFileType.INSTANCE, GlobalSearchScope.allScope(project));
List<T> result = new ArrayList<>();
for (VirtualFile virtualFile : virtualFiles) {
CypherFile cypherFile = (CypherFile) PsiManager.getInstance(project).findFile(virtualFile);
if (cypherFile != null) {
List<T> found = findAllAndFilter(cypherFile, elementType, filter);
result.addAll(found);
}
}
return result;
}
/**
* Checks whether a node is contained in a parameter expansion.
*
* @param node
* @return True if the on of the nodes is embedded in a string
*/
private static boolean hasAncestorNodeType(@Nullable ASTNode node, int levelsUp, @NotNull IElementType parentNodeType) {
if (node == null) {
return false;
}
if (levelsUp <= 0) {
return node.getElementType() == parentNodeType;
}
return hasAncestorNodeType(node.getTreeParent(), levelsUp - 1, parentNodeType);
}
/**
* Test the specific type of the given identifier element.
* For it could be a BUCK_RULE_NAME or PROPERTY_LVALUE.
*/
public static boolean testIdentifierType(PsiElement element, IElementType type) {
if (element.getNode().getElementType() != BuckTypes.IDENTIFIER) {
return false;
}
return element.getParent() != null && element.getParent().getNode().getElementType() == type;
}
@Nullable
public IElementType getRemappingTokenType() {
try {
parsingStateData.enterSimpleCommand();
return getTokenType();
} finally {
parsingStateData.leaveSimpleCommand();
}
}
public RTJSParser(PsiBuilder builder) {
super(JavaScriptSupportLoader.JAVASCRIPT_1_5, builder);
myExpressionParser = new RTExpressionParser();
myStatementParser = new StatementParser<RTJSParser>(this) {
@Override
protected void doParseStatement(boolean canHaveClasses) {
final IElementType firstToken = builder.getTokenType();
if (firstToken == JSTokenTypes.LBRACE) {
parseExpressionStatement();
checkForSemicolon();
return;
}
if (isIdentifierToken(firstToken)) {
final IElementType nextToken = builder.lookAhead(1);
if (nextToken == JSTokenTypes.IN_KEYWORD) {
parseInStatement();
return;
}
}
if (builder.getTokenType() == JSTokenTypes.LPAR) {
if (parseInStatement()) {
return;
}
}
super.doParseStatement(canHaveClasses);
}
private boolean parseInStatement() {
PsiBuilder.Marker statement = builder.mark();
if (!getExpressionParser().parseInExpression()) {
statement.drop();
return false;
}
statement.done(JSElementTypes.EXPRESSION_STATEMENT);
return true;
}
};
}
@Nonnull
public static LeafElement createSingleLeafElement(@Nonnull IElementType type, CharSequence buffer, int startOffset, int endOffset, CharTable table, PsiManager manager, PsiFile originalFile) {
DummyHolder dummyHolder = DummyHolderFactory.createHolder(manager, table, type.getLanguage());
dummyHolder.setOriginalFile(originalFile);
FileElement holderElement = dummyHolder.getTreeElement();
LeafElement newElement = ASTFactory.leaf(type, holderElement.getCharTable().intern(
buffer, startOffset, endOffset));
holderElement.rawAddChildren(newElement);
CodeEditUtil.setNodeGenerated(newElement, true);
return newElement;
}
@Nullable
public BracePair findPair(boolean left, HighlighterIterator iterator, CharSequence fileText, FileType fileType) {
final IElementType tokenType = iterator.getTokenType();
final BracePair[] pairs = myMatcher.getPairs();
for (BracePair pair : pairs) {
if (tokenType == (left ? pair.getLeftBraceType() : pair.getRightBraceType())) return pair;
}
return null;
}
public static boolean isPairedBracesAllowedBeforeTypeInFileType(@Nonnull IElementType lbraceType,
final IElementType tokenType,
@Nonnull FileType fileType) {
try {
return getBraceMatcher(fileType, lbraceType).isPairedBracesAllowedBeforeType(lbraceType, tokenType);
}
catch (AbstractMethodError incompatiblePluginThatWeDoNotCare) {
// Do nothing
}
return true;
}
protected void doLexerHighlightingTest(String fileContent, IElementType targetElementType) {
BashSyntaxHighlighter syntaxHighlighter = new BashSyntaxHighlighter();
TextAttributesKey[] keys = syntaxHighlighter.getTokenHighlights(targetElementType);
Assert.assertEquals("Expected one key", 1, keys.length);
TextAttributesKey attributesKey = keys[0];
Assert.assertNotNull(attributesKey);
EditorColorsManager manager = EditorColorsManager.getInstance();
EditorColorsScheme scheme = (EditorColorsScheme) manager.getGlobalScheme().clone();
manager.addColorsScheme(scheme);
EditorColorsManager.getInstance().setGlobalScheme(scheme);
TextAttributes targetAttributes = new TextAttributes(JBColor.RED, JBColor.BLUE, JBColor.GRAY, EffectType.BOXED, Font.BOLD);
scheme.setAttributes(attributesKey, targetAttributes);
myFixture.configureByText(BashFileType.BASH_FILE_TYPE, fileContent);
TextAttributes actualAttributes = null;
HighlighterIterator iterator = ((EditorImpl) myFixture.getEditor()).getHighlighter().createIterator(0);
while (!iterator.atEnd()) {
if (iterator.getTokenType() == targetElementType) {
actualAttributes = iterator.getTextAttributes();
break;
}
iterator.advance();
}
Assert.assertEquals("Expected text attributes for " + attributesKey, targetAttributes, actualAttributes);
}
@Override
@Nonnull
public TextAttributesKey[] getTokenHighlights(final IElementType tokenType) {
if (tokenType == BAD_CHARACTER) {
return new TextAttributesKey[0];
}
return myHighlighter.getTokenHighlights(tokenType);
}
public void parseLight(IElementType t, PsiBuilder b) {
boolean r;
b = adapt_builder_(t, b, this, null);
Marker m = enter_section_(b, 0, _COLLAPSE_, null);
r = parse_root_(t, b);
exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
}
@NotNull
public String getType(@NotNull PsiElement psiElement) {
IElementType iElementType = MakefileIdentifierReference.type(psiElement);
if(iElementType == MakefileTokenTypes.VAR_DEFINITION) return "definition";
if(iElementType == MakefileTokenTypes.TARGET_IDENTIFIER) return "target";
return "should not happen type";
}
public static boolean isAppropriateElementTypeForLiteralStatic(final IElementType tokenType)
{
return CSharpTokenSets.COMMENTS.contains(tokenType) ||
tokenType == CSharpTokens.WHITE_SPACE ||
tokenType == CSharpTokens.SEMICOLON ||
tokenType == CSharpTokens.COMMA ||
tokenType == CSharpTokens.RPAR ||
tokenType == CSharpTokens.RBRACKET ||
tokenType == CSharpTokens.RBRACE ||
tokenType == CSharpTokens.STRING_LITERAL ||
tokenType == CSharpTokens.CHARACTER_LITERAL;
}
private static boolean isFoldable(ASTNode node) {
IElementType type = node.getElementType();
if (type == HEREDOC_CONTENT_ELEMENT) {
// only the first heredoc element of a single heredoc is foldable,
// the range expansion expands it until the last content element
ASTNode prev = node.getTreePrev();
if (prev != null && prev.getElementType() == BashTokenTypes.LINE_FEED) {
//first heredoc content element, better PSI would be an improvement here
return true;
}
}
return foldableTokens.contains(type);
}
public boolean isWhiteSpace(PsiElement element) {
IElementType type = element.getNode().getElementType();
if (type == TokenType.WHITE_SPACE) {
return true;
}
return false;
}
/**
* From http://www.gnu.org/software/bash/manual/bashref.html#Conditional-Constructs :
* <br>
* <br>
* <code>( expression )</code>
* Returns the value of expression. This may be used to override the normal precedence of operators.
* <br>
* <code>! expression</code>
* True if expression is false.
* <br>
* <code>expression1 && expression2</code>
* True if both expression1 and expression2 are true.
* <br>
* <code>expression1 || expression2</code>
* True if either expression1 or expression2 is true.
* <br>
* The && and || operators do not evaluate expression2 if the value of expression1 is sufficient to determine the return value of the entire conditional expression.
* <br>
* An expression is a normal test expression as used in the conditional expression parsing function.
*
* @param builder The provider of the tokens.
* @return True if the parsing was successful
*/
@Override
public boolean parse(BashPsiBuilder builder) {
IElementType token = builder.getTokenType();
log.assertTrue(token == BRACKET_KEYWORD);
PsiBuilder.Marker startMarker = builder.mark();
builder.advanceLexer();
boolean ok;
if (builder.getTokenType() == _BRACKET_KEYWORD) {
builder.error("Empty expression is not allowed");
ok = false;
} else {
ok = parseExpression(builder);
}
ok &= (builder.getTokenType() == _BRACKET_KEYWORD);
if (ok) {
builder.advanceLexer();
startMarker.done(BashElementTypes.EXTENDED_CONDITIONAL_COMMAND);
return true;
}
startMarker.drop();
return false;
}
/**
* @param node Block node
* @return The placeholder text for the given node, if it is foldable.
*/
public String getPlaceholderText(@NotNull ASTNode node) {
IElementType elementType = node.getElementType();
if (!isFoldable(elementType)) {
return null;
}
String placeholderText = "";
if (elementType == FusionTypes.BLOCK) {
placeholderText = "{...}";
} else if (elementType == FusionTypes.DOC_COMMENT) {
placeholderText = "/*...*/";
}
return placeholderText;
}
public void doneBefore(@NotNull IElementType elementType, @NotNull Marker marker, String message) {
if (closed) {
throw new IllegalStateException("This marker is already closed (either dropped or done)");
}
if (!(marker instanceof MockMarker)) {
throw new IllegalStateException("The stopMarker must be a MockMarker");
}
closed = true;
int index = MockPsiBuilder.this.markers.indexOf(this);
int indexStopMarker = MockPsiBuilder.this.markers.indexOf(marker);
if (indexStopMarker == -1) {
throw new IllegalStateException("stopMarker wasn't found");
}
if (index == -1) {
throw new IllegalStateException("marker wasn't found");
}
if (index > indexStopMarker) {
throw new IllegalStateException(String.format("The stopMarker must have been created after the current marker: index %d, stop marker index %s", index, indexStopMarker));
}
MockPsiBuilder.this.markers.remove(index);
doneMarkers.add(Pair.create(this, elementType));
}
private void transitionToLetNamed(@NotNull PsiBuilder builder, @NotNull ParserState state) {
state.updateCurrentResolution(letNamed).complete().
wrapWith(m_types.C_LOWER_SYMBOL);
IElementType tokenType = builder.getTokenType();
if (tokenType != m_types.EQ && tokenType != m_types.COLON) {
state.add(mark(builder, letBinding, letNamedBinding, m_types.C_LET_BINDING).complete()).add(mark(builder, function, m_types.C_FUN_EXPR).complete())
.add(mark(builder, function, functionParameters, m_types.C_FUN_PARAMS).complete());
}
}
@NotNull
@Override
public PsiElement createElement(ASTNode node) {
final IElementType type = node.getElementType();
if (type.equals(RTElementTypes.REPEAT_EXPRESSION)) {
return new RTRepeatExpression(node);
}
if (type.equals(RTElementTypes.FILTER_EXPRESSION)) {
return new RTFilterExpression(node);
}
if (type.equals(RTElementTypes.AS_EXPRESSION)) {
return new RTAsExpression(node);
}
return super.createElement(node);
}