[java] IDEA-365317 delete JavaBinaryOperations and BasicJavaElementTypeConverter

GitOrigin-RevId: afa1d288c6a36788a07226e34528415ee0fa7200
2026-09-27 10:03:11 +07:00 · 2025-11-20 12:44:51 +00:00
parent 636f753d46
commit bf22495377
15 changed files with 98 additions and 390 deletions
@@ -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);
      }
@@ -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 {
@@ -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();
@@ -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) {
@@ -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;
@@ -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) {
@@ -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);
 }
@@ -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 {
@@ -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,
-)
@@ -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)
-}
@@ -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);
 }
@@ -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) {
@@ -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;
@@ -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)
 }
@@ -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
  }
 }