From bf2249537708bb1dda54c5f59f2cc4f81a1f0b9a Mon Sep 17 00:00:00 2001 From: Mikhail Pyltsin Date: Fri, 14 Nov 2025 16:04:58 +0100 Subject: [PATCH] [java] IDEA-365317 delete JavaBinaryOperations and BasicJavaElementTypeConverter GitOrigin-RevId: afa1d288c6a36788a07226e34528415ee0fa7200 --- .../expression/EvaluatorBuilderImpl.java | 4 +- .../PointlessBitwiseExpressionInspection.java | 8 +- .../ig/bitwise/ShiftOutOfRangeInspection.java | 4 +- ...plicationImplicitCastToLongInspection.java | 4 +- ...ecessaryExplicitNumericCastInspection.java | 4 +- .../siyeh/ig/psiutils/ExpectedTypeUtils.java | 4 +- .../editorActions/JavaTypingTokenSets.java | 6 +- .../java/JavaSpacePropertyProcessor.java | 7 +- .../syntax/BasicJavaElementTypeConverter.kt | 301 ------------------ .../lang/java/parser/JavaBinaryOperations.kt | 17 - .../psi/impl/source/tree/ElementType.java | 61 +++- .../java/PsiAssignmentExpressionImpl.java | 3 +- .../tree/java/ReplaceExpressionUtil.java | 35 +- .../java/syntax/element/SyntaxElementTypes.kt | 14 + .../java/syntax/parser/ExpressionParser.kt | 16 - 15 files changed, 98 insertions(+), 390 deletions(-) delete mode 100644 java/java-frontback-psi-impl/src/com/intellij/java/frontback/psi/impl/syntax/BasicJavaElementTypeConverter.kt delete mode 100644 java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/JavaBinaryOperations.kt diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java index b7b7a440b210..736ab6d37486 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/evaluation/expression/EvaluatorBuilderImpl.java @@ -21,7 +21,6 @@ import com.intellij.ide.highlighter.JavaFileType; import com.intellij.java.codeserver.highlighting.JavaErrorCollector; import com.intellij.java.codeserver.highlighting.errors.JavaCompilationError; import com.intellij.java.codeserver.highlighting.errors.JavaErrorKinds; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.lang.jvm.JvmModifier; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.project.Project; @@ -29,6 +28,7 @@ import com.intellij.openapi.util.registry.Registry; import com.intellij.openapi.util.text.StringUtil; import com.intellij.psi.*; import com.intellij.psi.impl.JavaConstantExpressionEvaluator; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.*; import com.intellij.refactoring.extractMethodObject.LightMethodObjectExtractedData; @@ -634,7 +634,7 @@ public final class EvaluatorBuilderImpl implements EvaluatorBuilder { } } // unary numeric promotion if applicable - else if (JavaBinaryOperations.SHIFT_OPS.contains(operation)) { + else if (ElementType.SHIFT_OPS.contains(operation)) { lResult = handleUnaryNumericPromotion(lType, lResult); rResult = handleUnaryNumericPromotion(rType, rResult); } diff --git a/java/java-analysis-impl/src/com/siyeh/ig/bitwise/PointlessBitwiseExpressionInspection.java b/java/java-analysis-impl/src/com/siyeh/ig/bitwise/PointlessBitwiseExpressionInspection.java index 02c3e41d549e..a637dfd2797c 100644 --- a/java/java-analysis-impl/src/com/siyeh/ig/bitwise/PointlessBitwiseExpressionInspection.java +++ b/java/java-analysis-impl/src/com/siyeh/ig/bitwise/PointlessBitwiseExpressionInspection.java @@ -17,11 +17,11 @@ package com.siyeh.ig.bitwise; import com.intellij.codeInspection.LocalQuickFix; import com.intellij.codeInspection.options.OptPane; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.modcommand.ModPsiUpdater; import com.intellij.modcommand.PsiUpdateModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.psi.*; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import com.intellij.psi.util.ConstantExpressionUtil; @@ -93,11 +93,11 @@ public final class PointlessBitwiseExpressionInspection extends BaseInspection { for (int i = 0, length = operands.length; i < length; i++) { final PsiExpression operand = operands[i]; if (isZero(operand)) { - if (tokenType.equals(AND) || JavaBinaryOperations.SHIFT_OPS.contains(tokenType) && previousOperand == null) { + if (tokenType.equals(AND) || ElementType.SHIFT_OPS.contains(tokenType) && previousOperand == null) { return getText(expression, operands[0], operands[length - 1], PsiTypes.longType().equals(expression.getType()) ? "0L" : "0", ct); } else if (tokenType.equals(OR) || tokenType.equals(XOR) || - JavaBinaryOperations.SHIFT_OPS.contains(tokenType) && previousOperand != null) { + ElementType.SHIFT_OPS.contains(tokenType) && previousOperand != null) { return getText(expression, i == length - 1 ? expression.getTokenBeforeOperand(operand) : operand, ct); } } @@ -261,7 +261,7 @@ public final class PointlessBitwiseExpressionInspection extends BaseInspection { if (sign.equals(AND) || sign.equals(OR) || sign.equals(XOR)) { isPointless = booleanExpressionIsPointless(operands); } - else if (JavaBinaryOperations.SHIFT_OPS.contains(sign)) { + else if (ElementType.SHIFT_OPS.contains(sign)) { isPointless = shiftExpressionIsPointless(operands); } else { diff --git a/java/java-analysis-impl/src/com/siyeh/ig/bitwise/ShiftOutOfRangeInspection.java b/java/java-analysis-impl/src/com/siyeh/ig/bitwise/ShiftOutOfRangeInspection.java index 0593413cdf40..58c29df1806f 100644 --- a/java/java-analysis-impl/src/com/siyeh/ig/bitwise/ShiftOutOfRangeInspection.java +++ b/java/java-analysis-impl/src/com/siyeh/ig/bitwise/ShiftOutOfRangeInspection.java @@ -19,11 +19,11 @@ import com.intellij.codeInspection.CommonQuickFixBundle; import com.intellij.codeInspection.LocalQuickFix; import com.intellij.codeInspection.dataFlow.CommonDataflow; import com.intellij.codeInspection.dataFlow.rangeSet.LongRangeSet; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.modcommand.ModPsiUpdater; import com.intellij.modcommand.PsiUpdateModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.psi.*; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.IElementType; import com.intellij.util.ObjectUtils; import com.siyeh.InspectionGadgetsBundle; @@ -108,7 +108,7 @@ public final class ShiftOutOfRangeInspection extends BaseInspection { super.visitBinaryExpression(expression); final PsiJavaToken sign = expression.getOperationSign(); final IElementType tokenType = sign.getTokenType(); - if (!JavaBinaryOperations.SHIFT_OPS.contains(tokenType)) return; + if (!ElementType.SHIFT_OPS.contains(tokenType)) return; final PsiExpression rhs = expression.getROperand(); if (rhs == null) return; final PsiType expressionType = expression.getType(); diff --git a/java/java-analysis-impl/src/com/siyeh/ig/numeric/IntegerMultiplicationImplicitCastToLongInspection.java b/java/java-analysis-impl/src/com/siyeh/ig/numeric/IntegerMultiplicationImplicitCastToLongInspection.java index 9afe1fcb6448..208becc25cf6 100644 --- a/java/java-analysis-impl/src/com/siyeh/ig/numeric/IntegerMultiplicationImplicitCastToLongInspection.java +++ b/java/java-analysis-impl/src/com/siyeh/ig/numeric/IntegerMultiplicationImplicitCastToLongInspection.java @@ -24,11 +24,11 @@ import com.intellij.codeInspection.dataFlow.types.DfLongType; import com.intellij.codeInspection.dataFlow.types.DfReferenceType; import com.intellij.codeInspection.dataFlow.types.DfType; import com.intellij.codeInspection.options.OptPane; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.modcommand.ModPsiUpdater; import com.intellij.modcommand.PsiUpdateModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.psi.*; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.ConstantEvaluationOverflowException; import com.intellij.psi.util.PsiTreeUtil; @@ -147,7 +147,7 @@ public final class IntegerMultiplicationImplicitCastToLongInspection extends Bas } private static boolean isShiftToken(IElementType tokenType) { - return JavaBinaryOperations.SHIFT_OPS.contains(tokenType); + return ElementType.SHIFT_OPS.contains(tokenType); } private static boolean isShiftEqToken(@NotNull IElementType tokenType) { diff --git a/java/java-analysis-impl/src/com/siyeh/ig/numeric/UnnecessaryExplicitNumericCastInspection.java b/java/java-analysis-impl/src/com/siyeh/ig/numeric/UnnecessaryExplicitNumericCastInspection.java index 909ed0237fcd..2f0456b4ae72 100644 --- a/java/java-analysis-impl/src/com/siyeh/ig/numeric/UnnecessaryExplicitNumericCastInspection.java +++ b/java/java-analysis-impl/src/com/siyeh/ig/numeric/UnnecessaryExplicitNumericCastInspection.java @@ -3,11 +3,11 @@ package com.siyeh.ig.numeric; import com.intellij.codeInspection.CleanupLocalInspectionTool; import com.intellij.codeInspection.LocalQuickFix; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.modcommand.ModPsiUpdater; import com.intellij.modcommand.PsiUpdateModCommandQuickFix; import com.intellij.openapi.project.Project; import com.intellij.psi.*; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import com.intellij.psi.util.PsiTreeUtil; @@ -171,7 +171,7 @@ public final class UnnecessaryExplicitNumericCastInspection extends BaseInspecti } } } - else if (JavaBinaryOperations.SHIFT_OPS.contains(tokenType)) { + else if (ElementType.SHIFT_OPS.contains(tokenType)) { final PsiExpression firstOperand = polyadicExpression.getOperands()[0]; if (!PsiTreeUtil.isAncestor(firstOperand, expression, false)) { return true; diff --git a/java/java-analysis-impl/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java b/java/java-analysis-impl/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java index b90c1217cd0b..96483066504b 100644 --- a/java/java-analysis-impl/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java +++ b/java/java-analysis-impl/src/com/siyeh/ig/psiutils/ExpectedTypeUtils.java @@ -16,9 +16,9 @@ package com.siyeh.ig.psiutils; import com.intellij.codeInsight.ExceptionUtil; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.openapi.project.Project; import com.intellij.psi.*; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.infos.MethodCandidateInfo; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; @@ -605,7 +605,7 @@ public final class ExpectedTypeUtils { } private static boolean isShiftOperation(@NotNull IElementType sign) { - return JavaBinaryOperations.SHIFT_OPS.contains(sign); + return ElementType.SHIFT_OPS.contains(sign); } private static boolean isOperatorAssignmentOperation(@NotNull IElementType sign) { diff --git a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaTypingTokenSets.java b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaTypingTokenSets.java index 17808f3af74e..e1c53901d25e 100644 --- a/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaTypingTokenSets.java +++ b/java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/JavaTypingTokenSets.java @@ -1,8 +1,8 @@ // 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.codeInsight.editorActions; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.psi.JavaTokenType; +import com.intellij.psi.impl.source.tree.ElementType; import com.intellij.psi.tree.TokenSet; public final class JavaTypingTokenSets { @@ -16,11 +16,11 @@ public final class JavaTypingTokenSets { JavaTokenType.STRING_LITERAL, JavaTokenType.TEXT_BLOCK_LITERAL); public static final TokenSet UNWANTED_TOKEN_BEFORE_QUESTION = - TokenSet.orSet(JavaBinaryOperations.ASSIGNMENT_OPS, TokenSet.create(JavaTokenType.QUEST, JavaTokenType.COLON)); + TokenSet.orSet(ElementType.ASSIGNMENT_OPS, TokenSet.create(JavaTokenType.QUEST, JavaTokenType.COLON)); public static final TokenSet WANTED_TOKEN_BEFORE_QUESTION = // Tokens that may appear before ?: in polyadic expression that may have non-boolean result TokenSet.orSet( TokenSet.create(JavaTokenType.OR, JavaTokenType.XOR, JavaTokenType.AND), - JavaBinaryOperations.SHIFT_OPS, JavaBinaryOperations.ADDITIVE_OPS, JavaBinaryOperations.MULTIPLICATIVE_OPS); + ElementType.SHIFT_OPS, ElementType.ADDITIVE_OPS, ElementType.MULTIPLICATIVE_OPS); } diff --git a/java/java-frontback-impl/src/com/intellij/psi/formatter/java/JavaSpacePropertyProcessor.java b/java/java-frontback-impl/src/com/intellij/psi/formatter/java/JavaSpacePropertyProcessor.java index aa30fd66e6ec..e601595ef762 100644 --- a/java/java-frontback-impl/src/com/intellij/psi/formatter/java/JavaSpacePropertyProcessor.java +++ b/java/java-frontback-impl/src/com/intellij/psi/formatter/java/JavaSpacePropertyProcessor.java @@ -6,7 +6,6 @@ import com.intellij.formatting.Spacing; import com.intellij.lang.ASTNode; import com.intellij.lang.java.JavaLanguage; import com.intellij.lang.java.JavaParserDefinition; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.lexer.Lexer; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; @@ -1109,13 +1108,13 @@ public final class JavaSpacePropertyProcessor extends JavaElementVisitor { else if (i == JavaTokenType.GT || i == JavaTokenType.LT || i == JavaTokenType.GE || i == JavaTokenType.LE) { createSpaceInCode(mySettings.SPACE_AROUND_RELATIONAL_OPERATORS); } - else if (JavaBinaryOperations.ADDITIVE_OPS.contains(i)) { + else if (ElementType.ADDITIVE_OPS.contains(i)) { createSpaceInCode(mySettings.SPACE_AROUND_ADDITIVE_OPERATORS); } - else if (JavaBinaryOperations.MULTIPLICATIVE_OPS.contains(i)) { + else if (ElementType.MULTIPLICATIVE_OPS.contains(i)) { createSpaceInCode(mySettings.SPACE_AROUND_MULTIPLICATIVE_OPERATORS); } - else if (JavaBinaryOperations.SHIFT_OPS.contains(i)) { + else if (ElementType.SHIFT_OPS.contains(i)) { createSpaceInCode(mySettings.SPACE_AROUND_SHIFT_OPERATORS); } else { diff --git a/java/java-frontback-psi-impl/src/com/intellij/java/frontback/psi/impl/syntax/BasicJavaElementTypeConverter.kt b/java/java-frontback-psi-impl/src/com/intellij/java/frontback/psi/impl/syntax/BasicJavaElementTypeConverter.kt deleted file mode 100644 index 3f2f1854ef2b..000000000000 --- a/java/java-frontback-psi-impl/src/com/intellij/java/frontback/psi/impl/syntax/BasicJavaElementTypeConverter.kt +++ /dev/null @@ -1,301 +0,0 @@ -// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -package com.intellij.java.frontback.psi.impl.syntax - -import com.intellij.java.syntax.element.JavaDocSyntaxElementType -import com.intellij.java.syntax.element.JavaSyntaxElementType -import com.intellij.java.syntax.element.JavaSyntaxTokenType -import com.intellij.platform.syntax.element.SyntaxTokenTypes -import com.intellij.platform.syntax.psi.ElementTypeConverter -import com.intellij.platform.syntax.psi.elementTypeConverterOf -import com.intellij.psi.JavaTokenType -import com.intellij.psi.TokenType -import com.intellij.psi.impl.source.BasicJavaDocElementType -import com.intellij.psi.impl.source.BasicJavaElementType -import org.jetbrains.annotations.ApiStatus - -// todo this converter misses some declaration. Please get rid of it as soon as possible -@ApiStatus.Internal -val BasicJavaElementTypeConverter: ElementTypeConverter = elementTypeConverterOf( - // todo move elsewhere - SyntaxTokenTypes.ERROR_ELEMENT to TokenType.ERROR_ELEMENT, - SyntaxTokenTypes.WHITE_SPACE to TokenType.WHITE_SPACE, - SyntaxTokenTypes.BAD_CHARACTER to TokenType.BAD_CHARACTER, - - // these element types are available only in java-frontend module - // JavaSyntaxElementType.JAVA_FILE to FrontendJavaParserDefinition.FILE_ELEMENT_TYPE, - JavaSyntaxElementType.CLASS to BasicJavaElementType.BASIC_CLASS, - JavaSyntaxElementType.IMPLICIT_CLASS to BasicJavaElementType.BASIC_IMPLICIT_CLASS, - JavaSyntaxElementType.ANONYMOUS_CLASS to BasicJavaElementType.BASIC_ANONYMOUS_CLASS, - JavaSyntaxElementType.ENUM_CONSTANT_INITIALIZER to BasicJavaElementType.BASIC_ENUM_CONSTANT_INITIALIZER, - JavaSyntaxElementType.TYPE_PARAMETER_LIST to BasicJavaElementType.BASIC_TYPE_PARAMETER_LIST, - JavaSyntaxElementType.TYPE_PARAMETER to BasicJavaElementType.BASIC_TYPE_PARAMETER, - JavaSyntaxElementType.IMPORT_LIST to BasicJavaElementType.BASIC_IMPORT_LIST, - JavaSyntaxElementType.IMPORT_STATEMENT to BasicJavaElementType.BASIC_IMPORT_STATEMENT, - JavaSyntaxElementType.IMPORT_STATIC_STATEMENT to BasicJavaElementType.BASIC_IMPORT_STATIC_STATEMENT, - JavaSyntaxElementType.IMPORT_MODULE_STATEMENT to BasicJavaElementType.BASIC_IMPORT_MODULE_STATEMENT, - JavaSyntaxElementType.MODIFIER_LIST to BasicJavaElementType.BASIC_MODIFIER_LIST, - JavaSyntaxElementType.ANNOTATION to BasicJavaElementType.BASIC_ANNOTATION, - JavaSyntaxElementType.NAME_VALUE_PAIR to BasicJavaElementType.BASIC_NAME_VALUE_PAIR, - JavaSyntaxElementType.LITERAL_EXPRESSION to BasicJavaElementType.BASIC_LITERAL_EXPRESSION, - JavaSyntaxElementType.ANNOTATION_PARAMETER_LIST to BasicJavaElementType.BASIC_ANNOTATION_PARAMETER_LIST, - JavaSyntaxElementType.EXTENDS_LIST to BasicJavaElementType.BASIC_EXTENDS_LIST, - JavaSyntaxElementType.IMPLEMENTS_LIST to BasicJavaElementType.BASIC_IMPLEMENTS_LIST, - JavaSyntaxElementType.FIELD to BasicJavaElementType.BASIC_FIELD, - JavaSyntaxElementType.ENUM_CONSTANT to BasicJavaElementType.BASIC_ENUM_CONSTANT, - JavaSyntaxElementType.METHOD to BasicJavaElementType.BASIC_METHOD, - JavaSyntaxElementType.ANNOTATION_METHOD to BasicJavaElementType.BASIC_ANNOTATION_METHOD, - JavaSyntaxElementType.CLASS_INITIALIZER to BasicJavaElementType.BASIC_CLASS_INITIALIZER, - JavaSyntaxElementType.PARAMETER to BasicJavaElementType.BASIC_PARAMETER, - JavaSyntaxElementType.PARAMETER_LIST to BasicJavaElementType.BASIC_PARAMETER_LIST, - JavaSyntaxElementType.EXTENDS_BOUND_LIST to BasicJavaElementType.BASIC_EXTENDS_BOUND_LIST, - JavaSyntaxElementType.THROWS_LIST to BasicJavaElementType.BASIC_THROWS_LIST, - JavaSyntaxElementType.LAMBDA_EXPRESSION to BasicJavaElementType.BASIC_LAMBDA_EXPRESSION, - JavaSyntaxElementType.METHOD_REF_EXPRESSION to BasicJavaElementType.BASIC_METHOD_REF_EXPRESSION, - JavaSyntaxElementType.MODULE to BasicJavaElementType.BASIC_MODULE, - JavaSyntaxElementType.REQUIRES_STATEMENT to BasicJavaElementType.BASIC_REQUIRES_STATEMENT, - JavaSyntaxElementType.EXPORTS_STATEMENT to BasicJavaElementType.BASIC_EXPORTS_STATEMENT, - JavaSyntaxElementType.OPENS_STATEMENT to BasicJavaElementType.BASIC_OPENS_STATEMENT, - JavaSyntaxElementType.USES_STATEMENT to BasicJavaElementType.BASIC_USES_STATEMENT, - JavaSyntaxElementType.PROVIDES_STATEMENT to BasicJavaElementType.BASIC_PROVIDES_STATEMENT, - JavaSyntaxElementType.PROVIDES_WITH_LIST to BasicJavaElementType.BASIC_PROVIDES_WITH_LIST, - JavaSyntaxElementType.RECORD_COMPONENT to BasicJavaElementType.BASIC_RECORD_COMPONENT, - JavaSyntaxElementType.RECORD_HEADER to BasicJavaElementType.BASIC_RECORD_HEADER, - JavaSyntaxElementType.PERMITS_LIST to BasicJavaElementType.BASIC_PERMITS_LIST, - JavaSyntaxElementType.IMPORT_STATIC_REFERENCE to BasicJavaElementType.BASIC_IMPORT_STATIC_REFERENCE, - JavaSyntaxElementType.TYPE to BasicJavaElementType.BASIC_TYPE, - JavaSyntaxElementType.DIAMOND_TYPE to BasicJavaElementType.BASIC_DIAMOND_TYPE, - JavaSyntaxElementType.REFERENCE_PARAMETER_LIST to BasicJavaElementType.BASIC_REFERENCE_PARAMETER_LIST, - JavaSyntaxElementType.JAVA_CODE_REFERENCE to BasicJavaElementType.BASIC_JAVA_CODE_REFERENCE, - JavaSyntaxElementType.PACKAGE_STATEMENT to BasicJavaElementType.BASIC_PACKAGE_STATEMENT, - JavaSyntaxElementType.LOCAL_VARIABLE to BasicJavaElementType.BASIC_LOCAL_VARIABLE, - JavaSyntaxElementType.REFERENCE_EXPRESSION to BasicJavaElementType.BASIC_REFERENCE_EXPRESSION, - JavaSyntaxElementType.THIS_EXPRESSION to BasicJavaElementType.BASIC_THIS_EXPRESSION, - JavaSyntaxElementType.SUPER_EXPRESSION to BasicJavaElementType.BASIC_SUPER_EXPRESSION, - JavaSyntaxElementType.PARENTH_EXPRESSION to BasicJavaElementType.BASIC_PARENTH_EXPRESSION, - JavaSyntaxElementType.METHOD_CALL_EXPRESSION to BasicJavaElementType.BASIC_METHOD_CALL_EXPRESSION, - JavaSyntaxElementType.TYPE_CAST_EXPRESSION to BasicJavaElementType.BASIC_TYPE_CAST_EXPRESSION, - JavaSyntaxElementType.PREFIX_EXPRESSION to BasicJavaElementType.BASIC_PREFIX_EXPRESSION, - JavaSyntaxElementType.POSTFIX_EXPRESSION to BasicJavaElementType.BASIC_POSTFIX_EXPRESSION, - JavaSyntaxElementType.BINARY_EXPRESSION to BasicJavaElementType.BASIC_BINARY_EXPRESSION, - JavaSyntaxElementType.POLYADIC_EXPRESSION to BasicJavaElementType.BASIC_POLYADIC_EXPRESSION, - JavaSyntaxElementType.CONDITIONAL_EXPRESSION to BasicJavaElementType.BASIC_CONDITIONAL_EXPRESSION, - JavaSyntaxElementType.ASSIGNMENT_EXPRESSION to BasicJavaElementType.BASIC_ASSIGNMENT_EXPRESSION, - JavaSyntaxElementType.NEW_EXPRESSION to BasicJavaElementType.BASIC_NEW_EXPRESSION, - JavaSyntaxElementType.ARRAY_ACCESS_EXPRESSION to BasicJavaElementType.BASIC_ARRAY_ACCESS_EXPRESSION, - JavaSyntaxElementType.ARRAY_INITIALIZER_EXPRESSION to BasicJavaElementType.BASIC_ARRAY_INITIALIZER_EXPRESSION, - JavaSyntaxElementType.INSTANCE_OF_EXPRESSION to BasicJavaElementType.BASIC_INSTANCE_OF_EXPRESSION, - JavaSyntaxElementType.CLASS_OBJECT_ACCESS_EXPRESSION to BasicJavaElementType.BASIC_CLASS_OBJECT_ACCESS_EXPRESSION, - JavaSyntaxElementType.TEMPLATE_EXPRESSION to BasicJavaElementType.BASIC_TEMPLATE_EXPRESSION, - JavaSyntaxElementType.TEMPLATE to BasicJavaElementType.BASIC_TEMPLATE, - JavaSyntaxElementType.EMPTY_EXPRESSION to BasicJavaElementType.BASIC_EMPTY_EXPRESSION, - JavaSyntaxElementType.EXPRESSION_LIST to BasicJavaElementType.BASIC_EXPRESSION_LIST, - JavaSyntaxElementType.EMPTY_STATEMENT to BasicJavaElementType.BASIC_EMPTY_STATEMENT, - JavaSyntaxElementType.BLOCK_STATEMENT to BasicJavaElementType.BASIC_BLOCK_STATEMENT, - JavaSyntaxElementType.EXPRESSION_STATEMENT to BasicJavaElementType.BASIC_EXPRESSION_STATEMENT, - JavaSyntaxElementType.EXPRESSION_LIST_STATEMENT to BasicJavaElementType.BASIC_EXPRESSION_LIST_STATEMENT, - JavaSyntaxElementType.DECLARATION_STATEMENT to BasicJavaElementType.BASIC_DECLARATION_STATEMENT, - JavaSyntaxElementType.IF_STATEMENT to BasicJavaElementType.BASIC_IF_STATEMENT, - JavaSyntaxElementType.WHILE_STATEMENT to BasicJavaElementType.BASIC_WHILE_STATEMENT, - JavaSyntaxElementType.FOR_STATEMENT to BasicJavaElementType.BASIC_FOR_STATEMENT, - JavaSyntaxElementType.FOREACH_STATEMENT to BasicJavaElementType.BASIC_FOREACH_STATEMENT, - JavaSyntaxElementType.FOREACH_PATTERN_STATEMENT to BasicJavaElementType.BASIC_FOREACH_PATTERN_STATEMENT, - JavaSyntaxElementType.DO_WHILE_STATEMENT to BasicJavaElementType.BASIC_DO_WHILE_STATEMENT, - JavaSyntaxElementType.SWITCH_STATEMENT to BasicJavaElementType.BASIC_SWITCH_STATEMENT, - JavaSyntaxElementType.SWITCH_EXPRESSION to BasicJavaElementType.BASIC_SWITCH_EXPRESSION, - JavaSyntaxElementType.SWITCH_LABEL_STATEMENT to BasicJavaElementType.BASIC_SWITCH_LABEL_STATEMENT, - JavaSyntaxElementType.SWITCH_LABELED_RULE to BasicJavaElementType.BASIC_SWITCH_LABELED_RULE, - JavaSyntaxElementType.BREAK_STATEMENT to BasicJavaElementType.BASIC_BREAK_STATEMENT, - JavaSyntaxElementType.YIELD_STATEMENT to BasicJavaElementType.BASIC_YIELD_STATEMENT, - JavaSyntaxElementType.CONTINUE_STATEMENT to BasicJavaElementType.BASIC_CONTINUE_STATEMENT, - JavaSyntaxElementType.RETURN_STATEMENT to BasicJavaElementType.BASIC_RETURN_STATEMENT, - JavaSyntaxElementType.THROW_STATEMENT to BasicJavaElementType.BASIC_THROW_STATEMENT, - JavaSyntaxElementType.SYNCHRONIZED_STATEMENT to BasicJavaElementType.BASIC_SYNCHRONIZED_STATEMENT, - JavaSyntaxElementType.TRY_STATEMENT to BasicJavaElementType.BASIC_TRY_STATEMENT, - JavaSyntaxElementType.RESOURCE_LIST to BasicJavaElementType.BASIC_RESOURCE_LIST, - JavaSyntaxElementType.RESOURCE_VARIABLE to BasicJavaElementType.BASIC_RESOURCE_VARIABLE, - JavaSyntaxElementType.RESOURCE_EXPRESSION to BasicJavaElementType.BASIC_RESOURCE_EXPRESSION, - JavaSyntaxElementType.CATCH_SECTION to BasicJavaElementType.BASIC_CATCH_SECTION, - JavaSyntaxElementType.LABELED_STATEMENT to BasicJavaElementType.BASIC_LABELED_STATEMENT, - JavaSyntaxElementType.ASSERT_STATEMENT to BasicJavaElementType.BASIC_ASSERT_STATEMENT, - JavaSyntaxElementType.ANNOTATION_ARRAY_INITIALIZER to BasicJavaElementType.BASIC_ANNOTATION_ARRAY_INITIALIZER, - JavaSyntaxElementType.RECEIVER_PARAMETER to BasicJavaElementType.BASIC_RECEIVER_PARAMETER, - JavaSyntaxElementType.MODULE_REFERENCE to BasicJavaElementType.BASIC_MODULE_REFERENCE, - JavaSyntaxElementType.TYPE_TEST_PATTERN to BasicJavaElementType.BASIC_TYPE_TEST_PATTERN, - JavaSyntaxElementType.UNNAMED_PATTERN to BasicJavaElementType.BASIC_UNNAMED_PATTERN, - JavaSyntaxElementType.PATTERN_VARIABLE to BasicJavaElementType.BASIC_PATTERN_VARIABLE, - JavaSyntaxElementType.DECONSTRUCTION_PATTERN to BasicJavaElementType.BASIC_DECONSTRUCTION_PATTERN, - JavaSyntaxElementType.DECONSTRUCTION_LIST to BasicJavaElementType.BASIC_DECONSTRUCTION_LIST, - JavaSyntaxElementType.DECONSTRUCTION_PATTERN_VARIABLE to BasicJavaElementType.BASIC_DECONSTRUCTION_PATTERN_VARIABLE, - JavaSyntaxElementType.DEFAULT_CASE_LABEL_ELEMENT to BasicJavaElementType.BASIC_DEFAULT_CASE_LABEL_ELEMENT, - JavaSyntaxElementType.CASE_LABEL_ELEMENT_LIST to BasicJavaElementType.BASIC_CASE_LABEL_ELEMENT_LIST, - - // these element types are available only in java-frontend module - //JavaSyntaxElementType.CODE_BLOCK to FrontendJavaElementType.CODE_BLOCK, - //JavaSyntaxElementType.MEMBERS to FrontendJavaElementType.MEMBERS, - //JavaSyntaxElementType.STATEMENTS to FrontendJavaElementType.STATEMENTS, - //JavaSyntaxElementType.EXPRESSION_TEXT to FrontendJavaElementType.EXPRESSION_TEXT, - //JavaSyntaxElementType.REFERENCE_TEXT to FrontendJavaElementType.REFERENCE_TEXT, - //JavaSyntaxElementType.TYPE_WITH_DISJUNCTIONS_TEXT to FrontendJavaElementType.TYPE_WITH_DISJUNCTIONS_TEXT, - //JavaSyntaxElementType.TYPE_WITH_CONJUNCTIONS_TEXT to FrontendJavaElementType.TYPE_WITH_CONJUNCTIONS_TEXT, - //JavaSyntaxElementType.DUMMY_ELEMENT to FrontendJavaElementType.DUMMY_ELEMENT, - - - JavaSyntaxTokenType.IDENTIFIER to JavaTokenType.IDENTIFIER, - JavaSyntaxTokenType.C_STYLE_COMMENT to JavaTokenType.C_STYLE_COMMENT, - JavaSyntaxTokenType.END_OF_LINE_COMMENT to JavaTokenType.END_OF_LINE_COMMENT, - JavaSyntaxTokenType.INTEGER_LITERAL to JavaTokenType.INTEGER_LITERAL, - JavaSyntaxTokenType.LONG_LITERAL to JavaTokenType.LONG_LITERAL, - JavaSyntaxTokenType.FLOAT_LITERAL to JavaTokenType.FLOAT_LITERAL, - JavaSyntaxTokenType.DOUBLE_LITERAL to JavaTokenType.DOUBLE_LITERAL, - JavaSyntaxTokenType.CHARACTER_LITERAL to JavaTokenType.CHARACTER_LITERAL, - JavaSyntaxTokenType.STRING_LITERAL to JavaTokenType.STRING_LITERAL, - JavaSyntaxTokenType.TEXT_BLOCK_LITERAL to JavaTokenType.TEXT_BLOCK_LITERAL, - JavaSyntaxTokenType.STRING_TEMPLATE_BEGIN to JavaTokenType.STRING_TEMPLATE_BEGIN, - JavaSyntaxTokenType.STRING_TEMPLATE_MID to JavaTokenType.STRING_TEMPLATE_MID, - JavaSyntaxTokenType.STRING_TEMPLATE_END to JavaTokenType.STRING_TEMPLATE_END, - JavaSyntaxTokenType.TEXT_BLOCK_TEMPLATE_BEGIN to JavaTokenType.TEXT_BLOCK_TEMPLATE_BEGIN, - JavaSyntaxTokenType.TEXT_BLOCK_TEMPLATE_MID to JavaTokenType.TEXT_BLOCK_TEMPLATE_MID, - JavaSyntaxTokenType.TEXT_BLOCK_TEMPLATE_END to JavaTokenType.TEXT_BLOCK_TEMPLATE_END, - JavaSyntaxTokenType.TRUE_KEYWORD to JavaTokenType.TRUE_KEYWORD, - JavaSyntaxTokenType.FALSE_KEYWORD to JavaTokenType.FALSE_KEYWORD, - JavaSyntaxTokenType.NULL_KEYWORD to JavaTokenType.NULL_KEYWORD, - JavaSyntaxTokenType.ABSTRACT_KEYWORD to JavaTokenType.ABSTRACT_KEYWORD, - JavaSyntaxTokenType.ASSERT_KEYWORD to JavaTokenType.ASSERT_KEYWORD, - JavaSyntaxTokenType.BOOLEAN_KEYWORD to JavaTokenType.BOOLEAN_KEYWORD, - JavaSyntaxTokenType.BREAK_KEYWORD to JavaTokenType.BREAK_KEYWORD, - JavaSyntaxTokenType.BYTE_KEYWORD to JavaTokenType.BYTE_KEYWORD, - JavaSyntaxTokenType.CASE_KEYWORD to JavaTokenType.CASE_KEYWORD, - JavaSyntaxTokenType.CATCH_KEYWORD to JavaTokenType.CATCH_KEYWORD, - JavaSyntaxTokenType.CHAR_KEYWORD to JavaTokenType.CHAR_KEYWORD, - JavaSyntaxTokenType.CLASS_KEYWORD to JavaTokenType.CLASS_KEYWORD, - JavaSyntaxTokenType.CONST_KEYWORD to JavaTokenType.CONST_KEYWORD, - JavaSyntaxTokenType.CONTINUE_KEYWORD to JavaTokenType.CONTINUE_KEYWORD, - JavaSyntaxTokenType.DEFAULT_KEYWORD to JavaTokenType.DEFAULT_KEYWORD, - JavaSyntaxTokenType.DO_KEYWORD to JavaTokenType.DO_KEYWORD, - JavaSyntaxTokenType.DOUBLE_KEYWORD to JavaTokenType.DOUBLE_KEYWORD, - JavaSyntaxTokenType.ELSE_KEYWORD to JavaTokenType.ELSE_KEYWORD, - JavaSyntaxTokenType.ENUM_KEYWORD to JavaTokenType.ENUM_KEYWORD, - JavaSyntaxTokenType.EXTENDS_KEYWORD to JavaTokenType.EXTENDS_KEYWORD, - JavaSyntaxTokenType.FINAL_KEYWORD to JavaTokenType.FINAL_KEYWORD, - JavaSyntaxTokenType.FINALLY_KEYWORD to JavaTokenType.FINALLY_KEYWORD, - JavaSyntaxTokenType.FLOAT_KEYWORD to JavaTokenType.FLOAT_KEYWORD, - JavaSyntaxTokenType.FOR_KEYWORD to JavaTokenType.FOR_KEYWORD, - JavaSyntaxTokenType.GOTO_KEYWORD to JavaTokenType.GOTO_KEYWORD, - JavaSyntaxTokenType.IF_KEYWORD to JavaTokenType.IF_KEYWORD, - JavaSyntaxTokenType.IMPLEMENTS_KEYWORD to JavaTokenType.IMPLEMENTS_KEYWORD, - JavaSyntaxTokenType.IMPORT_KEYWORD to JavaTokenType.IMPORT_KEYWORD, - JavaSyntaxTokenType.INSTANCEOF_KEYWORD to JavaTokenType.INSTANCEOF_KEYWORD, - JavaSyntaxTokenType.INT_KEYWORD to JavaTokenType.INT_KEYWORD, - JavaSyntaxTokenType.INTERFACE_KEYWORD to JavaTokenType.INTERFACE_KEYWORD, - JavaSyntaxTokenType.LONG_KEYWORD to JavaTokenType.LONG_KEYWORD, - JavaSyntaxTokenType.NATIVE_KEYWORD to JavaTokenType.NATIVE_KEYWORD, - JavaSyntaxTokenType.NEW_KEYWORD to JavaTokenType.NEW_KEYWORD, - JavaSyntaxTokenType.PACKAGE_KEYWORD to JavaTokenType.PACKAGE_KEYWORD, - JavaSyntaxTokenType.PRIVATE_KEYWORD to JavaTokenType.PRIVATE_KEYWORD, - JavaSyntaxTokenType.PUBLIC_KEYWORD to JavaTokenType.PUBLIC_KEYWORD, - JavaSyntaxTokenType.SHORT_KEYWORD to JavaTokenType.SHORT_KEYWORD, - JavaSyntaxTokenType.SUPER_KEYWORD to JavaTokenType.SUPER_KEYWORD, - JavaSyntaxTokenType.SWITCH_KEYWORD to JavaTokenType.SWITCH_KEYWORD, - JavaSyntaxTokenType.SYNCHRONIZED_KEYWORD to JavaTokenType.SYNCHRONIZED_KEYWORD, - JavaSyntaxTokenType.THIS_KEYWORD to JavaTokenType.THIS_KEYWORD, - JavaSyntaxTokenType.THROW_KEYWORD to JavaTokenType.THROW_KEYWORD, - JavaSyntaxTokenType.PROTECTED_KEYWORD to JavaTokenType.PROTECTED_KEYWORD, - JavaSyntaxTokenType.TRANSIENT_KEYWORD to JavaTokenType.TRANSIENT_KEYWORD, - JavaSyntaxTokenType.RETURN_KEYWORD to JavaTokenType.RETURN_KEYWORD, - JavaSyntaxTokenType.VOID_KEYWORD to JavaTokenType.VOID_KEYWORD, - JavaSyntaxTokenType.STATIC_KEYWORD to JavaTokenType.STATIC_KEYWORD, - JavaSyntaxTokenType.STRICTFP_KEYWORD to JavaTokenType.STRICTFP_KEYWORD, - JavaSyntaxTokenType.WHILE_KEYWORD to JavaTokenType.WHILE_KEYWORD, - JavaSyntaxTokenType.TRY_KEYWORD to JavaTokenType.TRY_KEYWORD, - JavaSyntaxTokenType.VOLATILE_KEYWORD to JavaTokenType.VOLATILE_KEYWORD, - JavaSyntaxTokenType.THROWS_KEYWORD to JavaTokenType.THROWS_KEYWORD, - JavaSyntaxTokenType.LPARENTH to JavaTokenType.LPARENTH, - JavaSyntaxTokenType.RPARENTH to JavaTokenType.RPARENTH, - JavaSyntaxTokenType.LBRACE to JavaTokenType.LBRACE, - JavaSyntaxTokenType.RBRACE to JavaTokenType.RBRACE, - JavaSyntaxTokenType.LBRACKET to JavaTokenType.LBRACKET, - JavaSyntaxTokenType.RBRACKET to JavaTokenType.RBRACKET, - JavaSyntaxTokenType.SEMICOLON to JavaTokenType.SEMICOLON, - JavaSyntaxTokenType.COMMA to JavaTokenType.COMMA, - JavaSyntaxTokenType.DOT to JavaTokenType.DOT, - JavaSyntaxTokenType.ELLIPSIS to JavaTokenType.ELLIPSIS, - JavaSyntaxTokenType.AT to JavaTokenType.AT, - JavaSyntaxTokenType.EQ to JavaTokenType.EQ, - JavaSyntaxTokenType.GT to JavaTokenType.GT, - JavaSyntaxTokenType.LT to JavaTokenType.LT, - JavaSyntaxTokenType.EXCL to JavaTokenType.EXCL, - JavaSyntaxTokenType.TILDE to JavaTokenType.TILDE, - JavaSyntaxTokenType.QUEST to JavaTokenType.QUEST, - JavaSyntaxTokenType.COLON to JavaTokenType.COLON, - JavaSyntaxTokenType.PLUS to JavaTokenType.PLUS, - JavaSyntaxTokenType.MINUS to JavaTokenType.MINUS, - JavaSyntaxTokenType.ASTERISK to JavaTokenType.ASTERISK, - JavaSyntaxTokenType.DIV to JavaTokenType.DIV, - JavaSyntaxTokenType.AND to JavaTokenType.AND, - JavaSyntaxTokenType.OR to JavaTokenType.OR, - JavaSyntaxTokenType.XOR to JavaTokenType.XOR, - JavaSyntaxTokenType.PERC to JavaTokenType.PERC, - JavaSyntaxTokenType.EQEQ to JavaTokenType.EQEQ, - JavaSyntaxTokenType.LE to JavaTokenType.LE, - JavaSyntaxTokenType.GE to JavaTokenType.GE, - JavaSyntaxTokenType.NE to JavaTokenType.NE, - JavaSyntaxTokenType.ANDAND to JavaTokenType.ANDAND, - JavaSyntaxTokenType.OROR to JavaTokenType.OROR, - JavaSyntaxTokenType.PLUSPLUS to JavaTokenType.PLUSPLUS, - JavaSyntaxTokenType.MINUSMINUS to JavaTokenType.MINUSMINUS, - JavaSyntaxTokenType.LTLT to JavaTokenType.LTLT, - JavaSyntaxTokenType.GTGT to JavaTokenType.GTGT, - JavaSyntaxTokenType.GTGTGT to JavaTokenType.GTGTGT, - JavaSyntaxTokenType.PLUSEQ to JavaTokenType.PLUSEQ, - JavaSyntaxTokenType.MINUSEQ to JavaTokenType.MINUSEQ, - JavaSyntaxTokenType.ASTERISKEQ to JavaTokenType.ASTERISKEQ, - JavaSyntaxTokenType.DIVEQ to JavaTokenType.DIVEQ, - JavaSyntaxTokenType.ANDEQ to JavaTokenType.ANDEQ, - JavaSyntaxTokenType.OREQ to JavaTokenType.OREQ, - JavaSyntaxTokenType.XOREQ to JavaTokenType.XOREQ, - JavaSyntaxTokenType.PERCEQ to JavaTokenType.PERCEQ, - JavaSyntaxTokenType.LTLTEQ to JavaTokenType.LTLTEQ, - JavaSyntaxTokenType.GTGTEQ to JavaTokenType.GTGTEQ, - JavaSyntaxTokenType.GTGTGTEQ to JavaTokenType.GTGTGTEQ, - JavaSyntaxTokenType.DOUBLE_COLON to JavaTokenType.DOUBLE_COLON, - JavaSyntaxTokenType.ARROW to JavaTokenType.ARROW, - JavaSyntaxTokenType.OPEN_KEYWORD to JavaTokenType.OPEN_KEYWORD, - JavaSyntaxTokenType.MODULE_KEYWORD to JavaTokenType.MODULE_KEYWORD, - JavaSyntaxTokenType.REQUIRES_KEYWORD to JavaTokenType.REQUIRES_KEYWORD, - JavaSyntaxTokenType.EXPORTS_KEYWORD to JavaTokenType.EXPORTS_KEYWORD, - JavaSyntaxTokenType.OPENS_KEYWORD to JavaTokenType.OPENS_KEYWORD, - JavaSyntaxTokenType.USES_KEYWORD to JavaTokenType.USES_KEYWORD, - JavaSyntaxTokenType.PROVIDES_KEYWORD to JavaTokenType.PROVIDES_KEYWORD, - JavaSyntaxTokenType.TRANSITIVE_KEYWORD to JavaTokenType.TRANSITIVE_KEYWORD, - JavaSyntaxTokenType.TO_KEYWORD to JavaTokenType.TO_KEYWORD, - JavaSyntaxTokenType.WITH_KEYWORD to JavaTokenType.WITH_KEYWORD, - JavaSyntaxTokenType.VAR_KEYWORD to JavaTokenType.VAR_KEYWORD, - JavaSyntaxTokenType.YIELD_KEYWORD to JavaTokenType.YIELD_KEYWORD, - JavaSyntaxTokenType.RECORD_KEYWORD to JavaTokenType.RECORD_KEYWORD, - JavaSyntaxTokenType.VALUE_KEYWORD to JavaTokenType.VALUE_KEYWORD, - JavaSyntaxTokenType.SEALED_KEYWORD to JavaTokenType.SEALED_KEYWORD, - JavaSyntaxTokenType.NON_SEALED_KEYWORD to JavaTokenType.NON_SEALED_KEYWORD, - JavaSyntaxTokenType.PERMITS_KEYWORD to JavaTokenType.PERMITS_KEYWORD, - JavaSyntaxTokenType.WHEN_KEYWORD to JavaTokenType.WHEN_KEYWORD, - - JavaDocSyntaxElementType.DOC_TAG to BasicJavaDocElementType.BASIC_DOC_TAG, - JavaDocSyntaxElementType.DOC_INLINE_TAG to BasicJavaDocElementType.BASIC_DOC_INLINE_TAG, - JavaDocSyntaxElementType.DOC_METHOD_OR_FIELD_REF to BasicJavaDocElementType.BASIC_DOC_METHOD_OR_FIELD_REF, - JavaDocSyntaxElementType.DOC_PARAMETER_REF to BasicJavaDocElementType.BASIC_DOC_PARAMETER_REF, - JavaDocSyntaxElementType.DOC_TAG_VALUE_ELEMENT to BasicJavaDocElementType.BASIC_DOC_TAG_VALUE_ELEMENT, - JavaDocSyntaxElementType.DOC_SNIPPET_TAG to BasicJavaDocElementType.BASIC_DOC_SNIPPET_TAG, - JavaDocSyntaxElementType.DOC_SNIPPET_TAG_VALUE to BasicJavaDocElementType.BASIC_DOC_SNIPPET_TAG_VALUE, - JavaDocSyntaxElementType.DOC_SNIPPET_BODY to BasicJavaDocElementType.BASIC_DOC_SNIPPET_BODY, - JavaDocSyntaxElementType.DOC_SNIPPET_ATTRIBUTE to BasicJavaDocElementType.BASIC_DOC_SNIPPET_ATTRIBUTE, - JavaDocSyntaxElementType.DOC_SNIPPET_ATTRIBUTE_LIST to BasicJavaDocElementType.BASIC_DOC_SNIPPET_ATTRIBUTE_LIST, - JavaDocSyntaxElementType.DOC_SNIPPET_ATTRIBUTE_VALUE to BasicJavaDocElementType.BASIC_DOC_SNIPPET_ATTRIBUTE_VALUE, - - // these element types are available only in java-frontend module - //JavaDocSyntaxElementType.DOC_REFERENCE_HOLDER to FrontendJavaDocElementType.DOC_REFERENCE_HOLDER, - //JavaDocSyntaxElementType.DOC_TYPE_HOLDER to FrontendJavaDocElementType.DOC_TYPE_HOLDER, - //JavaDocSyntaxElementType.DOC_COMMENT to FrontendJavaDocElementType.DOC_COMMENT, - - JavaDocSyntaxElementType.DOC_MARKDOWN_CODE_BLOCK to BasicJavaDocElementType.BASIC_DOC_MARKDOWN_CODE_BLOCK, - JavaDocSyntaxElementType.DOC_MARKDOWN_REFERENCE_LINK to BasicJavaDocElementType.BASIC_DOC_MARKDOWN_REFERENCE_LINK, - JavaDocSyntaxElementType.DOC_MARKDOWN_REFERENCE_LABEL to BasicJavaDocElementType.BASIC_DOC_MARKDOWN_REFERENCE_LABEL, -) diff --git a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/JavaBinaryOperations.kt b/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/JavaBinaryOperations.kt deleted file mode 100644 index 65c08dcebb6f..000000000000 --- a/java/java-frontback-psi-impl/src/com/intellij/lang/java/parser/JavaBinaryOperations.kt +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. -package com.intellij.lang.java.parser - -import com.intellij.java.frontback.psi.impl.syntax.BasicJavaElementTypeConverter -import com.intellij.java.syntax.parser.ExpressionParser -import com.intellij.platform.syntax.psi.asTokenSet -import com.intellij.psi.tree.TokenSet -import org.jetbrains.annotations.ApiStatus - -@ApiStatus.Internal -object JavaBinaryOperations { - // todo replace BasicJavaElementTypeConverter with another Converter when parsers are merged - @JvmField val ASSIGNMENT_OPS: TokenSet = ExpressionParser.ASSIGNMENT_OPS.asTokenSet(BasicJavaElementTypeConverter) - @JvmField val SHIFT_OPS: TokenSet = ExpressionParser.SHIFT_OPS.asTokenSet(BasicJavaElementTypeConverter) - @JvmField val ADDITIVE_OPS: TokenSet = ExpressionParser.ADDITIVE_OPS.asTokenSet(BasicJavaElementTypeConverter) - @JvmField val MULTIPLICATIVE_OPS: TokenSet = ExpressionParser.MULTIPLICATIVE_OPS.asTokenSet(BasicJavaElementTypeConverter) -} \ No newline at end of file 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 1a768e5c2322..973b73f5af37 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 @@ -3,29 +3,46 @@ package com.intellij.psi.impl.source.tree; import com.intellij.psi.JavaDocTokenType; import com.intellij.psi.JavaTokenType; -import com.intellij.psi.impl.source.BasicElementTypes; import com.intellij.psi.tree.TokenSet; /** - * @see BasicElementTypes + * @see com.intellij.psi.impl.source.BasicElementTypes * @see com.intellij.java.syntax.element.SyntaxElementTypes */ @SuppressWarnings("unused") //because of backward compatibility, some of these sets are used in plugins public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElementType, JavaDocElementType { - TokenSet JAVA_PLAIN_COMMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET; + TokenSet JAVA_PLAIN_COMMENT_BIT_SET = TokenSet.create(END_OF_LINE_COMMENT, C_STYLE_COMMENT); TokenSet JAVA_COMMENT_BIT_SET = TokenSet.orSet(JAVA_PLAIN_COMMENT_BIT_SET, DOC_COMMENT_TOKENS); 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; + TokenSet 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, + EXTENDS_KEYWORD, FINAL_KEYWORD, FINALLY_KEYWORD, FLOAT_KEYWORD, FOR_KEYWORD, GOTO_KEYWORD, IF_KEYWORD, IMPLEMENTS_KEYWORD, + IMPORT_KEYWORD, INSTANCEOF_KEYWORD, INT_KEYWORD, INTERFACE_KEYWORD, LONG_KEYWORD, NATIVE_KEYWORD, NEW_KEYWORD, PACKAGE_KEYWORD, + PRIVATE_KEYWORD, PROTECTED_KEYWORD, PUBLIC_KEYWORD, RETURN_KEYWORD, SHORT_KEYWORD, SUPER_KEYWORD, STATIC_KEYWORD, STRICTFP_KEYWORD, + SWITCH_KEYWORD, SYNCHRONIZED_KEYWORD, THIS_KEYWORD, THROW_KEYWORD, THROWS_KEYWORD, TRANSIENT_KEYWORD, TRY_KEYWORD, VOID_KEYWORD, + VOLATILE_KEYWORD, WHILE_KEYWORD, + OPEN_KEYWORD, MODULE_KEYWORD, REQUIRES_KEYWORD, EXPORTS_KEYWORD, OPENS_KEYWORD, USES_KEYWORD, PROVIDES_KEYWORD, + TRANSITIVE_KEYWORD, TO_KEYWORD, WITH_KEYWORD, VAR_KEYWORD, YIELD_KEYWORD, RECORD_KEYWORD, SEALED_KEYWORD, PERMITS_KEYWORD, + NON_SEALED_KEYWORD, WHEN_KEYWORD, VALUE_KEYWORD + ); - TokenSet LITERAL_BIT_SET = BasicElementTypes.BASIC_LITERAL_BIT_SET; + TokenSet LITERAL_BIT_SET = TokenSet.create(TRUE_KEYWORD, FALSE_KEYWORD, NULL_KEYWORD); - TokenSet OPERATION_BIT_SET = BasicElementTypes.BASIC_OPERATION_BIT_SET; + TokenSet OPERATION_BIT_SET = TokenSet.create( + EQ, GT, LT, EXCL, TILDE, QUEST, COLON, PLUS, MINUS, ASTERISK, DIV, AND, OR, XOR, + PERC, EQEQ, LE, GE, NE, ANDAND, OROR, PLUSPLUS, MINUSMINUS, LTLT, GTGT, GTGTGT, + PLUSEQ, MINUSEQ, ASTERISKEQ, DIVEQ, ANDEQ, OREQ, XOREQ, PERCEQ, LTLTEQ, GTGTEQ, GTGTGTEQ); - TokenSet MODIFIER_BIT_SET = BasicElementTypes.BASIC_MODIFIER_BIT_SET; + TokenSet 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, + VALUE_KEYWORD); - TokenSet PRIMITIVE_TYPE_BIT_SET = BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET; + TokenSet PRIMITIVE_TYPE_BIT_SET = TokenSet.create( + BOOLEAN_KEYWORD, BYTE_KEYWORD, SHORT_KEYWORD, INT_KEYWORD, LONG_KEYWORD, CHAR_KEYWORD, FLOAT_KEYWORD, DOUBLE_KEYWORD, VOID_KEYWORD); TokenSet EXPRESSION_BIT_SET = TokenSet.create( REFERENCE_EXPRESSION, LITERAL_EXPRESSION, THIS_EXPRESSION, SUPER_EXPRESSION, @@ -68,17 +85,31 @@ public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElemen REQUIRES_STATEMENT, EXPORTS_STATEMENT, OPENS_STATEMENT, USES_STATEMENT, PROVIDES_STATEMENT); TokenSet IMPORT_STATEMENT_BASE_BIT_SET = TokenSet.create(IMPORT_STATEMENT, IMPORT_STATIC_STATEMENT, IMPORT_MODULE_STATEMENT); - TokenSet CLASS_KEYWORD_BIT_SET = BasicElementTypes.BASIC_CLASS_KEYWORD_BIT_SET; + TokenSet CLASS_KEYWORD_BIT_SET = TokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD, ENUM_KEYWORD, RECORD_KEYWORD); 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; - TokenSet STRING_LITERALS = BasicElementTypes.BASIC_STRING_LITERALS; - TokenSet TEXT_LITERALS = BasicElementTypes.BASIC_TEXT_LITERALS; + TokenSet INTEGER_LITERALS = TokenSet.create(INTEGER_LITERAL, LONG_LITERAL); + TokenSet REAL_LITERALS = TokenSet.create(FLOAT_LITERAL, DOUBLE_LITERAL); + TokenSet STRING_LITERALS = TokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL); + TokenSet TEXT_LITERALS = TokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL, CHARACTER_LITERAL); - TokenSet STRING_TEMPLATE_FRAGMENTS = BasicElementTypes.BASIC_STRING_TEMPLATE_FRAGMENTS; + TokenSet STRING_TEMPLATE_FRAGMENTS = TokenSet.create(STRING_TEMPLATE_BEGIN, STRING_TEMPLATE_MID, STRING_TEMPLATE_END, + TEXT_BLOCK_TEMPLATE_BEGIN, TEXT_BLOCK_TEMPLATE_MID, TEXT_BLOCK_TEMPLATE_END); - TokenSet ALL_LITERALS = BasicElementTypes.BASIC_ALL_LITERALS; + TokenSet ALL_LITERALS = TokenSet.orSet(INTEGER_LITERALS, + REAL_LITERALS, + STRING_LITERALS, + TEXT_LITERALS); + + TokenSet SHIFT_OPS = TokenSet.create(LTLT, GTGT, GTGTGT); + + TokenSet ADDITIVE_OPS = TokenSet.create(PLUS, MINUS); + + TokenSet MULTIPLICATIVE_OPS = TokenSet.create(ASTERISK, DIV, PERC); + + TokenSet ASSIGNMENT_OPS = TokenSet.create( + EQ, ASTERISKEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ, LTLTEQ, GTGTEQ, GTGTGTEQ, ANDEQ, + OREQ, XOREQ); } \ No newline at end of file diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiAssignmentExpressionImpl.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiAssignmentExpressionImpl.java index d4ba5ed22828..58cab9ec884a 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiAssignmentExpressionImpl.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiAssignmentExpressionImpl.java @@ -2,7 +2,6 @@ package com.intellij.psi.impl.source.tree.java; import com.intellij.lang.ASTNode; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.openapi.diagnostic.Logger; import com.intellij.psi.*; import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil; @@ -95,7 +94,7 @@ public class PsiAssignmentExpressionImpl extends ExpressionPsiElement implements } } - private static final TokenSet OUR_OPERATIONS_BIT_SET = JavaBinaryOperations.ASSIGNMENT_OPS; + private static final TokenSet OUR_OPERATIONS_BIT_SET = ElementType.ASSIGNMENT_OPS; @Override public void accept(@NotNull PsiElementVisitor visitor) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ReplaceExpressionUtil.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ReplaceExpressionUtil.java index ca201f406670..6a6838650541 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ReplaceExpressionUtil.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/ReplaceExpressionUtil.java @@ -2,7 +2,6 @@ package com.intellij.psi.impl.source.tree.java; import com.intellij.lang.ASTNode; -import com.intellij.lang.java.parser.JavaBinaryOperations; import com.intellij.openapi.diagnostic.Logger; import com.intellij.psi.JavaTokenType; import com.intellij.psi.PsiElement; @@ -57,10 +56,10 @@ public final class ReplaceExpressionUtil { return true; } if (i == JavaElementType.INSTANCE_OF_EXPRESSION || - i == JavaElementType.PREFIX_EXPRESSION || - i == JavaElementType.TYPE_CAST_EXPRESSION || - i == JavaElementType.REFERENCE_EXPRESSION || - i == JavaElementType.METHOD_REF_EXPRESSION) { + i == JavaElementType.PREFIX_EXPRESSION || + i == JavaElementType.TYPE_CAST_EXPRESSION || + i == JavaElementType.REFERENCE_EXPRESSION || + i == JavaElementType.METHOD_REF_EXPRESSION) { return priority < parentPriority; } if (i == JavaElementType.ARRAY_ACCESS_EXPRESSION) { @@ -68,16 +67,16 @@ public final class ReplaceExpressionUtil { return role != ChildRole.ARRAY_DIMENSION && role != ChildRole.INDEX && priority < parentPriority; } if (i == JavaElementType.METHOD_CALL_EXPRESSION || - i == JavaElementType.NEW_EXPRESSION || - i == JavaElementType.ARRAY_INITIALIZER_EXPRESSION || - i == JavaElementType.PARENTH_EXPRESSION || - i == JavaElementType.LITERAL_EXPRESSION || - i == JavaElementType.THIS_EXPRESSION || - i == JavaElementType.SUPER_EXPRESSION || - i == JavaElementType.CLASS_OBJECT_ACCESS_EXPRESSION || - i == JavaElementType.LAMBDA_EXPRESSION || - i == JavaElementType.SWITCH_EXPRESSION || - i == JavaElementType.TEMPLATE_EXPRESSION) { + i == JavaElementType.NEW_EXPRESSION || + i == JavaElementType.ARRAY_INITIALIZER_EXPRESSION || + i == JavaElementType.PARENTH_EXPRESSION || + i == JavaElementType.LITERAL_EXPRESSION || + i == JavaElementType.THIS_EXPRESSION || + i == JavaElementType.SUPER_EXPRESSION || + i == JavaElementType.CLASS_OBJECT_ACCESS_EXPRESSION || + i == JavaElementType.LAMBDA_EXPRESSION || + i == JavaElementType.SWITCH_EXPRESSION || + i == JavaElementType.TEMPLATE_EXPRESSION) { return false; } @@ -117,13 +116,13 @@ public final class ReplaceExpressionUtil { else if (opType == JavaTokenType.LT || opType == JavaTokenType.GT || opType == JavaTokenType.LE || opType == JavaTokenType.GE) { return 8; } - else if (JavaBinaryOperations.SHIFT_OPS.contains(opType)) { + else if (ElementType.SHIFT_OPS.contains(opType)) { return 9; } - else if (JavaBinaryOperations.ADDITIVE_OPS.contains(opType)) { + else if (ElementType.ADDITIVE_OPS.contains(opType)) { return 10; } - else if (JavaBinaryOperations.MULTIPLICATIVE_OPS.contains(opType)) { + else if (ElementType.MULTIPLICATIVE_OPS.contains(opType)) { return 11; } return 8; diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/SyntaxElementTypes.kt b/java/java-syntax/src/com/intellij/java/syntax/element/SyntaxElementTypes.kt index c1c3e3401f10..702ff962b678 100644 --- a/java/java-syntax/src/com/intellij/java/syntax/element/SyntaxElementTypes.kt +++ b/java/java-syntax/src/com/intellij/java/syntax/element/SyntaxElementTypes.kt @@ -1,6 +1,7 @@ // Copyright 2000-2025 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.java.syntax.element +import com.intellij.java.syntax.element.JavaSyntaxTokenType import com.intellij.platform.syntax.SyntaxElementTypeSet import com.intellij.platform.syntax.element.SyntaxTokenTypes.WHITE_SPACE import com.intellij.platform.syntax.syntaxElementTypeSetOf @@ -101,4 +102,17 @@ object SyntaxElementTypes { ) val ALL_LITERALS: SyntaxElementTypeSet = INTEGER_LITERALS + REAL_LITERALS + TEXT_LITERALS + LITERAL_BIT_SET + + + val SHIFT_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.LTLT, JavaSyntaxTokenType.GTGT, JavaSyntaxTokenType.GTGTGT) + + val ADDITIVE_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.PLUS, JavaSyntaxTokenType.MINUS) + + val MULTIPLICATIVE_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.ASTERISK, JavaSyntaxTokenType.DIV, JavaSyntaxTokenType.PERC) + + val ASSIGNMENT_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JavaSyntaxTokenType.EQ, JavaSyntaxTokenType.ASTERISKEQ, JavaSyntaxTokenType.DIVEQ, JavaSyntaxTokenType.PERCEQ, + JavaSyntaxTokenType.PLUSEQ, JavaSyntaxTokenType.MINUSEQ, + JavaSyntaxTokenType.LTLTEQ, JavaSyntaxTokenType.GTGTEQ, JavaSyntaxTokenType.GTGTGTEQ, JavaSyntaxTokenType.ANDEQ, + JavaSyntaxTokenType.OREQ, JavaSyntaxTokenType.XOREQ) } diff --git a/java/java-syntax/src/com/intellij/java/syntax/parser/ExpressionParser.kt b/java/java-syntax/src/com/intellij/java/syntax/parser/ExpressionParser.kt index 29ac83dafde1..14cb49472c63 100644 --- a/java/java-syntax/src/com/intellij/java/syntax/parser/ExpressionParser.kt +++ b/java/java-syntax/src/com/intellij/java/syntax/parser/ExpressionParser.kt @@ -39,22 +39,6 @@ class ExpressionParser( } companion object { - @JvmStatic - val SHIFT_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.LTLT, JavaSyntaxTokenType.GTGT, JavaSyntaxTokenType.GTGTGT) - - @JvmStatic - val ADDITIVE_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.PLUS, JavaSyntaxTokenType.MINUS) - - @JvmStatic - val MULTIPLICATIVE_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaSyntaxTokenType.ASTERISK, JavaSyntaxTokenType.DIV, JavaSyntaxTokenType.PERC) - - @JvmStatic - val ASSIGNMENT_OPS: SyntaxElementTypeSet = syntaxElementTypeSetOf( - JavaSyntaxTokenType.EQ, JavaSyntaxTokenType.ASTERISKEQ, JavaSyntaxTokenType.DIVEQ, JavaSyntaxTokenType.PERCEQ, - JavaSyntaxTokenType.PLUSEQ, JavaSyntaxTokenType.MINUSEQ, - JavaSyntaxTokenType.LTLTEQ, JavaSyntaxTokenType.GTGTEQ, JavaSyntaxTokenType.GTGTGTEQ, JavaSyntaxTokenType.ANDEQ, - JavaSyntaxTokenType.OREQ, JavaSyntaxTokenType.XOREQ) - const val FORBID_LAMBDA_MASK: Int = 0x1 } }