MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-04-19 21:11:28 +07:00
Code Issues Packages Projects Releases Wiki Activity

[java-rd] IDEA-333104 fix cases when highlighting get null in parents

Browse Source 
- fix comments
- BasicJavaTokenSet is renamed to ParentAwareTokenSet and move to core
- method `toTokenSet` is deleted, because it was the reason a lot of mistakes

GitOrigin-RevId: b776be4f067d99e4a531d3622dfa9b9e8078c543
This commit is contained in:
Mikhail Pyltsin
2023-09-28 10:40:09 +02:00
committed by intellij-monorepo-bot
parent 7b31275d08
commit 4cf2e16167
27 changed files with 259 additions and 201 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
java/java-frontback-impl/src/com/intellij/BaseJavaJspElementType.java
View File

@@ -2,12 +2,12 @@
package com.intellij;
import com.intellij.lang.xml.XmlTokenElementMarkTypes;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.TokenSet;
public interface BaseJavaJspElementType {
BasicJavaTokenSet WHITE_SPACE_BIT_SET = BasicJavaTokenSet.orSet(
BasicJavaTokenSet.create(TokenSet.WHITE_SPACE),
BasicJavaTokenSet.create(XmlTokenElementMarkTypes.XML_WHITE_SPACE_MARK));
ParentAwareTokenSet WHITE_SPACE_BIT_SET = ParentAwareTokenSet.orSet(
ParentAwareTokenSet.create(TokenSet.WHITE_SPACE),
ParentAwareTokenSet.create(XmlTokenElementMarkTypes.XML_WHITE_SPACE_MARK));
}

6
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavaTypedHandler.java
View File

