From 4cf2e16167e1794e628e7d4a91b5e63a2fa60062 Mon Sep 17 00:00:00 2001 From: Mikhail Pyltsin Date: Thu, 28 Sep 2023 10:40:09 +0200 Subject: [PATCH] [java-rd] IDEA-333104 fix cases when highlighting get null in parents - 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 --- .../com/intellij/BaseJavaJspElementType.java | 8 +-- .../AbstractBasicJavaTypedHandler.java | 6 +- .../AbstractBasicJavadocTypedHandler.java | 4 +- .../editorActions/JavaQuoteHandler.java | 18 +++--- .../CommentBreakerEnterProcessor.java | 6 +- .../LeaveCodeBlockEnterProcessor.java | 8 +-- .../smartEnter/MissingLoopBodyFixer.java | 8 +-- .../MissingReturnExpressionFixer.java | 6 +- .../highlighting/JavaPairedBraceMatcher.java | 18 +++--- .../PairedBraceAndAnglesMatcher.java | 17 +++++- .../javadoc/AbstractBasicJavadocHelper.java | 8 +-- .../java/parser/BasicDeclarationParser.java | 4 +- .../lang/java/parser/BasicFileParser.java | 2 +- .../lang/java/parser/BasicModuleParser.java | 2 +- .../java/parser/BasicOldExpressionParser.java | 2 +- .../parser/BasicPrattExpressionParser.java | 2 +- .../java/parser/BasicReferenceParser.java | 2 +- .../psi/impl/source/BasicElementTypes.java | 56 +++++++++-------- .../psi/impl/source/BasicJavaAstTreeUtil.java | 39 +++++------- .../impl/source/BasicJavaDocElementType.java | 2 +- .../psi/impl/source/BasicJavaElementType.java | 28 ++++----- .../psi/impl/source/BasicJavaTokenSet.java | 59 ------------------ .../source/WhiteSpaceAndCommentSetHolder.java | 13 ++-- .../psi/impl/source/tree/ElementType.java | 61 ++++++++++++++----- .../impl/source/tree/JavaDocElementType.java | 3 +- .../psi/tree/ParentAwareTokenSet.java | 54 ++++++++++++++++ .../psi/tree/ParentProviderElementType.java | 24 ++++++++ 27 files changed, 259 insertions(+), 201 deletions(-) delete mode 100644 java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaTokenSet.java create mode 100644 platform/core-api/src/com/intellij/psi/tree/ParentAwareTokenSet.java diff --git a/java/java-frontback-impl/src/com/intellij/BaseJavaJspElementType.java b/java/java-frontback-impl/src/com/intellij/BaseJavaJspElementType.java index abfd042c16a0..40464cd15b4d 100644 --- a/java/java-frontback-impl/src/com/intellij/BaseJavaJspElementType.java +++ b/java/java-frontback-impl/src/com/intellij/BaseJavaJspElementType.java @@ -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)); } diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavaTypedHandler.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavaTypedHandler.java index d606f736b75b..c49f215a2520 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavaTypedHandler.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavaTypedHandler.java @@ -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) && diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavadocTypedHandler.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavadocTypedHandler.java index a4d8e68952c6..d1f78c1a4bf0 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavadocTypedHandler.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/AbstractBasicJavadocTypedHandler.java @@ -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; } diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaQuoteHandler.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaQuoteHandler.java index 8a1112932c8b..b1297317d2c2 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaQuoteHandler.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaQuoteHandler.java @@ -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 diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/CommentBreakerEnterProcessor.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/CommentBreakerEnterProcessor.java index ccca6fdc54e2..5595f4ea5907 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/CommentBreakerEnterProcessor.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/CommentBreakerEnterProcessor.java @@ -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 diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/LeaveCodeBlockEnterProcessor.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/LeaveCodeBlockEnterProcessor.java index be81806ae466..53490ce15453 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/LeaveCodeBlockEnterProcessor.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/LeaveCodeBlockEnterProcessor.java @@ -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 diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingLoopBodyFixer.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingLoopBodyFixer.java index e9d046b72f43..0e6c77f69563 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingLoopBodyFixer.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingLoopBodyFixer.java @@ -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; diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingReturnExpressionFixer.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingReturnExpressionFixer.java index d1df37432982..32549232f2ff 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingReturnExpressionFixer.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/smartEnter/MissingReturnExpressionFixer.java @@ -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")) { diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaPairedBraceMatcher.java b/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaPairedBraceMatcher.java index 9e402cd61dd2..9eb76e50d2c0 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaPairedBraceMatcher.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaPairedBraceMatcher.java @@ -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 diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/PairedBraceAndAnglesMatcher.java b/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/PairedBraceAndAnglesMatcher.java index 64ae8af6083e..7b5d90b489dc 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/PairedBraceAndAnglesMatcher.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/PairedBraceAndAnglesMatcher.java @@ -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; } } diff --git a/java/java-frontback-impl/src/com/intellij/javadoc/AbstractBasicJavadocHelper.java b/java/java-frontback-impl/src/com/intellij/javadoc/AbstractBasicJavadocHelper.java index ab7d10aa0e8d..216b88164527 100644 --- a/java/java-frontback-impl/src/com/intellij/javadoc/AbstractBasicJavadocHelper.java +++ b/java/java-frontback-impl/src/com/intellij/javadoc/AbstractBasicJavadocHelper.java @@ -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> 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() { } diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicDeclarationParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicDeclarationParser.java index 846c76d177a4..97062af85718 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicDeclarationParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicDeclarationParser.java @@ -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 parseModifierList(final PsiBuilder builder) { - return parseModifierList(builder, BASIC_MODIFIER_BIT_SET.toTokenSet()); + return parseModifierList(builder, BASIC_MODIFIER_BIT_SET); } @NotNull diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java index 0cf1c77b9a0d..e1d39e73fe92 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicFileParser.java @@ -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); diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicModuleParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicModuleParser.java index 82e9e6221745..fef6cdfaa7ea 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicModuleParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicModuleParser.java @@ -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; diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicOldExpressionParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicOldExpressionParser.java index 36b4d4472c78..547dfac8f1b5 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicOldExpressionParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicOldExpressionParser.java @@ -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 diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicPrattExpressionParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicPrattExpressionParser.java index f7b975ee3a42..0616e1c62f70 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicPrattExpressionParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicPrattExpressionParser.java @@ -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)); diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicReferenceParser.java b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicReferenceParser.java index 00b7aff201ec..0a9903f6f9a5 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicReferenceParser.java +++ b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/BasicReferenceParser.java @@ -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))) { diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java index 1c7791d85a7c..7cf17462a616 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java @@ -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); diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaAstTreeUtil.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaAstTreeUtil.java index 7769f4e364e3..6a91722ee557 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaAstTreeUtil.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaAstTreeUtil.java @@ -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 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 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 diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java index edd9054852aa..156f0e821f67 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java @@ -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); diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java index 388cd6c5f9d0..3dcdb2e5e53e 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java @@ -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 { diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaTokenSet.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaTokenSet.java deleted file mode 100644 index 4d1d9594320e..000000000000 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaTokenSet.java +++ /dev/null @@ -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 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); - } -} diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/WhiteSpaceAndCommentSetHolder.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/WhiteSpaceAndCommentSetHolder.java index 6a9639b5388c..df295b1b2957 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/WhiteSpaceAndCommentSetHolder.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/WhiteSpaceAndCommentSetHolder.java @@ -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; } diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java index 6ec2c676f36a..0b4544a78bf3 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/ElementType.java @@ -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; diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaDocElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaDocElementType.java index 73858fc2cdf7..cb4d5ca70940 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaDocElementType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaDocElementType.java @@ -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); } \ No newline at end of file diff --git a/platform/core-api/src/com/intellij/psi/tree/ParentAwareTokenSet.java b/platform/core-api/src/com/intellij/psi/tree/ParentAwareTokenSet.java new file mode 100644 index 000000000000..79ff9570ad94 --- /dev/null +++ b/platform/core-api/src/com/intellij/psi/tree/ParentAwareTokenSet.java @@ -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 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); + } +} diff --git a/platform/core-api/src/com/intellij/psi/tree/ParentProviderElementType.java b/platform/core-api/src/com/intellij/psi/tree/ParentProviderElementType.java index 7e08bf5f681b..f1f6f9953efb 100644 --- a/platform/core-api/src/com/intellij/psi/tree/ParentProviderElementType.java +++ b/platform/core-api/src/com/intellij/psi/tree/ParentProviderElementType.java @@ -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 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 parents = ((ParentProviderElementType)source).getParents(); + return ContainerUtil.exists(parents, parent -> parent != null && + containsWithSourceParent(parent, tokenSet)); + } + return false; + } } \ No newline at end of file