@@ -17,7 +17,7 @@ import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.text.CharArrayUtil;
import org.jetbrains.annotations.NotNull;
@@ -139,7 +139,7 @@ public abstract class AbstractBasicJavaTypedHandler extends TypedHandlerDelegate
PsiDocumentManager.getInstance(project).commitDocument(doc);
final PsiElement leaf = file.findElementAt(offset);
if (BasicJavaAstTreeUtil.getParentOfType(leaf, BASIC_ARRAY_INITIALIZER_EXPRESSION, false,
BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(BASIC_CODE_BLOCK), MEMBER_SET)) != null) {
ParentAwareTokenSet.orSet(ParentAwareTokenSet.create(BASIC_CODE_BLOCK), MEMBER_SET)) != null) {
return Result.CONTINUE;
}
PsiElement st = leaf != null ? leaf.getParent() : null;
@@ -168,7 +168,7 @@ public abstract class AbstractBasicJavaTypedHandler extends TypedHandlerDelegate
// lambda
if (prevLeaf != null && prevLeaf.getNode().getElementType() == JavaTokenType.ARROW) return true;
// anonymous class
BasicJavaTokenSet stopAt = BasicJavaTokenSet.orSet(MEMBER_SET, BasicJavaTokenSet.create(BASIC_CODE_BLOCK));
ParentAwareTokenSet stopAt = ParentAwareTokenSet.orSet(MEMBER_SET, ParentAwareTokenSet.create(BASIC_CODE_BLOCK));
if (BasicJavaAstTreeUtil.getParentOfType(prevLeaf, BASIC_NEW_EXPRESSION, true, stopAt) != null) return true;
// local class
if (prevLeaf != null && prevLeaf.getParent() != null && BasicJavaAstTreeUtil.is(prevLeaf.getNode(), JavaTokenType.IDENTIFIER) &&

4
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavadocTypedHandler.java
View File

@@ -9,7 +9,7 @@ import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -177,7 +177,7 @@ public abstract class AbstractBasicJavadocTypedHandler extends TypedHandlerDeleg
// The contents of inline tags is not HTML, so the paired tag completion isn't appropriate there.
if (BasicJavaAstTreeUtil.is(astNode, DOC_INLINE_TAG, DOC_SNIPPET_TAG) ||
BasicJavaAstTreeUtil.getParentOfType(astNode, BasicJavaTokenSet.create(DOC_INLINE_TAG, DOC_SNIPPET_TAG)) != null) {
BasicJavaAstTreeUtil.getParentOfType(astNode, ParentAwareTokenSet.create(DOC_INLINE_TAG, DOC_SNIPPET_TAG)) != null) {
return false;
}

18
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaQuoteHandler.java
View File

@@ -11,8 +11,8 @@ import com.intellij.pom.java.LanguageLevel;
import com.intellij.psi.*;
import com.intellij.psi.codeStyle.CodeStyleManager;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -23,15 +23,15 @@ import static com.intellij.psi.impl.source.BasicJavaElementType.BASIC_LITERAL_EX
import static com.intellij.psi.impl.source.BasicJavaElementType.REFERENCE_EXPRESSION_SET;
public class JavaQuoteHandler extends SimpleTokenSetQuoteHandler implements JavaLikeQuoteHandler, MultiCharQuoteHandler {
private final BasicJavaTokenSet myConcatenableStrings = BasicJavaTokenSet.create(JavaTokenType.STRING_LITERAL);
private final BasicJavaTokenSet myAppropriateElementTypeForLiteral = BasicJavaTokenSet.orSet(
BasicJavaTokenSet.create(JavaDocTokenType.ALL_JAVADOC_TOKENS),
BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET, BasicJavaTokenSet.create(BASIC_TEXT_LITERALS),
BasicJavaTokenSet.create(JavaTokenType.SEMICOLON, JavaTokenType.COMMA, JavaTokenType.RPARENTH, JavaTokenType.RBRACKET,
JavaTokenType.RBRACE));
private final TokenSet myConcatenableStrings = TokenSet.create(JavaTokenType.STRING_LITERAL);
private final ParentAwareTokenSet myAppropriateElementTypeForLiteral = ParentAwareTokenSet.orSet(
ParentAwareTokenSet.create(JavaDocTokenType.ALL_JAVADOC_TOKENS),
BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET, ParentAwareTokenSet.create(BASIC_TEXT_LITERALS),
ParentAwareTokenSet.create(JavaTokenType.SEMICOLON, JavaTokenType.COMMA, JavaTokenType.RPARENTH, JavaTokenType.RBRACKET,
JavaTokenType.RBRACE));
public JavaQuoteHandler() {
super(BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(BASIC_TEXT_LITERALS), BasicJavaTokenSet.create(JavaDocTokenType.DOC_TAG_VALUE_QUOTE)).toTokenSet());
super(TokenSet.orSet(BASIC_TEXT_LITERALS, TokenSet.create(JavaDocTokenType.DOC_TAG_VALUE_QUOTE)));
}
@Override
@@ -73,7 +73,7 @@ public class JavaQuoteHandler extends SimpleTokenSetQuoteHandler implements Java
@NotNull
@Override
public TokenSet getConcatenatableStringTokenTypes() {
return myConcatenableStrings.toTokenSet();
return myConcatenableStrings;
}
@Override

6
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/CommentBreakerEnterProcessor.java
View File

@@ -26,15 +26,15 @@ import com.intellij.psi.JavaTokenType;
import com.intellij.psi.PsiElement;
import com.intellij.psi.impl.source.BasicElementTypes;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import org.jetbrains.annotations.NotNull;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
public class CommentBreakerEnterProcessor implements ASTNodeEnterProcessor {
private final BasicJavaTokenSet myCommentTypes = BasicJavaTokenSet.orSet(
BasicJavaTokenSet.create(BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET), BasicJavaTokenSet.create(DOC_COMMENT)
private final ParentAwareTokenSet myCommentTypes = ParentAwareTokenSet.orSet(
ParentAwareTokenSet.create(BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET), ParentAwareTokenSet.create(DOC_COMMENT)
);
@Override

8
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/LeaveCodeBlockEnterProcessor.java
View File

@@ -9,7 +9,7 @@ import com.intellij.openapi.editor.Editor;
import com.intellij.openapi.editor.actionSystem.EditorActionHandler;
import com.intellij.openapi.editor.actionSystem.EditorActionManager;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.util.text.CharArrayUtil;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -17,9 +17,9 @@ import org.jetbrains.annotations.Nullable;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
public class LeaveCodeBlockEnterProcessor implements ASTNodeEnterProcessor {
private final BasicJavaTokenSet CONTROL_FLOW_ELEMENT_TYPES =
BasicJavaTokenSet.create(BASIC_IF_STATEMENT, BASIC_WHILE_STATEMENT, BASIC_DO_WHILE_STATEMENT, BASIC_FOR_STATEMENT,
BASIC_FOREACH_STATEMENT);
private final ParentAwareTokenSet CONTROL_FLOW_ELEMENT_TYPES =
ParentAwareTokenSet.create(BASIC_IF_STATEMENT, BASIC_WHILE_STATEMENT, BASIC_DO_WHILE_STATEMENT, BASIC_FOR_STATEMENT,
BASIC_FOREACH_STATEMENT);
@Override

8
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingLoopBodyFixer.java
View File

@@ -21,7 +21,7 @@ import com.intellij.openapi.editor.Editor;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiWhiteSpace;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.util.PsiTreeUtil;
import com.intellij.util.IncorrectOperationException;
import com.intellij.util.ObjectUtils;
@@ -58,9 +58,9 @@ public class MissingLoopBodyFixer implements Fixer {
}
private static ASTNode getLoopParent(@NotNull ASTNode element) {
ASTNode statement = BasicJavaAstTreeUtil.getParentOfType(element, BasicJavaTokenSet.create(BASIC_FOREACH_STATEMENT,
BASIC_FOR_STATEMENT,
BASIC_WHILE_STATEMENT));
ASTNode statement = BasicJavaAstTreeUtil.getParentOfType(element, ParentAwareTokenSet.create(BASIC_FOREACH_STATEMENT,
BASIC_FOR_STATEMENT,
BASIC_WHILE_STATEMENT));
if (statement == null) return null;
if (BasicJavaAstTreeUtil.is(statement, BASIC_FOREACH_STATEMENT)) {
return isForEachApplicable(statement, element) ? statement : null;

6
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingReturnExpressionFixer.java
View File

@@ -8,7 +8,7 @@ import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiJavaToken;
import com.intellij.psi.TokenType;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -35,7 +35,7 @@ public class MissingReturnExpressionFixer implements Fixer {
return;
}
ASTNode parent = BasicJavaAstTreeUtil.getParentOfType(astNode, BasicJavaTokenSet.create(BASIC_CLASS_INITIALIZER, BASIC_METHOD));
ASTNode parent = BasicJavaAstTreeUtil.getParentOfType(astNode, ParentAwareTokenSet.create(BASIC_CLASS_INITIALIZER, BASIC_METHOD));
if (BasicJavaAstTreeUtil.is(parent, BASIC_METHOD)) {
ASTNode type = BasicJavaAstTreeUtil.findChildByType(parent, BASIC_TYPE);
if (type != null && !type.getText().equals("void")) {
@@ -68,7 +68,7 @@ public class MissingReturnExpressionFixer implements Fixer {
int offset = returnStatement.getTextRange().getEndOffset();
final PsiElement psiMethod =
BasicJavaAstTreeUtil.getParentOfType(BasicJavaAstTreeUtil.toPsi(returnStatement), BASIC_METHOD, true,
BasicJavaTokenSet.create(BASIC_LAMBDA_EXPRESSION));
ParentAwareTokenSet.create(BASIC_LAMBDA_EXPRESSION));
ASTNode method = BasicJavaAstTreeUtil.toNode(psiMethod);
ASTNode type = BasicJavaAstTreeUtil.findChildByType(method, BASIC_TYPE);
if (method != null && type != null && type.getText().equals("void")) {

18
java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaPairedBraceMatcher.java
View File

@@ -5,24 +5,24 @@ import com.intellij.ide.highlighter.JavaFileType;
import com.intellij.lang.java.JavaLanguage;
import com.intellij.psi.JavaTokenType;
import com.intellij.psi.impl.source.BasicElementTypes;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import org.jetbrains.annotations.NotNull;
public class JavaPairedBraceMatcher extends PairedBraceAndAnglesMatcher {
private static class Holder {
private static final BasicJavaTokenSet TYPE_TOKENS =
BasicJavaTokenSet.orSet(BaseJavaJspElementType.WHITE_SPACE_BIT_SET,
BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET,
BasicJavaTokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.COMMA,
JavaTokenType.AT,//anno
JavaTokenType.RBRACKET, JavaTokenType.LBRACKET, //arrays
JavaTokenType.QUEST, JavaTokenType.EXTENDS_KEYWORD, JavaTokenType.SUPER_KEYWORD));//wildcards
private static final ParentAwareTokenSet TYPE_TOKENS =
ParentAwareTokenSet.orSet(BaseJavaJspElementType.WHITE_SPACE_BIT_SET,
BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET,
ParentAwareTokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.COMMA,
JavaTokenType.AT,//anno
JavaTokenType.RBRACKET, JavaTokenType.LBRACKET, //arrays
JavaTokenType.QUEST, JavaTokenType.EXTENDS_KEYWORD, JavaTokenType.SUPER_KEYWORD));//wildcards
}
public JavaPairedBraceMatcher() {
super(new JavaBraceMatcher(), JavaLanguage.INSTANCE, JavaFileType.INSTANCE, Holder.TYPE_TOKENS.toTokenSet());
super(new JavaBraceMatcher(), JavaLanguage.INSTANCE, JavaFileType.INSTANCE, Holder.TYPE_TOKENS);
}
@Override

17
java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/PairedBraceAndAnglesMatcher.java
View File

@@ -8,11 +8,13 @@ import com.intellij.openapi.editor.highlighter.HighlighterIterator;
import com.intellij.openapi.fileTypes.FileType;
import com.intellij.openapi.fileTypes.LanguageFileType;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
public abstract class PairedBraceAndAnglesMatcher extends PairedBraceMatcherAdapter {
private final TokenSet myTokenSetAllowedInsideAngleBrackets;
private final ParentAwareTokenSet myBasicTokenSetAllowedInsideAngleBrackets;
private final LanguageFileType myFileType;
public PairedBraceAndAnglesMatcher(@NotNull PairedBraceMatcher matcher,
@@ -21,6 +23,17 @@ public abstract class PairedBraceAndAnglesMatcher extends PairedBraceMatcherAdap
@NotNull TokenSet tokenSetAllowedInsideAngleBrackets) {
super(matcher, language);
myTokenSetAllowedInsideAngleBrackets = tokenSetAllowedInsideAngleBrackets;
myBasicTokenSetAllowedInsideAngleBrackets = null;
myFileType = fileType;
}
public PairedBraceAndAnglesMatcher(@NotNull PairedBraceMatcher matcher,
@NotNull Language language,
@NotNull LanguageFileType fileType,
@NotNull ParentAwareTokenSet basicTokenSetAllowedInsideAngleBrackets) {
super(matcher, language);
myTokenSetAllowedInsideAngleBrackets = null;
myBasicTokenSetAllowedInsideAngleBrackets = basicTokenSetAllowedInsideAngleBrackets;
myFileType = fileType;
}
@@ -75,7 +88,9 @@ public abstract class PairedBraceAndAnglesMatcher extends PairedBraceMatcherAdap
continue;
}
if (!myTokenSetAllowedInsideAngleBrackets.contains(tokenType)) {
if (
(myTokenSetAllowedInsideAngleBrackets == null || !myTokenSetAllowedInsideAngleBrackets.contains(tokenType)) &&
(myBasicTokenSetAllowedInsideAngleBrackets == null || !myBasicTokenSetAllowedInsideAngleBrackets.contains(tokenType))) {
return false;
}
}

8
java/java-frontback-impl/src/com/intellij/javadoc/AbstractBasicJavadocHelper.java
View File

@@ -12,8 +12,8 @@ import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.BasicJavaAstTreeUtil;
import com.intellij.psi.impl.source.BasicJavaTokenSet;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
@@ -29,9 +29,9 @@ public abstract class AbstractBasicJavadocHelper {
public static final Pair<JavadocParameterInfo, List<JavadocParameterInfo>> EMPTY
= new Pair<>(null, Collections.emptyList());
private static final @NotNull BasicJavaTokenSet TAG_TOKEN_SET = BasicJavaTokenSet.create(DOC_TAG,
DOC_SNIPPET_TAG,
DOC_INLINE_TAG);
private static final @NotNull ParentAwareTokenSet TAG_TOKEN_SET = ParentAwareTokenSet.create(DOC_TAG,
DOC_SNIPPET_TAG,
DOC_INLINE_TAG);
protected AbstractBasicJavadocHelper() {
}

4
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicDeclarationParser.java
View File

@@ -51,7 +51,7 @@ public class BasicDeclarationParser {
myParser = javaParser;
myJavaElementTypeContainer = javaParser.getJavaElementTypeFactory().getContainer();
TYPE_START = TokenSet.orSet(
BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(),
BASIC_PRIMITIVE_TYPE_BIT_SET,
TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT, JavaTokenType.VAR_KEYWORD));
RESOURCE_EXPRESSIONS = TokenSet.create(
myJavaElementTypeContainer.REFERENCE_EXPRESSION, myJavaElementTypeContainer.THIS_EXPRESSION,
@@ -437,7 +437,7 @@ public class BasicDeclarationParser {
@NotNull
public Pair<PsiBuilder.Marker, Boolean> parseModifierList(final PsiBuilder builder) {
return parseModifierList(builder, BASIC_MODIFIER_BIT_SET.toTokenSet());
return parseModifierList(builder, BASIC_MODIFIER_BIT_SET);
}
@NotNull

2
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java
View File

@@ -34,7 +34,7 @@ public class BasicFileParser {
myParser = javaParser;
myJavaElementTypeContainer = javaParser.getJavaElementTypeFactory().getContainer();
IMPORT_LIST_STOPPER_SET = TokenSet.orSet(
BasicElementTypes.BASIC_MODIFIER_BIT_SET.toTokenSet(),
BasicElementTypes.BASIC_MODIFIER_BIT_SET,
TokenSet.create(JavaTokenType.CLASS_KEYWORD, JavaTokenType.INTERFACE_KEYWORD, JavaTokenType.ENUM_KEYWORD, JavaTokenType.AT));
UNNAMED_CLASS_INDICATORS =
TokenSet.create(myJavaElementTypeContainer.METHOD, myJavaElementTypeContainer.FIELD, myJavaElementTypeContainer.CLASS_INITIALIZER);

2
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicModuleParser.java
View File

@@ -179,7 +179,7 @@ public class BasicModuleParser {
PsiBuilder.Marker modifierList = builder.mark();
while (true) {
if (expect(builder, BasicElementTypes.BASIC_MODIFIER_BIT_SET.toTokenSet())) continue;
if (expect(builder, BasicElementTypes.BASIC_MODIFIER_BIT_SET)) continue;
if (builder.getTokenType() == JavaTokenType.IDENTIFIER && PsiKeyword.TRANSITIVE.equals(builder.getTokenText())) {
mapAndAdvance(builder, JavaTokenType.TRANSITIVE_KEYWORD);
continue;

2
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicOldExpressionParser.java
View File

@@ -49,7 +49,7 @@ public class BasicOldExpressionParser {
myParser = javaParser;
myJavaElementTypeContainer = javaParser.getJavaElementTypeFactory().getContainer();
TYPE_START = TokenSet.orSet(
BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
BASIC_PRIMITIVE_TYPE_BIT_SET, TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
}
@Nullable

2
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicPrattExpressionParser.java
View File

@@ -35,7 +35,7 @@ public class BasicPrattExpressionParser {
JavaTokenType.IDENTIFIER, TokenType.BAD_CHARACTER, JavaTokenType.COMMA, JavaTokenType.INTEGER_LITERAL, JavaTokenType.STRING_LITERAL);
private static final TokenSet ARGS_LIST_END = TokenSet.create(JavaTokenType.RPARENTH, JavaTokenType.RBRACE, JavaTokenType.RBRACKET);
private final TokenSet TYPE_START = TokenSet.orSet(BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
private final TokenSet TYPE_START = TokenSet.orSet(BASIC_PRIMITIVE_TYPE_BIT_SET, TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
private static final TokenSet POSTFIX_OPS = TokenSet.create(JavaTokenType.PLUSPLUS, JavaTokenType.MINUSMINUS);
private static final TokenSet PREF_ARITHMETIC_OPS = TokenSet.orSet(POSTFIX_OPS, TokenSet.create(JavaTokenType.PLUS, JavaTokenType.MINUS));
private static final TokenSet PREFIX_OPS = TokenSet.orSet(PREF_ARITHMETIC_OPS, TokenSet.create(JavaTokenType.TILDE, JavaTokenType.EXCL));

2
java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicReferenceParser.java
View File

@@ -102,7 +102,7 @@ public class BasicReferenceParser {
builder.remapCurrentToken(tokenType = JavaTokenType.IDENTIFIER);
}
if (expect(builder, BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet())) {
if (expect(builder, BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET)) {
typeInfo.isPrimitive = true;
}
else if ((isSet(flags, WILDCARD) || badWildcard) && (tokenType == JavaTokenType.QUEST || isKeywordAny(builder))) {

56
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java
View File

@@ -3,22 +3,24 @@ package com.intellij.psi.impl.source;
import com.intellij.psi.JavaDocTokenType;
import com.intellij.psi.JavaTokenType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.TokenSet;
/**
* The BasicElementTypes interface represents a collection of basic element types used in fronback java modules.
* The BasicElementTypes interface represents a collection of basic element types used in frontback java modules.
* {@link TokenSet} is used for set, which contains `basic` types, which are not used in hierarchy.
* for other sets {@link BasicJavaTokenSet} is used.
* for other sets {@link ParentAwareTokenSet} is used.
*
* @see BasicJavaTokenSet
* @see ParentAwareTokenSet
*/
@SuppressWarnings("unused")
public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, BasicJavaElementType, BasicJavaDocElementType {
TokenSet BASIC_JAVA_PLAIN_COMMENT_BIT_SET = TokenSet.create(END_OF_LINE_COMMENT, C_STYLE_COMMENT);
BasicJavaTokenSet BASIC_JAVA_COMMENT_BIT_SET =
BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(BASIC_JAVA_PLAIN_COMMENT_BIT_SET), BasicJavaTokenSet.create(DOC_COMMENT));
BasicJavaTokenSet BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET =
BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(WHITE_SPACE), BASIC_JAVA_COMMENT_BIT_SET);
ParentAwareTokenSet BASIC_JAVA_COMMENT_BIT_SET =
ParentAwareTokenSet.orSet(ParentAwareTokenSet.create(BASIC_JAVA_PLAIN_COMMENT_BIT_SET), ParentAwareTokenSet.create(DOC_COMMENT));
ParentAwareTokenSet BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET =
ParentAwareTokenSet.orSet(ParentAwareTokenSet.create(WHITE_SPACE), BASIC_JAVA_COMMENT_BIT_SET);
TokenSet BASIC_KEYWORD_BIT_SET = TokenSet.create(
ABSTRACT_KEYWORD, ASSERT_KEYWORD, BOOLEAN_KEYWORD, BREAK_KEYWORD, BYTE_KEYWORD, CASE_KEYWORD, CATCH_KEYWORD, CHAR_KEYWORD,
CLASS_KEYWORD, CONST_KEYWORD, CONTINUE_KEYWORD, DEFAULT_KEYWORD, DO_KEYWORD, DOUBLE_KEYWORD, ELSE_KEYWORD, ENUM_KEYWORD,
@@ -39,14 +41,14 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
PERC, EQEQ, LE, GE, NE, ANDAND, OROR, PLUSPLUS, MINUSMINUS, LTLT, GTGT, GTGTGT,
PLUSEQ, MINUSEQ, ASTERISKEQ, DIVEQ, ANDEQ, OREQ, XOREQ, PERCEQ, LTLTEQ, GTGTEQ, GTGTGTEQ);
BasicJavaTokenSet BASIC_MODIFIER_BIT_SET = BasicJavaTokenSet.create(
TokenSet BASIC_MODIFIER_BIT_SET = TokenSet.create(
PUBLIC_KEYWORD, PROTECTED_KEYWORD, PRIVATE_KEYWORD, STATIC_KEYWORD, ABSTRACT_KEYWORD, FINAL_KEYWORD, NATIVE_KEYWORD,
SYNCHRONIZED_KEYWORD, STRICTFP_KEYWORD, TRANSIENT_KEYWORD, VOLATILE_KEYWORD, DEFAULT_KEYWORD, SEALED_KEYWORD, NON_SEALED_KEYWORD);
BasicJavaTokenSet BASIC_PRIMITIVE_TYPE_BIT_SET = BasicJavaTokenSet.create(
TokenSet BASIC_PRIMITIVE_TYPE_BIT_SET = TokenSet.create(
BOOLEAN_KEYWORD, BYTE_KEYWORD, SHORT_KEYWORD, INT_KEYWORD, LONG_KEYWORD, CHAR_KEYWORD, FLOAT_KEYWORD, DOUBLE_KEYWORD, VOID_KEYWORD);
BasicJavaTokenSet BASIC_EXPRESSION_BIT_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_EXPRESSION_BIT_SET = ParentAwareTokenSet.create(
BASIC_REFERENCE_EXPRESSION, BASIC_LITERAL_EXPRESSION, BASIC_THIS_EXPRESSION, BASIC_SUPER_EXPRESSION,
BASIC_PARENTH_EXPRESSION, BASIC_METHOD_CALL_EXPRESSION,
BASIC_TYPE_CAST_EXPRESSION, BASIC_PREFIX_EXPRESSION, BASIC_POSTFIX_EXPRESSION, BASIC_BINARY_EXPRESSION,
@@ -57,11 +59,11 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_EMPTY_EXPRESSION,
BASIC_TEMPLATE_EXPRESSION);
BasicJavaTokenSet BASIC_ANNOTATION_MEMBER_VALUE_BIT_SET =
BasicJavaTokenSet.orSet(BASIC_EXPRESSION_BIT_SET, BasicJavaTokenSet.create(BASIC_ANNOTATION,
BASIC_ANNOTATION_ARRAY_INITIALIZER));
ParentAwareTokenSet BASIC_ANNOTATION_MEMBER_VALUE_BIT_SET =
ParentAwareTokenSet.orSet(BASIC_EXPRESSION_BIT_SET, ParentAwareTokenSet.create(BASIC_ANNOTATION,
BASIC_ANNOTATION_ARRAY_INITIALIZER));
BasicJavaTokenSet BASIC_ARRAY_DIMENSION_BIT_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_ARRAY_DIMENSION_BIT_SET = ParentAwareTokenSet.create(
BASIC_REFERENCE_EXPRESSION, BASIC_LITERAL_EXPRESSION, BASIC_THIS_EXPRESSION, BASIC_SUPER_EXPRESSION,
BASIC_PARENTH_EXPRESSION, BASIC_METHOD_CALL_EXPRESSION,
BASIC_TYPE_CAST_EXPRESSION, BASIC_PREFIX_EXPRESSION, BASIC_POSTFIX_EXPRESSION, BASIC_BINARY_EXPRESSION,
@@ -70,7 +72,7 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_CLASS_OBJECT_ACCESS_EXPRESSION,
BASIC_EMPTY_EXPRESSION);
BasicJavaTokenSet BASIC_JAVA_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_JAVA_STATEMENT_BIT_SET = ParentAwareTokenSet.create(
BASIC_EMPTY_STATEMENT, BASIC_BLOCK_STATEMENT, BASIC_EXPRESSION_STATEMENT, BASIC_EXPRESSION_LIST_STATEMENT,
BASIC_DECLARATION_STATEMENT, BASIC_IF_STATEMENT,
BASIC_WHILE_STATEMENT, BASIC_FOR_STATEMENT, BASIC_FOREACH_STATEMENT, BASIC_DO_WHILE_STATEMENT,
@@ -79,24 +81,24 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_TRY_STATEMENT, BASIC_LABELED_STATEMENT, BASIC_ASSERT_STATEMENT,
BASIC_YIELD_STATEMENT);
BasicJavaTokenSet BASIC_JAVA_PATTERN_BIT_SET =
BasicJavaTokenSet.create(BASIC_TYPE_TEST_PATTERN, BASIC_PARENTHESIZED_PATTERN, BASIC_DECONSTRUCTION_PATTERN, BASIC_UNNAMED_PATTERN);
ParentAwareTokenSet BASIC_JAVA_PATTERN_BIT_SET =
ParentAwareTokenSet.create(BASIC_TYPE_TEST_PATTERN, BASIC_PARENTHESIZED_PATTERN, BASIC_DECONSTRUCTION_PATTERN, BASIC_UNNAMED_PATTERN);
BasicJavaTokenSet BASIC_JAVA_CASE_LABEL_ELEMENT_BIT_SET =
BasicJavaTokenSet.orSet(BASIC_JAVA_PATTERN_BIT_SET, BASIC_EXPRESSION_BIT_SET, BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_JAVA_CASE_LABEL_ELEMENT_BIT_SET =
ParentAwareTokenSet.orSet(BASIC_JAVA_PATTERN_BIT_SET, BASIC_EXPRESSION_BIT_SET, ParentAwareTokenSet.create(
BASIC_DEFAULT_CASE_LABEL_ELEMENT));
BasicJavaTokenSet BASIC_JAVA_MODULE_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_JAVA_MODULE_STATEMENT_BIT_SET = ParentAwareTokenSet.create(
BASIC_REQUIRES_STATEMENT, BASIC_EXPORTS_STATEMENT, BASIC_OPENS_STATEMENT, BASIC_USES_STATEMENT,
BASIC_PROVIDES_STATEMENT);
BasicJavaTokenSet BASIC_IMPORT_STATEMENT_BASE_BIT_SET = BasicJavaTokenSet.create(BASIC_IMPORT_STATEMENT,
BASIC_IMPORT_STATIC_STATEMENT);
BasicJavaTokenSet BASIC_CLASS_KEYWORD_BIT_SET =
BasicJavaTokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD, ENUM_KEYWORD, RECORD_KEYWORD);
BasicJavaTokenSet BASIC_MEMBER_BIT_SET = BasicJavaTokenSet.create(BASIC_CLASS, BASIC_FIELD, BASIC_ENUM_CONSTANT,
BASIC_METHOD, BASIC_ANNOTATION_METHOD);
BasicJavaTokenSet BASIC_FULL_MEMBER_BIT_SET = BasicJavaTokenSet.orSet(BASIC_MEMBER_BIT_SET, BasicJavaTokenSet.create(
ParentAwareTokenSet BASIC_IMPORT_STATEMENT_BASE_BIT_SET = ParentAwareTokenSet.create(BASIC_IMPORT_STATEMENT,
BASIC_IMPORT_STATIC_STATEMENT);
TokenSet BASIC_CLASS_KEYWORD_BIT_SET =
TokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD, ENUM_KEYWORD, RECORD_KEYWORD);
ParentAwareTokenSet BASIC_MEMBER_BIT_SET = ParentAwareTokenSet.create(BASIC_CLASS, BASIC_FIELD, BASIC_ENUM_CONSTANT,
BASIC_METHOD, BASIC_ANNOTATION_METHOD);
ParentAwareTokenSet BASIC_FULL_MEMBER_BIT_SET = ParentAwareTokenSet.orSet(BASIC_MEMBER_BIT_SET, ParentAwareTokenSet.create(
BASIC_CLASS_INITIALIZER));
TokenSet BASIC_INTEGER_LITERALS = TokenSet.create(INTEGER_LITERAL, LONG_LITERAL);

39
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaAstTreeUtil.java
View File

@@ -8,6 +8,7 @@ import com.intellij.openapi.util.TextRange;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.tree.TreeUtil;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.ParentProviderElementType;
import com.intellij.psi.tree.TokenSet;
import com.intellij.psi.tree.java.IJavaDocElementType;
@@ -67,10 +68,10 @@ public final class BasicJavaAstTreeUtil {
if (!isNotNull) {
return false;
}
return is(element.getElementType(), tokenSet);
return ParentProviderElementType.containsWithSourceParent(element.getElementType(), tokenSet);
}
public static boolean is(@Nullable ASTNode element, @NotNull BasicJavaTokenSet tokenSet) {
public static boolean is(@Nullable ASTNode element, @NotNull ParentAwareTokenSet tokenSet) {
boolean isNotNull = element != null;
if (!isNotNull) {
return false;
@@ -78,19 +79,7 @@ public final class BasicJavaAstTreeUtil {
return is(element.getElementType(), tokenSet);
}
//needs for FrontBackJavaTokenSet
public static boolean is(@NotNull IElementType source, @NotNull TokenSet tokenSet) {
if (tokenSet.contains(source)) {
return true;
}
if (source instanceof ParentProviderElementType) {
Set<IElementType> parents = ((ParentProviderElementType)source).getParents();
return ContainerUtil.exists(parents, parent -> parent != null && is(parent, tokenSet));
}
return false;
}
private static boolean is(@NotNull IElementType source, @NotNull BasicJavaTokenSet tokenSet) {
private static boolean is(@NotNull IElementType source, @NotNull ParentAwareTokenSet tokenSet) {
//not call iteratively!
if (tokenSet.contains(source)) {
return true;
@@ -110,7 +99,7 @@ public final class BasicJavaAstTreeUtil {
}
public static boolean is(@Nullable ASTNode element, IElementType... iElementTypes) {
return is(element, BasicJavaTokenSet.create(iElementTypes));
return is(element, ParentAwareTokenSet.create(iElementTypes));
}
public static List<ASTNode> getChildren(@Nullable ASTNode element) {
@@ -152,10 +141,10 @@ public final class BasicJavaAstTreeUtil {
public static @Nullable ASTNode findChildByType(@Nullable ASTNode astNode, IElementType... targets) {
return findChildByType(astNode, BasicJavaTokenSet.create(targets));
return findChildByType(astNode, ParentAwareTokenSet.create(targets));
}
public static @Nullable ASTNode findChildByType(@Nullable ASTNode astNode, BasicJavaTokenSet targets) {
public static @Nullable ASTNode findChildByType(@Nullable ASTNode astNode, ParentAwareTokenSet targets) {
if (astNode == null) {
return null;
}
@@ -316,7 +305,7 @@ public final class BasicJavaAstTreeUtil {
}
@Nullable
public static ASTNode getParentOfType(@Nullable ASTNode e, @NotNull BasicJavaTokenSet set) {
public static ASTNode getParentOfType(@Nullable ASTNode e, @NotNull ParentAwareTokenSet set) {
if (e == null) {
return null;
}
@@ -330,7 +319,7 @@ public final class BasicJavaAstTreeUtil {
return null;
}
private static @Nullable ASTNode findParent(@NotNull ASTNode element, @NotNull BasicJavaTokenSet type) {
private static @Nullable ASTNode findParent(@NotNull ASTNode element, @NotNull ParentAwareTokenSet type) {
for (ASTNode parent = element.getTreeParent(); parent != null; parent = parent.getTreeParent()) {
if (is(parent.getElementType(), type)) return parent;
}
@@ -425,7 +414,7 @@ public final class BasicJavaAstTreeUtil {
public static @Nullable PsiElement getParentOfType(@Nullable PsiElement element,
@NotNull IElementType target,
boolean strict,
@Nullable BasicJavaTokenSet stopAt) {
@Nullable ParentAwareTokenSet stopAt) {
if (element == null) return null;
if (strict) {
if (element instanceof PsiFile) return null;
@@ -512,7 +501,7 @@ public final class BasicJavaAstTreeUtil {
}
@Nullable
public static ASTNode getParentOfType(@Nullable ASTNode e, @NotNull BasicJavaTokenSet types, boolean strict) {
public static ASTNode getParentOfType(@Nullable ASTNode e, @NotNull ParentAwareTokenSet types, boolean strict) {
if (!strict && is(e, types)) {
return e;
}
@@ -527,7 +516,7 @@ public final class BasicJavaAstTreeUtil {
if (e == null) {
return null;
}
return toPsi(getParentOfType(e.getNode(), BasicJavaTokenSet.create(types)));
return toPsi(getParentOfType(e.getNode(), ParentAwareTokenSet.create(types)));
}
@Nullable
@@ -779,8 +768,8 @@ public final class BasicJavaAstTreeUtil {
return null;
}
return findChildByType(element, BasicJavaTokenSet.orSet(
BasicJavaTokenSet.create(BASIC_BLOCK_STATEMENT, BASIC_THROW_STATEMENT), EXPRESSION_SET));
return findChildByType(element, ParentAwareTokenSet.orSet(
ParentAwareTokenSet.create(BASIC_BLOCK_STATEMENT, BASIC_THROW_STATEMENT), EXPRESSION_SET));
}
@Nullable

2
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java
View File

@@ -44,7 +44,7 @@ public interface BasicJavaDocElementType {
IElementType DOC_COMMENT = new IJavaDocElementType("DOC_COMMENT");
BasicJavaTokenSet ALL_JAVADOC_ELEMENTS = BasicJavaTokenSet.create(
ParentAwareTokenSet ALL_JAVADOC_ELEMENTS = ParentAwareTokenSet.create(
DOC_TAG, DOC_INLINE_TAG, DOC_METHOD_OR_FIELD_REF, DOC_PARAMETER_REF, DOC_TAG_VALUE_ELEMENT,
DOC_REFERENCE_HOLDER, DOC_TYPE_HOLDER, DOC_COMMENT);

28
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java
View File

@@ -159,8 +159,8 @@ public interface BasicJavaElementType {
IElementType BASIC_TYPE_WITH_CONJUNCTIONS_TEXT = new IElementType("TYPE_WITH_CONJUNCTIONS_TEXT", JavaLanguage.INSTANCE);
IElementType BASIC_DUMMY_ELEMENT = new IJavaElementType("DUMMY_ELEMENT");
BasicJavaTokenSet STATEMENT_SET =
BasicJavaTokenSet.create(
ParentAwareTokenSet STATEMENT_SET =
ParentAwareTokenSet.create(
BASIC_ASSERT_STATEMENT, BASIC_BLOCK_STATEMENT, BASIC_BREAK_STATEMENT, BASIC_CONTINUE_STATEMENT,
BASIC_DECLARATION_STATEMENT, BASIC_DO_WHILE_STATEMENT, BASIC_EMPTY_STATEMENT, BASIC_EXPRESSION_LIST_STATEMENT,
BASIC_EXPRESSION_STATEMENT,
@@ -174,21 +174,21 @@ public interface BasicJavaElementType {
IElementType BASIC_JAVA_CODE_REFERENCE_ELEMENT_MARK = new IElementType("BASIC_JAVA_CODE_REFERENCE_ELEMENT_MARK", JavaLanguage.INSTANCE);
BasicJavaTokenSet JAVA_CODE_REFERENCE_ELEMENT_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet JAVA_CODE_REFERENCE_ELEMENT_SET = ParentAwareTokenSet.create(
BASIC_JAVA_CODE_REFERENCE_ELEMENT_MARK,
BASIC_IMPORT_STATIC_REFERENCE, BASIC_JAVA_CODE_REFERENCE, BASIC_METHOD_REF_EXPRESSION, BASIC_REFERENCE_EXPRESSION
);
IElementType BASIC_REFERENCE_EXPRESSION_MARK = new IElementType("BASIC_REFERENCE_EXPRESSION_MARK", JavaLanguage.INSTANCE);
BasicJavaTokenSet REFERENCE_EXPRESSION_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet REFERENCE_EXPRESSION_SET = ParentAwareTokenSet.create(
BASIC_REFERENCE_EXPRESSION_MARK,
BASIC_METHOD_REF_EXPRESSION, BASIC_REFERENCE_EXPRESSION
);
IElementType BASIC_EXPRESSION_MARK = new IElementType("BASIC_EXPRESSION_MARK", JavaLanguage.INSTANCE);
BasicJavaTokenSet EXPRESSION_SET = BasicJavaTokenSet.create(
ParentAwareTokenSet EXPRESSION_SET = ParentAwareTokenSet.create(
BASIC_EXPRESSION_MARK,
BASIC_REFERENCE_EXPRESSION, BASIC_LITERAL_EXPRESSION, BASIC_THIS_EXPRESSION, BASIC_SUPER_EXPRESSION,
BASIC_PARENTH_EXPRESSION, BASIC_METHOD_CALL_EXPRESSION,
@@ -203,17 +203,17 @@ public interface BasicJavaElementType {
IElementType BASIC_CLASS_MARK = new IElementType("BASIC_CLASS_MARK", JavaLanguage.INSTANCE);
BasicJavaTokenSet CLASS_SET = BasicJavaTokenSet.create(BASIC_CLASS_MARK,
BASIC_CLASS, BASIC_ANONYMOUS_CLASS,
BASIC_ENUM_CONSTANT_INITIALIZER);
ParentAwareTokenSet CLASS_SET = ParentAwareTokenSet.create(BASIC_CLASS_MARK,
BASIC_CLASS, BASIC_ANONYMOUS_CLASS,
BASIC_ENUM_CONSTANT_INITIALIZER);
IElementType BASIC_MEMBER_MARK = new IElementType("BASIC_MEMBER_MARK", JavaLanguage.INSTANCE);
BasicJavaTokenSet MEMBER_SET = BasicJavaTokenSet.create(BASIC_MEMBER_MARK,
BASIC_ANNOTATION_METHOD, BASIC_ANONYMOUS_CLASS, BASIC_CLASS,
BASIC_CLASS_INITIALIZER,
BASIC_ENUM_CONSTANT, BASIC_ENUM_CONSTANT_INITIALIZER, BASIC_FIELD,
BASIC_METHOD, BASIC_RECORD_COMPONENT,
BASIC_TYPE_PARAMETER);
ParentAwareTokenSet MEMBER_SET = ParentAwareTokenSet.create(BASIC_MEMBER_MARK,
BASIC_ANNOTATION_METHOD, BASIC_ANONYMOUS_CLASS, BASIC_CLASS,
BASIC_CLASS_INITIALIZER,
BASIC_ENUM_CONSTANT, BASIC_ENUM_CONSTANT_INITIALIZER, BASIC_FIELD,
BASIC_METHOD, BASIC_RECORD_COMPONENT,
BASIC_TYPE_PARAMETER);
class JavaCompositeElementType extends IJavaElementType implements ICompositeElementType, ParentProviderElementType {

59
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaTokenSet.java
View File

@@ -1,59 +0,0 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.impl.source;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentProviderElementType;
import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.Set;
/**
* A utility class, analogue {@link TokenSet}.
* The main purpose is to check if a given token type is present in the token set.
* The main difference is that this class supports hierarchy with {@link ParentProviderElementType}
* This class shouldn't be used in cases, when it needs to get all elements from this set, because in this case
* iteration through all loaded IElementType will be performed
*/
public final class BasicJavaTokenSet {
private final TokenSet myTokenSet;
private BasicJavaTokenSet(@NotNull TokenSet set) { myTokenSet = set; }
public boolean contains(@Nullable IElementType iElementType) {
if (iElementType == null) {
return false;
}
return BasicJavaAstTreeUtil.is(iElementType, myTokenSet);
}
/**
*
* @return The TokenSet, which can be used to check that it contains some elements.
* Not use this method if {@link TokenSet#getTypes()} will be used on this set,
* in this case it is better to create TokenSet from values
*/
public TokenSet toTokenSet() {
return TokenSet.forAllMatching(t -> this.contains(t));
}
public static BasicJavaTokenSet create(@NotNull TokenSet set) {
return new BasicJavaTokenSet(set);
}
static BasicJavaTokenSet create(@NotNull Set<IElementType> set) {
return new BasicJavaTokenSet(TokenSet.create(set.toArray(IElementType.EMPTY_ARRAY)));
}
public static BasicJavaTokenSet orSet(BasicJavaTokenSet... sets) {
TokenSet tokenSet = TokenSet.orSet(Arrays.stream(sets).map(t -> t.myTokenSet).toArray(TokenSet[]::new));
return new BasicJavaTokenSet(tokenSet);
}
public static BasicJavaTokenSet create(IElementType... set) {
TokenSet tokenSet = TokenSet.create(set);
return new BasicJavaTokenSet(tokenSet);
}
}

13
java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/WhiteSpaceAndCommentSetHolder.java
View File

@@ -4,21 +4,22 @@ package com.intellij.psi.impl.source;
import com.intellij.lang.WhitespacesAndCommentsBinder;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.psi.tree.IElementType;
import com.intellij.psi.tree.ParentAwareTokenSet;
import com.intellij.psi.tree.TokenSet;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
import static com.intellij.psi.impl.source.BasicJavaTokenSet.create;
import static com.intellij.psi.impl.source.BasicJavaTokenSet.orSet;
import static com.intellij.psi.tree.ParentAwareTokenSet.create;
import static com.intellij.psi.tree.ParentAwareTokenSet.orSet;
public class WhiteSpaceAndCommentSetHolder {
public static final WhiteSpaceAndCommentSetHolder INSTANCE = new WhiteSpaceAndCommentSetHolder();
private static final BasicJavaTokenSet PRECEDING_COMMENT_SET =
private static final ParentAwareTokenSet PRECEDING_COMMENT_SET =
orSet(create(BasicJavaElementType.BASIC_MODULE), BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET);
private static final BasicJavaTokenSet TRAILING_COMMENT_SET =
private static final ParentAwareTokenSet TRAILING_COMMENT_SET =
orSet(create(BasicJavaElementType.BASIC_PACKAGE_STATEMENT), BasicElementTypes.BASIC_IMPORT_STATEMENT_BASE_BIT_SET,
BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET, BasicElementTypes.BASIC_JAVA_STATEMENT_BIT_SET);
@@ -41,11 +42,11 @@ public class WhiteSpaceAndCommentSetHolder {
return TRAILING_COMMENT_BINDER;
}
public BasicJavaTokenSet getPrecedingCommentSet() {
public ParentAwareTokenSet getPrecedingCommentSet() {
return PRECEDING_COMMENT_SET;
}
public BasicJavaTokenSet getTrailingCommentSet() {
public ParentAwareTokenSet getTrailingCommentSet() {
return TRAILING_COMMENT_SET;
}

61
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java
View File

@@ -6,10 +6,12 @@ import com.intellij.psi.JavaTokenType;
import com.intellij.psi.impl.source.BasicElementTypes;
import com.intellij.psi.tree.TokenSet;
@SuppressWarnings("unused")
public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElementType, JavaDocElementType {
TokenSet JAVA_PLAIN_COMMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET;
TokenSet JAVA_COMMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_OR_WHITESPACE_BIT_SET = BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_BIT_SET = TokenSet.orSet(JAVA_PLAIN_COMMENT_BIT_SET, TokenSet.create(DOC_COMMENT));
;
TokenSet JAVA_COMMENT_OR_WHITESPACE_BIT_SET = TokenSet.orSet(TokenSet.WHITE_SPACE, JAVA_COMMENT_BIT_SET);
TokenSet KEYWORD_BIT_SET = BasicElementTypes.BASIC_KEYWORD_BIT_SET;
@@ -17,27 +19,56 @@ public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElemen
TokenSet OPERATION_BIT_SET = BasicElementTypes.BASIC_OPERATION_BIT_SET;
TokenSet MODIFIER_BIT_SET = BasicElementTypes.BASIC_MODIFIER_BIT_SET.toTokenSet();
TokenSet MODIFIER_BIT_SET = BasicElementTypes.BASIC_MODIFIER_BIT_SET;
TokenSet PRIMITIVE_TYPE_BIT_SET = BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet();
TokenSet PRIMITIVE_TYPE_BIT_SET = BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET;
TokenSet EXPRESSION_BIT_SET = BasicElementTypes.BASIC_EXPRESSION_BIT_SET.toTokenSet();
TokenSet EXPRESSION_BIT_SET = TokenSet.create(
REFERENCE_EXPRESSION, LITERAL_EXPRESSION, THIS_EXPRESSION, SUPER_EXPRESSION,
PARENTH_EXPRESSION, METHOD_CALL_EXPRESSION,
TYPE_CAST_EXPRESSION, PREFIX_EXPRESSION, POSTFIX_EXPRESSION, BINARY_EXPRESSION,
POLYADIC_EXPRESSION, CONDITIONAL_EXPRESSION,
ASSIGNMENT_EXPRESSION, NEW_EXPRESSION, ARRAY_ACCESS_EXPRESSION,
ARRAY_INITIALIZER_EXPRESSION, INSTANCE_OF_EXPRESSION,
CLASS_OBJECT_ACCESS_EXPRESSION, METHOD_REF_EXPRESSION, LAMBDA_EXPRESSION, SWITCH_EXPRESSION,
EMPTY_EXPRESSION,
TEMPLATE_EXPRESSION);
TokenSet ANNOTATION_MEMBER_VALUE_BIT_SET = BasicElementTypes.BASIC_ANNOTATION_MEMBER_VALUE_BIT_SET.toTokenSet();
TokenSet ARRAY_DIMENSION_BIT_SET = BasicElementTypes.BASIC_ARRAY_DIMENSION_BIT_SET.toTokenSet();
TokenSet ANNOTATION_MEMBER_VALUE_BIT_SET = TokenSet.orSet(EXPRESSION_BIT_SET,
TokenSet.create(ANNOTATION, ANNOTATION_ARRAY_INITIALIZER));
TokenSet JAVA_STATEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_STATEMENT_BIT_SET.toTokenSet();
TokenSet ARRAY_DIMENSION_BIT_SET = TokenSet.create(
REFERENCE_EXPRESSION, LITERAL_EXPRESSION, THIS_EXPRESSION, SUPER_EXPRESSION,
PARENTH_EXPRESSION, METHOD_CALL_EXPRESSION,
TYPE_CAST_EXPRESSION, PREFIX_EXPRESSION, POSTFIX_EXPRESSION, BINARY_EXPRESSION,
POLYADIC_EXPRESSION, CONDITIONAL_EXPRESSION,
ASSIGNMENT_EXPRESSION, NEW_EXPRESSION, ARRAY_ACCESS_EXPRESSION, INSTANCE_OF_EXPRESSION,
CLASS_OBJECT_ACCESS_EXPRESSION,
EMPTY_EXPRESSION);
;
TokenSet JAVA_PATTERN_BIT_SET = BasicElementTypes.BASIC_JAVA_PATTERN_BIT_SET.toTokenSet();
TokenSet JAVA_STATEMENT_BIT_SET = TokenSet.create(
EMPTY_STATEMENT, BLOCK_STATEMENT, EXPRESSION_STATEMENT, EXPRESSION_LIST_STATEMENT,
DECLARATION_STATEMENT, IF_STATEMENT,
WHILE_STATEMENT, FOR_STATEMENT, FOREACH_STATEMENT, DO_WHILE_STATEMENT,
SWITCH_STATEMENT, SWITCH_LABEL_STATEMENT, BREAK_STATEMENT,
CONTINUE_STATEMENT, RETURN_STATEMENT, THROW_STATEMENT, SYNCHRONIZED_STATEMENT,
TRY_STATEMENT, LABELED_STATEMENT, ASSERT_STATEMENT,
YIELD_STATEMENT);
TokenSet JAVA_CASE_LABEL_ELEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_CASE_LABEL_ELEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_PATTERN_BIT_SET = TokenSet.create(TYPE_TEST_PATTERN, PARENTHESIZED_PATTERN, DECONSTRUCTION_PATTERN, UNNAMED_PATTERN);
TokenSet JAVA_MODULE_STATEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_MODULE_STATEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_CASE_LABEL_ELEMENT_BIT_SET =
TokenSet.orSet(JAVA_PATTERN_BIT_SET, EXPRESSION_BIT_SET, TokenSet.create(DEFAULT_CASE_LABEL_ELEMENT));
TokenSet IMPORT_STATEMENT_BASE_BIT_SET = BasicElementTypes.BASIC_IMPORT_STATEMENT_BASE_BIT_SET.toTokenSet();
TokenSet CLASS_KEYWORD_BIT_SET = BasicElementTypes.BASIC_CLASS_KEYWORD_BIT_SET.toTokenSet();
TokenSet MEMBER_BIT_SET = BasicElementTypes.BASIC_MEMBER_BIT_SET.toTokenSet();
TokenSet FULL_MEMBER_BIT_SET = BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET.toTokenSet();
TokenSet JAVA_MODULE_STATEMENT_BIT_SET = TokenSet.create(
REQUIRES_STATEMENT, EXPORTS_STATEMENT, OPENS_STATEMENT, USES_STATEMENT, PROVIDES_STATEMENT);
TokenSet IMPORT_STATEMENT_BASE_BIT_SET = TokenSet.create(IMPORT_STATEMENT, IMPORT_STATIC_STATEMENT);
TokenSet CLASS_KEYWORD_BIT_SET = BasicElementTypes.BASIC_CLASS_KEYWORD_BIT_SET;
TokenSet MEMBER_BIT_SET = TokenSet.create(CLASS, FIELD, ENUM_CONSTANT, METHOD, ANNOTATION_METHOD);
TokenSet FULL_MEMBER_BIT_SET = TokenSet.orSet(MEMBER_BIT_SET, TokenSet.create(
CLASS_INITIALIZER));
TokenSet INTEGER_LITERALS = BasicElementTypes.BASIC_INTEGER_LITERALS;
TokenSet REAL_LITERALS = BasicElementTypes.BASIC_REAL_LITERALS;

3
java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaDocElementType.java
View File

@@ -84,5 +84,6 @@ public interface JavaDocElementType {
}
};
TokenSet ALL_JAVADOC_ELEMENTS = BasicJavaDocElementType.ALL_JAVADOC_ELEMENTS.toTokenSet();
TokenSet ALL_JAVADOC_ELEMENTS = TokenSet.create(DOC_TAG, DOC_INLINE_TAG, DOC_METHOD_OR_FIELD_REF, DOC_PARAMETER_REF, DOC_TAG_VALUE_ELEMENT,
DOC_REFERENCE_HOLDER, DOC_TYPE_HOLDER, DOC_COMMENT);
}

54
platform/core-api/src/com/intellij/psi/tree/ParentAwareTokenSet.java Normal file
View File

@@ -0,0 +1,54 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.tree;
import org.jetbrains.annotations.Contract;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.Set;
/**
* Analogue {@link TokenSet}.
* The main purpose is to check if a given token type is present in the token set.
* The main difference is that this class supports hierarchy with {@link ParentProviderElementType}
*/
public final class ParentAwareTokenSet {
private final TokenSet myTokenSet;
private ParentAwareTokenSet(@NotNull TokenSet set) { myTokenSet = set; }
/**
* @return true if the provided token set contains given source element type or any of its parents, otherwise false
* @see ParentProviderElementType#containsWithSourceParent(IElementType, TokenSet)
*/
@Contract("null -> false")
public boolean contains(@Nullable IElementType iElementType) {
if (iElementType == null) {
return false;
}
return ParentProviderElementType.containsWithSourceParent(iElementType, myTokenSet);
}
@NotNull
public static ParentAwareTokenSet create(@NotNull TokenSet set) {
return new ParentAwareTokenSet(set);
}
@NotNull
public static ParentAwareTokenSet create(@NotNull Set<IElementType> set) {
return new ParentAwareTokenSet(TokenSet.create(set.toArray(IElementType.EMPTY_ARRAY)));
}
@NotNull
public static ParentAwareTokenSet orSet(ParentAwareTokenSet... sets) {
TokenSet tokenSet = TokenSet.orSet(Arrays.stream(sets).map(t -> t.myTokenSet).toArray(TokenSet[]::new));
return new ParentAwareTokenSet(tokenSet);
}
@NotNull
public static ParentAwareTokenSet create(IElementType... set) {
TokenSet tokenSet = TokenSet.create(set);
return new ParentAwareTokenSet(tokenSet);
}
}

24
platform/core-api/src/com/intellij/psi/tree/ParentProviderElementType.java
View File

@@ -1,11 +1,35 @@
// Copyright 2000-2023 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license.
package com.intellij.psi.tree;
import com.intellij.util.containers.ContainerUtil;
import org.jetbrains.annotations.NotNull;
import java.util.Set;
/**
* A marker interface to be implemented by classes that provide
* information about the parent element types.
* Could be used to create hierarchy for IElementType
*/
public interface ParentProviderElementType {
@NotNull
Set<IElementType> getParents();
/**
* @param source The source element type to check.
* @param tokenSet The set of token types to check against (this token set must contain the highest parents to check against)
* @return true if the provided token set contains given source element type or any of its parents, otherwise false
*/
static boolean containsWithSourceParent(@NotNull IElementType source, @NotNull TokenSet tokenSet) {
if (tokenSet.contains(source)) {
return true;
}
if (source instanceof ParentProviderElementType) {
Set<IElementType> parents = ((ParentProviderElementType)source).getParents();
return ContainerUtil.exists(parents, parent -> parent != null &&
containsWithSourceParent(parent, tokenSet));
}
return false;
}
}