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 new file mode 100644 index 000000000000..97812fa914e8 --- /dev/null +++ b/java/java-frontback-psi-impl/src/com/intellij/java/frontback/psi/impl/syntax/BasicJavaElementTypeConverter.kt @@ -0,0 +1,300 @@ +// 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, +) diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java index 0427b16a475d..4c3f2ce02050 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicElementTypes.java @@ -1,6 +1,7 @@ // Copyright 2000-2024 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license. package com.intellij.psi.impl.source; +import com.intellij.java.syntax.element.SyntaxElementTypes; import com.intellij.psi.JavaDocTokenType; import com.intellij.psi.JavaTokenType; import com.intellij.psi.tree.ParentAwareTokenSet; @@ -14,6 +15,7 @@ import com.intellij.psi.tree.TokenSet; * It's checked with {@link com.intellij.java.parser.FrontBackElementTypeTest#testJavaTokenSet()} * * @see ParentAwareTokenSet + * @see SyntaxElementTypes */ @SuppressWarnings("unused") public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, BasicJavaElementType, BasicJavaDocElementType { diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java index 257281245c67..764919a8980e 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaDocElementType.java @@ -26,6 +26,9 @@ import java.util.Set; import java.util.function.Function; import java.util.function.Supplier; +/** + * @see JavaDocSyntaxElementType + */ public interface BasicJavaDocElementType { IElementType BASIC_DOC_TAG = new IJavaDocElementType("DOC_TAG"); IElementType BASIC_DOC_INLINE_TAG = new IJavaDocElementType("DOC_INLINE_TAG"); diff --git a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java index 70f7a4e7d315..d59579c81c9e 100644 --- a/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java +++ b/java/java-frontback-psi-impl/src/com/intellij/psi/impl/source/BasicJavaElementType.java @@ -31,6 +31,9 @@ import java.util.function.Function; import java.util.function.Supplier; +/** + * @see com.intellij.java.syntax.element.JavaSyntaxElementType + */ public interface BasicJavaElementType { IElementType BASIC_CLASS = new IJavaElementType("CLASS"); diff --git a/java/java-psi-impl/resources/META-INF/JavaPsiPlugin.xml b/java/java-psi-impl/resources/META-INF/JavaPsiPlugin.xml index 56e686c71868..3a05f96686b4 100644 --- a/java/java-psi-impl/resources/META-INF/JavaPsiPlugin.xml +++ b/java/java-psi-impl/resources/META-INF/JavaPsiPlugin.xml @@ -133,6 +133,7 @@ + nodeClass, IElementType parentElementType) { diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java index 3c0f9a2107fb..8819a1855851 100644 --- a/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java +++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/tree/JavaElementType.java @@ -20,6 +20,9 @@ import java.util.function.Supplier; import static com.intellij.psi.impl.source.BasicJavaElementType.*; +/** + * @see com.intellij.java.syntax.element.JavaSyntaxElementType + */ public interface JavaElementType { class JavaCompositeElementType extends BasicJavaElementType.JavaCompositeElementType { public JavaCompositeElementType(@NotNull String debugName, diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocCommentSyntaxTokenTypes.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocCommentSyntaxTokenTypes.kt new file mode 100644 index 000000000000..e59ea2401e21 --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocCommentSyntaxTokenTypes.kt @@ -0,0 +1,59 @@ +// 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.platform.syntax.SyntaxElementType +import com.intellij.platform.syntax.SyntaxElementTypeSet + +/** + * Describes JDoc comment specific to the Java Plugin (not part of the core-api) + * @see com.intellij.lexer.JavaDocCommentTokenTypes + */ +interface JavaDocCommentSyntaxTokenTypes { + val commentStart: SyntaxElementType + val commentEnd: SyntaxElementType + val commentData: SyntaxElementType + val spaceCommentsTokenSet: SyntaxElementTypeSet + val space: SyntaxElementType + val tagValueToken: SyntaxElementType + val tagValueLParen: SyntaxElementType + val tagValueRParen: SyntaxElementType + val tagValueSharp: SyntaxElementType + val tagValueComma: SyntaxElementType + val tagName: SyntaxElementType + val tagValueLT: SyntaxElementType + val tagValueGT: SyntaxElementType + val inlineTagStart: SyntaxElementType + val inlineTagEnd: SyntaxElementType + val badCharacter: SyntaxElementType + val commentLeadingAsterisks: SyntaxElementType + + val tagValueQuote: SyntaxElementType + get() = commentData + + val tagValueColon: SyntaxElementType + get() = commentData + + val codeFence: SyntaxElementType + get() = commentData + + val rightBracket: SyntaxElementType + get() = commentData + + val leftBracket: SyntaxElementType + get() = commentData + + val leftParenthesis: SyntaxElementType + get() = commentData + + val rightParenthesis: SyntaxElementType + get() = commentData + + val sharp: SyntaxElementType + get() = commentData + + val inlineCodeFence: SyntaxElementType + get() = commentData + + val comma: SyntaxElementType + get() = commentData +} diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxElementType.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxElementType.kt new file mode 100644 index 000000000000..cb3fb3bc1de8 --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxElementType.kt @@ -0,0 +1,29 @@ +// 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.platform.syntax.SyntaxElementType + +/** + * @see com.intellij.psi.impl.source.tree.JavaDocElementType + */ +object JavaDocSyntaxElementType { + val DOC_TAG: SyntaxElementType = SyntaxElementType("DOC_TAG") + val DOC_INLINE_TAG: SyntaxElementType = SyntaxElementType("DOC_INLINE_TAG") + val DOC_METHOD_OR_FIELD_REF: SyntaxElementType = SyntaxElementType("DOC_METHOD_OR_FIELD_REF") + val DOC_PARAMETER_REF: SyntaxElementType = SyntaxElementType("DOC_PARAMETER_REF") + val DOC_TAG_VALUE_ELEMENT: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_ELEMENT") + val DOC_SNIPPET_TAG: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_TAG") + val DOC_SNIPPET_TAG_VALUE: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_TAG_VALUE") + val DOC_SNIPPET_BODY: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_BODY") + val DOC_SNIPPET_ATTRIBUTE: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_ATTRIBUTE") + val DOC_SNIPPET_ATTRIBUTE_LIST: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_ATTRIBUTE_LIST") + val DOC_SNIPPET_ATTRIBUTE_VALUE: SyntaxElementType = SyntaxElementType("DOC_SNIPPET_ATTRIBUTE_VALUE") + + val DOC_REFERENCE_HOLDER: SyntaxElementType = SyntaxElementType("DOC_REFERENCE_HOLDER") + + val DOC_TYPE_HOLDER: SyntaxElementType = SyntaxElementType("DOC_TYPE_HOLDER") + + val DOC_COMMENT: SyntaxElementType = SyntaxElementType("DOC_COMMENT") + val DOC_MARKDOWN_CODE_BLOCK: SyntaxElementType = SyntaxElementType("DOC_CODE_BLOCK") + val DOC_MARKDOWN_REFERENCE_LINK: SyntaxElementType = SyntaxElementType("DOC_REFERENCE_LINK") +} \ No newline at end of file diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenType.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenType.kt new file mode 100644 index 000000000000..3817fd98013f --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenType.kt @@ -0,0 +1,43 @@ +// 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.platform.syntax.SyntaxElementType + +/** + * @see com.intellij.psi.JavaDocTokenType + */ +object JavaDocSyntaxTokenType { + val DOC_COMMENT_START: SyntaxElementType = SyntaxElementType("DOC_COMMENT_START") + val DOC_COMMENT_END: SyntaxElementType = SyntaxElementType("DOC_COMMENT_END") + val DOC_COMMENT_DATA: SyntaxElementType = SyntaxElementType("DOC_COMMENT_DATA") + val DOC_SPACE: SyntaxElementType = SyntaxElementType("DOC_SPACE") + val DOC_COMMENT_LEADING_ASTERISKS: SyntaxElementType = SyntaxElementType("DOC_COMMENT_LEADING_ASTERISKS") + val DOC_TAG_NAME: SyntaxElementType = SyntaxElementType("DOC_TAG_NAME") + val DOC_INLINE_TAG_START: SyntaxElementType = SyntaxElementType("DOC_INLINE_TAG_START") + val DOC_INLINE_TAG_END: SyntaxElementType = SyntaxElementType("DOC_INLINE_TAG_END") + + val DOC_TAG_VALUE_TOKEN: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_TOKEN") + val DOC_TAG_VALUE_DOT: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_DOT") + val DOC_TAG_VALUE_COMMA: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_COMMA") + val DOC_TAG_VALUE_LPAREN: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_LPAREN") + val DOC_TAG_VALUE_RPAREN: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_RPAREN") + val DOC_TAG_VALUE_QUOTE: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_QUOTE") + val DOC_TAG_VALUE_COLON: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_COLON") + val DOC_TAG_ATTRIBUTE_NAME: SyntaxElementType = SyntaxElementType("DOC_TAG_ATTRIBUTE_NAME") + val DOC_TAG_ATTRIBUTE_VALUE: SyntaxElementType = SyntaxElementType("DOC_TAG_ATTRIBUTE_VALUE") + val DOC_TAG_VALUE_LT: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_LT") + val DOC_TAG_VALUE_GT: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_GT") + val DOC_TAG_VALUE_SHARP_TOKEN: SyntaxElementType = SyntaxElementType("DOC_TAG_VALUE_SHARP_TOKEN") + + // Additional tokens for java 23 markdown + val DOC_CODE_FENCE: SyntaxElementType = SyntaxElementType("DOC_CODE_FENCE") + val DOC_RBRACKET: SyntaxElementType = SyntaxElementType("DOC_RBRACKET") + val DOC_LBRACKET: SyntaxElementType = SyntaxElementType("DOC_LBRACKET") + val DOC_LPAREN: SyntaxElementType = SyntaxElementType("DOC_LPAREN") + val DOC_RPAREN: SyntaxElementType = SyntaxElementType("DOC_RPAREN") + val DOC_SHARP: SyntaxElementType = SyntaxElementType("DOC_SHARP") + val DOC_INLINE_CODE_FENCE: SyntaxElementType = SyntaxElementType("DOC_INLINE_CODE_FENCE") + val DOC_COMMA: SyntaxElementType = SyntaxElementType("DOC_COMMA") + + val DOC_COMMENT_BAD_CHARACTER: SyntaxElementType = SyntaxElementType("DOC_COMMENT_BAD_CHARACTER") +} \ No newline at end of file diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenTypes.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenTypes.kt new file mode 100644 index 000000000000..6cfb973bce0f --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaDocSyntaxTokenTypes.kt @@ -0,0 +1,39 @@ +// 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.platform.syntax.SyntaxElementType +import com.intellij.platform.syntax.SyntaxElementTypeSet +import com.intellij.platform.syntax.syntaxElementTypeSetOf + +/** + * @see com.intellij.lexer.JavaDocTokenTypes + */ +object JavaDocSyntaxTokenTypes : JavaDocCommentSyntaxTokenTypes { + override val commentStart: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMENT_START + override val commentEnd: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMENT_END + override val commentData: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMENT_DATA + override val spaceCommentsTokenSet: SyntaxElementTypeSet = syntaxElementTypeSetOf(JavaDocSyntaxTokenType.DOC_SPACE, JavaDocSyntaxTokenType.DOC_COMMENT_DATA) + override val space: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_SPACE + override val tagValueToken: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_TOKEN + override val tagValueLParen: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_LPAREN + override val tagValueRParen: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_RPAREN + override val tagValueQuote: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_QUOTE + override val tagValueColon: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_COLON + override val tagValueSharp: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_SHARP_TOKEN + override val tagValueComma: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_COMMA + override val tagName: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_NAME + override val tagValueLT: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_LT + override val tagValueGT: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_TAG_VALUE_GT + override val inlineTagStart: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_INLINE_TAG_START + override val inlineTagEnd: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_INLINE_TAG_END + override val badCharacter: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMENT_BAD_CHARACTER + override val commentLeadingAsterisks: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMENT_LEADING_ASTERISKS + override val codeFence: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_CODE_FENCE + override val rightBracket: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_RBRACKET + override val leftBracket: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_LBRACKET + override val leftParenthesis: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_LPAREN + override val rightParenthesis: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_RPAREN + override val sharp: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_SHARP + override val inlineCodeFence: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_INLINE_CODE_FENCE + override val comma: SyntaxElementType get() = JavaDocSyntaxTokenType.DOC_COMMA +} diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxElementType.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxElementType.kt new file mode 100644 index 000000000000..0b1b5d4222f2 --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxElementType.kt @@ -0,0 +1,131 @@ +// 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.platform.syntax.SyntaxElementType + +/** + * @see com.intellij.psi.impl.source.tree.JavaElementType + */ +object JavaSyntaxElementType { + val JAVA_FILE: SyntaxElementType = SyntaxElementType("JAVA_FILE") + val CLASS: SyntaxElementType = SyntaxElementType("CLASS") + val IMPLICIT_CLASS: SyntaxElementType = SyntaxElementType("IMPLICIT_CLASS") + val ANONYMOUS_CLASS: SyntaxElementType = SyntaxElementType("ANONYMOUS_CLASS") + val ENUM_CONSTANT_INITIALIZER: SyntaxElementType = SyntaxElementType("ENUM_CONSTANT_INITIALIZER") + val TYPE_PARAMETER_LIST: SyntaxElementType = SyntaxElementType("TYPE_PARAMETER_LIST") + val TYPE_PARAMETER: SyntaxElementType = SyntaxElementType("TYPE_PARAMETER") + val IMPORT_LIST: SyntaxElementType = SyntaxElementType("IMPORT_LIST") + val IMPORT_STATEMENT: SyntaxElementType = SyntaxElementType("IMPORT_STATEMENT") + val IMPORT_STATIC_STATEMENT: SyntaxElementType = SyntaxElementType("IMPORT_STATIC_STATEMENT") + val IMPORT_MODULE_STATEMENT: SyntaxElementType = SyntaxElementType("IMPORT_MODULE_STATEMENT") + val MODIFIER_LIST: SyntaxElementType = SyntaxElementType("MODIFIER_LIST") + val ANNOTATION: SyntaxElementType = SyntaxElementType("ANNOTATION") + val NAME_VALUE_PAIR: SyntaxElementType = SyntaxElementType("NAME_VALUE_PAIR") + val LITERAL_EXPRESSION: SyntaxElementType = SyntaxElementType("LITERAL_EXPRESSION") + val ANNOTATION_PARAMETER_LIST: SyntaxElementType = SyntaxElementType("ANNOTATION_PARAMETER_LIST") + val EXTENDS_LIST: SyntaxElementType = SyntaxElementType("EXTENDS_LIST") + val IMPLEMENTS_LIST: SyntaxElementType = SyntaxElementType("IMPLEMENTS_LIST") + val FIELD: SyntaxElementType = SyntaxElementType("FIELD") + val ENUM_CONSTANT: SyntaxElementType = SyntaxElementType("ENUM_CONSTANT") + val METHOD: SyntaxElementType = SyntaxElementType("METHOD") + val ANNOTATION_METHOD: SyntaxElementType = SyntaxElementType("ANNOTATION_METHOD") + val CLASS_INITIALIZER: SyntaxElementType = SyntaxElementType("CLASS_INITIALIZER") + val PARAMETER: SyntaxElementType = SyntaxElementType("PARAMETER") + val PARAMETER_LIST: SyntaxElementType = SyntaxElementType("PARAMETER_LIST") + val EXTENDS_BOUND_LIST: SyntaxElementType = SyntaxElementType("EXTENDS_BOUND_LIST") + val THROWS_LIST: SyntaxElementType = SyntaxElementType("THROWS_LIST") + val LAMBDA_EXPRESSION: SyntaxElementType = SyntaxElementType("LAMBDA_EXPRESSION") + val METHOD_REF_EXPRESSION: SyntaxElementType = SyntaxElementType("METHOD_REF_EXPRESSION") + val MODULE: SyntaxElementType = SyntaxElementType("MODULE") + val REQUIRES_STATEMENT: SyntaxElementType = SyntaxElementType("REQUIRES_STATEMENT") + val EXPORTS_STATEMENT: SyntaxElementType = SyntaxElementType("EXPORTS_STATEMENT") + val OPENS_STATEMENT: SyntaxElementType = SyntaxElementType("OPENS_STATEMENT") + val USES_STATEMENT: SyntaxElementType = SyntaxElementType("USES_STATEMENT") + val PROVIDES_STATEMENT: SyntaxElementType = SyntaxElementType("PROVIDES_STATEMENT") + val PROVIDES_WITH_LIST: SyntaxElementType = SyntaxElementType("PROVIDES_WITH_LIST") + val RECORD_COMPONENT: SyntaxElementType = SyntaxElementType("RECORD_COMPONENT") + val RECORD_HEADER: SyntaxElementType = SyntaxElementType("RECORD_HEADER") + val PERMITS_LIST: SyntaxElementType = SyntaxElementType("PERMITS_LIST") + + val IMPORT_STATIC_REFERENCE: SyntaxElementType = SyntaxElementType("IMPORT_STATIC_REFERENCE") + val TYPE: SyntaxElementType = SyntaxElementType("TYPE") + val DIAMOND_TYPE: SyntaxElementType = SyntaxElementType("DIAMOND_TYPE") + val REFERENCE_PARAMETER_LIST: SyntaxElementType = SyntaxElementType("REFERENCE_PARAMETER_LIST") + val JAVA_CODE_REFERENCE: SyntaxElementType = SyntaxElementType("JAVA_CODE_REFERENCE") + val PACKAGE_STATEMENT: SyntaxElementType = SyntaxElementType("PACKAGE_STATEMENT") + val LOCAL_VARIABLE: SyntaxElementType = SyntaxElementType("LOCAL_VARIABLE") + val REFERENCE_EXPRESSION: SyntaxElementType = SyntaxElementType("REFERENCE_EXPRESSION") + val THIS_EXPRESSION: SyntaxElementType = SyntaxElementType("THIS_EXPRESSION") + val SUPER_EXPRESSION: SyntaxElementType = SyntaxElementType("SUPER_EXPRESSION") + val PARENTH_EXPRESSION: SyntaxElementType = SyntaxElementType("PARENTH_EXPRESSION") + val METHOD_CALL_EXPRESSION: SyntaxElementType = SyntaxElementType("METHOD_CALL_EXPRESSION") + val TYPE_CAST_EXPRESSION: SyntaxElementType = SyntaxElementType("TYPE_CAST_EXPRESSION") + val PREFIX_EXPRESSION: SyntaxElementType = SyntaxElementType("PREFIX_EXPRESSION") + val POSTFIX_EXPRESSION: SyntaxElementType = SyntaxElementType("POSTFIX_EXPRESSION") + val BINARY_EXPRESSION: SyntaxElementType = SyntaxElementType("BINARY_EXPRESSION") + val POLYADIC_EXPRESSION: SyntaxElementType = SyntaxElementType("POLYADIC_EXPRESSION") + val CONDITIONAL_EXPRESSION: SyntaxElementType = SyntaxElementType("CONDITIONAL_EXPRESSION") + val ASSIGNMENT_EXPRESSION: SyntaxElementType = SyntaxElementType("ASSIGNMENT_EXPRESSION") + val NEW_EXPRESSION: SyntaxElementType = SyntaxElementType("NEW_EXPRESSION") + val ARRAY_ACCESS_EXPRESSION: SyntaxElementType = SyntaxElementType("ARRAY_ACCESS_EXPRESSION") + val ARRAY_INITIALIZER_EXPRESSION: SyntaxElementType = SyntaxElementType("ARRAY_INITIALIZER_EXPRESSION") + val INSTANCE_OF_EXPRESSION: SyntaxElementType = SyntaxElementType("INSTANCE_OF_EXPRESSION") + val CLASS_OBJECT_ACCESS_EXPRESSION: SyntaxElementType = SyntaxElementType("CLASS_OBJECT_ACCESS_EXPRESSION") + + val TEMPLATE_EXPRESSION: SyntaxElementType = SyntaxElementType("TEMPLATE_EXPRESSION") + + val TEMPLATE: SyntaxElementType = SyntaxElementType("TEMPLATE") + + val EMPTY_EXPRESSION: SyntaxElementType = SyntaxElementType("EMPTY_EXPRESSION") + val EXPRESSION_LIST: SyntaxElementType = SyntaxElementType("EXPRESSION_LIST") + val EMPTY_STATEMENT: SyntaxElementType = SyntaxElementType("EMPTY_STATEMENT") + val BLOCK_STATEMENT: SyntaxElementType = SyntaxElementType("BLOCK_STATEMENT") + val EXPRESSION_STATEMENT: SyntaxElementType = SyntaxElementType("EXPRESSION_STATEMENT") + val EXPRESSION_LIST_STATEMENT: SyntaxElementType = SyntaxElementType("EXPRESSION_LIST_STATEMENT") + val DECLARATION_STATEMENT: SyntaxElementType = SyntaxElementType("DECLARATION_STATEMENT") + val IF_STATEMENT: SyntaxElementType = SyntaxElementType("IF_STATEMENT") + val WHILE_STATEMENT: SyntaxElementType = SyntaxElementType("WHILE_STATEMENT") + val FOR_STATEMENT: SyntaxElementType = SyntaxElementType("FOR_STATEMENT") + val FOREACH_STATEMENT: SyntaxElementType = SyntaxElementType("FOREACH_STATEMENT") + val FOREACH_PATTERN_STATEMENT: SyntaxElementType = SyntaxElementType("FOREACH_PATTERN_STATEMENT") + val DO_WHILE_STATEMENT: SyntaxElementType = SyntaxElementType("DO_WHILE_STATEMENT") + val SWITCH_STATEMENT: SyntaxElementType = SyntaxElementType("SWITCH_STATEMENT") + val SWITCH_EXPRESSION: SyntaxElementType = SyntaxElementType("SWITCH_EXPRESSION") + val SWITCH_LABEL_STATEMENT: SyntaxElementType = SyntaxElementType("SWITCH_LABEL_STATEMENT") + val SWITCH_LABELED_RULE: SyntaxElementType = SyntaxElementType("SWITCH_LABELED_RULE") + val BREAK_STATEMENT: SyntaxElementType = SyntaxElementType("BREAK_STATEMENT") + val YIELD_STATEMENT: SyntaxElementType = SyntaxElementType("YIELD_STATEMENT") + val CONTINUE_STATEMENT: SyntaxElementType = SyntaxElementType("CONTINUE_STATEMENT") + val RETURN_STATEMENT: SyntaxElementType = SyntaxElementType("RETURN_STATEMENT") + val THROW_STATEMENT: SyntaxElementType = SyntaxElementType("THROW_STATEMENT") + val SYNCHRONIZED_STATEMENT: SyntaxElementType = SyntaxElementType("SYNCHRONIZED_STATEMENT") + val TRY_STATEMENT: SyntaxElementType = SyntaxElementType("TRY_STATEMENT") + val RESOURCE_LIST: SyntaxElementType = SyntaxElementType("RESOURCE_LIST") + val RESOURCE_VARIABLE: SyntaxElementType = SyntaxElementType("RESOURCE_VARIABLE") + val RESOURCE_EXPRESSION: SyntaxElementType = SyntaxElementType("RESOURCE_EXPRESSION") + val CATCH_SECTION: SyntaxElementType = SyntaxElementType("CATCH_SECTION") + val LABELED_STATEMENT: SyntaxElementType = SyntaxElementType("LABELED_STATEMENT") + val ASSERT_STATEMENT: SyntaxElementType = SyntaxElementType("ASSERT_STATEMENT") + val ANNOTATION_ARRAY_INITIALIZER: SyntaxElementType = SyntaxElementType("ANNOTATION_ARRAY_INITIALIZER") + val RECEIVER_PARAMETER: SyntaxElementType = SyntaxElementType("RECEIVER") + val MODULE_REFERENCE: SyntaxElementType = SyntaxElementType("MODULE_REFERENCE") + val TYPE_TEST_PATTERN: SyntaxElementType = SyntaxElementType("TYPE_TEST_PATTERN") + val UNNAMED_PATTERN: SyntaxElementType = SyntaxElementType("UNNAMED_PATTERN") + val PATTERN_VARIABLE: SyntaxElementType = SyntaxElementType("PATTERN_VARIABLE") + val DECONSTRUCTION_PATTERN: SyntaxElementType = SyntaxElementType("DECONSTRUCTION_PATTERN") + val DECONSTRUCTION_LIST: SyntaxElementType = SyntaxElementType("DECONSTRUCTION_LIST") + val DECONSTRUCTION_PATTERN_VARIABLE: SyntaxElementType = SyntaxElementType("DECONSTRUCTION_PATTERN_VARIABLE") + val DEFAULT_CASE_LABEL_ELEMENT: SyntaxElementType = SyntaxElementType("DEFAULT_CASE_LABEL_ELEMENT") + val CASE_LABEL_ELEMENT_LIST: SyntaxElementType = SyntaxElementType("CASE_LABEL_ELEMENT_LIST") + + val CODE_BLOCK: SyntaxElementType = SyntaxElementType("CODE_BLOCK") + + val MEMBERS: SyntaxElementType = SyntaxElementType("MEMBERS") + + val STATEMENTS: SyntaxElementType = SyntaxElementType("STATEMENTS") + val EXPRESSION_TEXT: SyntaxElementType = SyntaxElementType("EXPRESSION_TEXT") + val REFERENCE_TEXT: SyntaxElementType = SyntaxElementType("REFERENCE_TEXT") + val TYPE_WITH_DISJUNCTIONS_TEXT: SyntaxElementType = SyntaxElementType("TYPE_WITH_DISJUNCTIONS_TEXT") + val TYPE_WITH_CONJUNCTIONS_TEXT: SyntaxElementType = SyntaxElementType("TYPE_WITH_CONJUNCTIONS_TEXT") + val DUMMY_ELEMENT: SyntaxElementType = SyntaxElementType("DUMMY_ELEMENT") +} \ No newline at end of file diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxTokenType.kt b/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxTokenType.kt new file mode 100644 index 000000000000..c5974c83c5f7 --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/JavaSyntaxTokenType.kt @@ -0,0 +1,311 @@ +// 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.platform.syntax.SyntaxElementType +import com.intellij.platform.syntax.SyntaxElementTypeSet +import com.intellij.platform.syntax.syntaxElementTypeSetOf + +/** + * @see com.intellij.psi.JavaTokenType + */ +object JavaSyntaxTokenType { + val IDENTIFIER: SyntaxElementType = SyntaxElementType("IDENTIFIER") + val C_STYLE_COMMENT: SyntaxElementType = SyntaxElementType("C_STYLE_COMMENT") + val END_OF_LINE_COMMENT: SyntaxElementType = SyntaxElementType("END_OF_LINE_COMMENT") + + val INTEGER_LITERAL: SyntaxElementType = SyntaxElementType("INTEGER_LITERAL") + val LONG_LITERAL: SyntaxElementType = SyntaxElementType("LONG_LITERAL") + val FLOAT_LITERAL: SyntaxElementType = SyntaxElementType("FLOAT_LITERAL") + val DOUBLE_LITERAL: SyntaxElementType = SyntaxElementType("DOUBLE_LITERAL") + val CHARACTER_LITERAL: SyntaxElementType = SyntaxElementType("CHARACTER_LITERAL") + val STRING_LITERAL: SyntaxElementType = SyntaxElementType("STRING_LITERAL") + val TEXT_BLOCK_LITERAL: SyntaxElementType = SyntaxElementType("TEXT_BLOCK_LITERAL") + + val STRING_TEMPLATE_BEGIN: SyntaxElementType = SyntaxElementType("STRING_TEMPLATE_BEGIN") + val STRING_TEMPLATE_MID: SyntaxElementType = SyntaxElementType("STRING_TEMPLATE_MID") + val STRING_TEMPLATE_END: SyntaxElementType = SyntaxElementType("STRING_TEMPLATE_END") + val TEXT_BLOCK_TEMPLATE_BEGIN: SyntaxElementType = SyntaxElementType("TEXT_BLOCK_TEMPLATE_BEGIN") + val TEXT_BLOCK_TEMPLATE_MID: SyntaxElementType = SyntaxElementType("TEXT_BLOCK_TEMPLATE_MID") + val TEXT_BLOCK_TEMPLATE_END: SyntaxElementType = SyntaxElementType("TEXT_BLOCK_TEMPLATE_END") + + val TRUE_KEYWORD: SyntaxElementType = SyntaxElementType("TRUE_KEYWORD") + val FALSE_KEYWORD: SyntaxElementType = SyntaxElementType("FALSE_KEYWORD") + val NULL_KEYWORD: SyntaxElementType = SyntaxElementType("NULL_KEYWORD") + + val ABSTRACT_KEYWORD: SyntaxElementType = SyntaxElementType("ABSTRACT_KEYWORD") + val ASSERT_KEYWORD: SyntaxElementType = SyntaxElementType("ASSERT_KEYWORD") + val BOOLEAN_KEYWORD: SyntaxElementType = SyntaxElementType("BOOLEAN_KEYWORD") + val BREAK_KEYWORD: SyntaxElementType = SyntaxElementType("BREAK_KEYWORD") + val BYTE_KEYWORD: SyntaxElementType = SyntaxElementType("BYTE_KEYWORD") + val CASE_KEYWORD: SyntaxElementType = SyntaxElementType("CASE_KEYWORD") + val CATCH_KEYWORD: SyntaxElementType = SyntaxElementType("CATCH_KEYWORD") + val CHAR_KEYWORD: SyntaxElementType = SyntaxElementType("CHAR_KEYWORD") + val CLASS_KEYWORD: SyntaxElementType = SyntaxElementType("CLASS_KEYWORD") + val CONST_KEYWORD: SyntaxElementType = SyntaxElementType("CONST_KEYWORD") + val CONTINUE_KEYWORD: SyntaxElementType = SyntaxElementType("CONTINUE_KEYWORD") + val DEFAULT_KEYWORD: SyntaxElementType = SyntaxElementType("DEFAULT_KEYWORD") + val DO_KEYWORD: SyntaxElementType = SyntaxElementType("DO_KEYWORD") + val DOUBLE_KEYWORD: SyntaxElementType = SyntaxElementType("DOUBLE_KEYWORD") + val ELSE_KEYWORD: SyntaxElementType = SyntaxElementType("ELSE_KEYWORD") + val ENUM_KEYWORD: SyntaxElementType = SyntaxElementType("ENUM_KEYWORD") + val EXTENDS_KEYWORD: SyntaxElementType = SyntaxElementType("EXTENDS_KEYWORD") + val FINAL_KEYWORD: SyntaxElementType = SyntaxElementType("FINAL_KEYWORD") + val FINALLY_KEYWORD: SyntaxElementType = SyntaxElementType("FINALLY_KEYWORD") + val FLOAT_KEYWORD: SyntaxElementType = SyntaxElementType("FLOAT_KEYWORD") + val FOR_KEYWORD: SyntaxElementType = SyntaxElementType("FOR_KEYWORD") + val GOTO_KEYWORD: SyntaxElementType = SyntaxElementType("GOTO_KEYWORD") + val IF_KEYWORD: SyntaxElementType = SyntaxElementType("IF_KEYWORD") + val IMPLEMENTS_KEYWORD: SyntaxElementType = SyntaxElementType("IMPLEMENTS_KEYWORD") + val IMPORT_KEYWORD: SyntaxElementType = SyntaxElementType("IMPORT_KEYWORD") + val INSTANCEOF_KEYWORD: SyntaxElementType = SyntaxElementType("INSTANCEOF_KEYWORD") + val INT_KEYWORD: SyntaxElementType = SyntaxElementType("INT_KEYWORD") + val INTERFACE_KEYWORD: SyntaxElementType = SyntaxElementType("INTERFACE_KEYWORD") + val LONG_KEYWORD: SyntaxElementType = SyntaxElementType("LONG_KEYWORD") + val NATIVE_KEYWORD: SyntaxElementType = SyntaxElementType("NATIVE_KEYWORD") + val NEW_KEYWORD: SyntaxElementType = SyntaxElementType("NEW_KEYWORD") + val PACKAGE_KEYWORD: SyntaxElementType = SyntaxElementType("PACKAGE_KEYWORD") + val PRIVATE_KEYWORD: SyntaxElementType = SyntaxElementType("PRIVATE_KEYWORD") + val PUBLIC_KEYWORD: SyntaxElementType = SyntaxElementType("PUBLIC_KEYWORD") + val SHORT_KEYWORD: SyntaxElementType = SyntaxElementType("SHORT_KEYWORD") + val SUPER_KEYWORD: SyntaxElementType = SyntaxElementType("SUPER_KEYWORD") + val SWITCH_KEYWORD: SyntaxElementType = SyntaxElementType("SWITCH_KEYWORD") + val SYNCHRONIZED_KEYWORD: SyntaxElementType = SyntaxElementType("SYNCHRONIZED_KEYWORD") + val THIS_KEYWORD: SyntaxElementType = SyntaxElementType("THIS_KEYWORD") + val THROW_KEYWORD: SyntaxElementType = SyntaxElementType("THROW_KEYWORD") + val PROTECTED_KEYWORD: SyntaxElementType = SyntaxElementType("PROTECTED_KEYWORD") + val TRANSIENT_KEYWORD: SyntaxElementType = SyntaxElementType("TRANSIENT_KEYWORD") + val RETURN_KEYWORD: SyntaxElementType = SyntaxElementType("RETURN_KEYWORD") + val VOID_KEYWORD: SyntaxElementType = SyntaxElementType("VOID_KEYWORD") + val STATIC_KEYWORD: SyntaxElementType = SyntaxElementType("STATIC_KEYWORD") + val STRICTFP_KEYWORD: SyntaxElementType = SyntaxElementType("STRICTFP_KEYWORD") + val WHILE_KEYWORD: SyntaxElementType = SyntaxElementType("WHILE_KEYWORD") + val TRY_KEYWORD: SyntaxElementType = SyntaxElementType("TRY_KEYWORD") + val VOLATILE_KEYWORD: SyntaxElementType = SyntaxElementType("VOLATILE_KEYWORD") + val THROWS_KEYWORD: SyntaxElementType = SyntaxElementType("THROWS_KEYWORD") + + val LPARENTH: SyntaxElementType = SyntaxElementType("LPARENTH") + val RPARENTH: SyntaxElementType = SyntaxElementType("RPARENTH") + val LBRACE: SyntaxElementType = SyntaxElementType("LBRACE") + val RBRACE: SyntaxElementType = SyntaxElementType("RBRACE") + val LBRACKET: SyntaxElementType = SyntaxElementType("LBRACKET") + val RBRACKET: SyntaxElementType = SyntaxElementType("RBRACKET") + val SEMICOLON: SyntaxElementType = SyntaxElementType("SEMICOLON") + val COMMA: SyntaxElementType = SyntaxElementType("COMMA") + val DOT: SyntaxElementType = SyntaxElementType("DOT") + val ELLIPSIS: SyntaxElementType = SyntaxElementType("ELLIPSIS") + val AT: SyntaxElementType = SyntaxElementType("AT") + + val EQ: SyntaxElementType = SyntaxElementType("EQ") + val GT: SyntaxElementType = SyntaxElementType("GT") + val LT: SyntaxElementType = SyntaxElementType("LT") + val EXCL: SyntaxElementType = SyntaxElementType("EXCL") + val TILDE: SyntaxElementType = SyntaxElementType("TILDE") + val QUEST: SyntaxElementType = SyntaxElementType("QUEST") + val COLON: SyntaxElementType = SyntaxElementType("COLON") + val PLUS: SyntaxElementType = SyntaxElementType("PLUS") + val MINUS: SyntaxElementType = SyntaxElementType("MINUS") + val ASTERISK: SyntaxElementType = SyntaxElementType("ASTERISK") + val DIV: SyntaxElementType = SyntaxElementType("DIV") + val AND: SyntaxElementType = SyntaxElementType("AND") + val OR: SyntaxElementType = SyntaxElementType("OR") + val XOR: SyntaxElementType = SyntaxElementType("XOR") + val PERC: SyntaxElementType = SyntaxElementType("PERC") + + val EQEQ: SyntaxElementType = SyntaxElementType("EQEQ") + val LE: SyntaxElementType = SyntaxElementType("LE") + val GE: SyntaxElementType = SyntaxElementType("GE") + val NE: SyntaxElementType = SyntaxElementType("NE") + val ANDAND: SyntaxElementType = SyntaxElementType("ANDAND") + val OROR: SyntaxElementType = SyntaxElementType("OROR") + val PLUSPLUS: SyntaxElementType = SyntaxElementType("PLUSPLUS") + val MINUSMINUS: SyntaxElementType = SyntaxElementType("MINUSMINUS") + val LTLT: SyntaxElementType = SyntaxElementType("LTLT") + val GTGT: SyntaxElementType = SyntaxElementType("GTGT") + val GTGTGT: SyntaxElementType = SyntaxElementType("GTGTGT") + val PLUSEQ: SyntaxElementType = SyntaxElementType("PLUSEQ") + val MINUSEQ: SyntaxElementType = SyntaxElementType("MINUSEQ") + val ASTERISKEQ: SyntaxElementType = SyntaxElementType("ASTERISKEQ") + val DIVEQ: SyntaxElementType = SyntaxElementType("DIVEQ") + val ANDEQ: SyntaxElementType = SyntaxElementType("ANDEQ") + val OREQ: SyntaxElementType = SyntaxElementType("OREQ") + val XOREQ: SyntaxElementType = SyntaxElementType("XOREQ") + val PERCEQ: SyntaxElementType = SyntaxElementType("PERCEQ") + val LTLTEQ: SyntaxElementType = SyntaxElementType("LTLTEQ") + val GTGTEQ: SyntaxElementType = SyntaxElementType("GTGTEQ") + val GTGTGTEQ: SyntaxElementType = SyntaxElementType("GTGTGTEQ") + + val DOUBLE_COLON: SyntaxElementType = SyntaxElementType("DOUBLE_COLON") + val ARROW: SyntaxElementType = SyntaxElementType("ARROW") + + val OPEN_KEYWORD: SyntaxElementType = SyntaxElementType("OPEN") + val MODULE_KEYWORD: SyntaxElementType = SyntaxElementType("MODULE") + val REQUIRES_KEYWORD: SyntaxElementType = SyntaxElementType("REQUIRES") + val EXPORTS_KEYWORD: SyntaxElementType = SyntaxElementType("EXPORTS") + val OPENS_KEYWORD: SyntaxElementType = SyntaxElementType("OPENS") + val USES_KEYWORD: SyntaxElementType = SyntaxElementType("USES") + val PROVIDES_KEYWORD: SyntaxElementType = SyntaxElementType("PROVIDES") + val TRANSITIVE_KEYWORD: SyntaxElementType = SyntaxElementType("TRANSITIVE") + val TO_KEYWORD: SyntaxElementType = SyntaxElementType("TO") + val WITH_KEYWORD: SyntaxElementType = SyntaxElementType("WITH") + + val VAR_KEYWORD: SyntaxElementType = SyntaxElementType("VAR") + val YIELD_KEYWORD: SyntaxElementType = SyntaxElementType("YIELD") + val RECORD_KEYWORD: SyntaxElementType = SyntaxElementType("RECORD") + + val VALUE_KEYWORD: SyntaxElementType = SyntaxElementType("VALUE_KEYWORD") + val SEALED_KEYWORD: SyntaxElementType = SyntaxElementType("SEALED") + val NON_SEALED_KEYWORD: SyntaxElementType = SyntaxElementType("NON_SEALED") + val PERMITS_KEYWORD: SyntaxElementType = SyntaxElementType("PERMITS") + val WHEN_KEYWORD: SyntaxElementType = SyntaxElementType("WHEN_KEYWORD") + + val JAVA_TOKEN_TYPE_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + IDENTIFIER, + C_STYLE_COMMENT, + END_OF_LINE_COMMENT, + + INTEGER_LITERAL, + LONG_LITERAL, + FLOAT_LITERAL, + DOUBLE_LITERAL, + CHARACTER_LITERAL, + STRING_LITERAL, + TEXT_BLOCK_LITERAL, + + STRING_TEMPLATE_BEGIN, + STRING_TEMPLATE_MID, + STRING_TEMPLATE_END, + TEXT_BLOCK_TEMPLATE_BEGIN, + TEXT_BLOCK_TEMPLATE_MID, + TEXT_BLOCK_TEMPLATE_END, + + TRUE_KEYWORD, + FALSE_KEYWORD, + NULL_KEYWORD, + + 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, + PUBLIC_KEYWORD, + SHORT_KEYWORD, + SUPER_KEYWORD, + SWITCH_KEYWORD, + SYNCHRONIZED_KEYWORD, + THIS_KEYWORD, + THROW_KEYWORD, + PROTECTED_KEYWORD, + TRANSIENT_KEYWORD, + RETURN_KEYWORD, + VOID_KEYWORD, + STATIC_KEYWORD, + STRICTFP_KEYWORD, + WHILE_KEYWORD, + TRY_KEYWORD, + VOLATILE_KEYWORD, + THROWS_KEYWORD, + + LPARENTH, + RPARENTH, + LBRACE, + RBRACE, + LBRACKET, + RBRACKET, + SEMICOLON, + COMMA, + DOT, + ELLIPSIS, + AT, + + 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, + + DOUBLE_COLON, + ARROW, + + 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, + + VALUE_KEYWORD, + SEALED_KEYWORD, + NON_SEALED_KEYWORD, + PERMITS_KEYWORD, + WHEN_KEYWORD, + ) +} \ No newline at end of file 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 new file mode 100644 index 000000000000..72e9092addfb --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/SyntaxElementTypes.kt @@ -0,0 +1,104 @@ +// 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.platform.syntax.SyntaxElementTypeSet +import com.intellij.platform.syntax.element.SyntaxTokenTypes.WHITE_SPACE +import com.intellij.platform.syntax.syntaxElementTypeSetOf +import com.intellij.java.syntax.element.JavaSyntaxElementType as JElement +import com.intellij.java.syntax.element.JavaSyntaxTokenType as JToken + +object SyntaxElementTypes { + val JAVA_PLAIN_COMMENT_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.END_OF_LINE_COMMENT, JToken.C_STYLE_COMMENT) + val JAVA_COMMENT_BIT_SET: SyntaxElementTypeSet = JAVA_PLAIN_COMMENT_BIT_SET + JavaDocSyntaxElementType.DOC_COMMENT + val JAVA_COMMENT_OR_WHITESPACE_BIT_SET: SyntaxElementTypeSet = JAVA_COMMENT_BIT_SET + WHITE_SPACE + + val KEYWORD_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JToken.ABSTRACT_KEYWORD, JToken.ASSERT_KEYWORD, JToken.BOOLEAN_KEYWORD, JToken.BREAK_KEYWORD, JToken.BYTE_KEYWORD, JToken.CASE_KEYWORD, + JToken.CATCH_KEYWORD, JToken.CHAR_KEYWORD, JToken.CLASS_KEYWORD, JToken.CONST_KEYWORD, JToken.CONTINUE_KEYWORD, JToken.DEFAULT_KEYWORD, + JToken.DO_KEYWORD, JToken.DOUBLE_KEYWORD, JToken.ELSE_KEYWORD, JToken.ENUM_KEYWORD, JToken.EXTENDS_KEYWORD, JToken.FINAL_KEYWORD, + JToken.FINALLY_KEYWORD, JToken.FLOAT_KEYWORD, JToken.FOR_KEYWORD, JToken.GOTO_KEYWORD, JToken.IF_KEYWORD, JToken.IMPLEMENTS_KEYWORD, + JToken.IMPORT_KEYWORD, JToken.INSTANCEOF_KEYWORD, JToken.INT_KEYWORD, JToken.INTERFACE_KEYWORD, JToken.LONG_KEYWORD, JToken.NATIVE_KEYWORD, + JToken.NEW_KEYWORD, JToken.PACKAGE_KEYWORD, JToken.PRIVATE_KEYWORD, JToken.PROTECTED_KEYWORD, JToken.PUBLIC_KEYWORD, JToken.RETURN_KEYWORD, + JToken.SHORT_KEYWORD, JToken.SUPER_KEYWORD, JToken.STATIC_KEYWORD, JToken.STRICTFP_KEYWORD, JToken.SWITCH_KEYWORD, JToken.SYNCHRONIZED_KEYWORD, + JToken.THIS_KEYWORD, JToken.THROW_KEYWORD, JToken.THROWS_KEYWORD, JToken.TRANSIENT_KEYWORD, JToken.TRY_KEYWORD, JToken.VOID_KEYWORD, + JToken.VOLATILE_KEYWORD, JToken.WHILE_KEYWORD, JToken.OPEN_KEYWORD, JToken.MODULE_KEYWORD, JToken.REQUIRES_KEYWORD, JToken.EXPORTS_KEYWORD, + JToken.OPENS_KEYWORD, JToken.USES_KEYWORD, JToken.PROVIDES_KEYWORD, JToken.TRANSITIVE_KEYWORD, JToken.TO_KEYWORD, JToken.WITH_KEYWORD, + JToken.VAR_KEYWORD, JToken.YIELD_KEYWORD, JToken.RECORD_KEYWORD, JToken.SEALED_KEYWORD, JToken.PERMITS_KEYWORD, JToken.NON_SEALED_KEYWORD, + JToken.WHEN_KEYWORD, JToken.VALUE_KEYWORD + ) + + val LITERAL_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.TRUE_KEYWORD, JToken.FALSE_KEYWORD, JToken.NULL_KEYWORD) + + val OPERATION_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JToken.EQ, JToken.GT, JToken.LT, JToken.EXCL, JToken.TILDE, JToken.QUEST, JToken.COLON, JToken.PLUS, JToken.MINUS, JToken.ASTERISK, + JToken.DIV, JToken.AND, JToken.OR, JToken.XOR, JToken.PERC, JToken.EQEQ, JToken.LE, JToken.GE, JToken.NE, JToken.ANDAND, JToken.OROR, + JToken.PLUSPLUS, JToken.MINUSMINUS, JToken.LTLT, JToken.GTGT, JToken.GTGTGT, JToken.PLUSEQ, JToken.MINUSEQ, JToken.ASTERISKEQ, + JToken.DIVEQ, JToken.ANDEQ, JToken.OREQ, JToken.XOREQ, JToken.PERCEQ, JToken.LTLTEQ, JToken.GTGTEQ, JToken.GTGTGTEQ + ) + + val MODIFIER_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JToken.PUBLIC_KEYWORD, JToken.PROTECTED_KEYWORD, JToken.PRIVATE_KEYWORD, JToken.STATIC_KEYWORD, JToken.ABSTRACT_KEYWORD, + JToken.FINAL_KEYWORD, JToken.NATIVE_KEYWORD, JToken.SYNCHRONIZED_KEYWORD, JToken.STRICTFP_KEYWORD, JToken.TRANSIENT_KEYWORD, + JToken.VOLATILE_KEYWORD, JToken.DEFAULT_KEYWORD, JToken.SEALED_KEYWORD, JToken.NON_SEALED_KEYWORD, JToken.VALUE_KEYWORD + ) + + val PRIMITIVE_TYPE_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JToken.BOOLEAN_KEYWORD, JToken.BYTE_KEYWORD, JToken.SHORT_KEYWORD, JToken.INT_KEYWORD, JToken.LONG_KEYWORD, JToken.CHAR_KEYWORD, + JToken.FLOAT_KEYWORD, JToken.DOUBLE_KEYWORD, JToken.VOID_KEYWORD + ) + + val EXPRESSION_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JElement.REFERENCE_EXPRESSION, JElement.LITERAL_EXPRESSION, JElement.THIS_EXPRESSION, JElement.SUPER_EXPRESSION, + JElement.PARENTH_EXPRESSION, JElement.METHOD_CALL_EXPRESSION, JElement.TYPE_CAST_EXPRESSION, JElement.PREFIX_EXPRESSION, + JElement.POSTFIX_EXPRESSION, JElement.BINARY_EXPRESSION, JElement.POLYADIC_EXPRESSION, JElement.CONDITIONAL_EXPRESSION, + JElement.ASSIGNMENT_EXPRESSION, JElement.NEW_EXPRESSION, JElement.ARRAY_ACCESS_EXPRESSION, JElement.ARRAY_INITIALIZER_EXPRESSION, + JElement.INSTANCE_OF_EXPRESSION, JElement.CLASS_OBJECT_ACCESS_EXPRESSION, JElement.METHOD_REF_EXPRESSION, JElement.LAMBDA_EXPRESSION, + JElement.SWITCH_EXPRESSION, JElement.EMPTY_EXPRESSION, JElement.TEMPLATE_EXPRESSION + ) + + val ANNOTATION_MEMBER_VALUE_BIT_SET: SyntaxElementTypeSet = EXPRESSION_BIT_SET + JElement.ANNOTATION + JElement.ANNOTATION_ARRAY_INITIALIZER + + val ARRAY_DIMENSION_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JElement.REFERENCE_EXPRESSION, JElement.LITERAL_EXPRESSION, JElement.THIS_EXPRESSION, JElement.SUPER_EXPRESSION, + JElement.PARENTH_EXPRESSION, JElement.METHOD_CALL_EXPRESSION, JElement.TYPE_CAST_EXPRESSION, JElement.PREFIX_EXPRESSION, + JElement.POSTFIX_EXPRESSION, JElement.BINARY_EXPRESSION, JElement.POLYADIC_EXPRESSION, JElement.CONDITIONAL_EXPRESSION, + JElement.ASSIGNMENT_EXPRESSION, JElement.NEW_EXPRESSION, JElement.ARRAY_ACCESS_EXPRESSION, JElement.INSTANCE_OF_EXPRESSION, + JElement.CLASS_OBJECT_ACCESS_EXPRESSION, JElement.EMPTY_EXPRESSION + ) + + val JAVA_STATEMENT_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JElement.EMPTY_STATEMENT, JElement.BLOCK_STATEMENT, JElement.EXPRESSION_STATEMENT, JElement.EXPRESSION_LIST_STATEMENT, + JElement.DECLARATION_STATEMENT, JElement.IF_STATEMENT, JElement.WHILE_STATEMENT, JElement.FOR_STATEMENT, JElement.FOREACH_STATEMENT, + JElement.DO_WHILE_STATEMENT, JElement.SWITCH_STATEMENT, JElement.SWITCH_LABEL_STATEMENT, JElement.BREAK_STATEMENT, + JElement.CONTINUE_STATEMENT, JElement.RETURN_STATEMENT, JElement.THROW_STATEMENT, JElement.SYNCHRONIZED_STATEMENT, + JElement.TRY_STATEMENT, JElement.LABELED_STATEMENT, JElement.ASSERT_STATEMENT, JElement.YIELD_STATEMENT + ) + + val JAVA_PATTERN_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf(JElement.TYPE_TEST_PATTERN, JElement.DECONSTRUCTION_PATTERN, JElement.UNNAMED_PATTERN) + + val JAVA_CASE_LABEL_ELEMENT_BIT_SET: SyntaxElementTypeSet = JAVA_PATTERN_BIT_SET + EXPRESSION_BIT_SET + JElement.DEFAULT_CASE_LABEL_ELEMENT + + val JAVA_MODULE_STATEMENT_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JElement.REQUIRES_STATEMENT, JElement.EXPORTS_STATEMENT, JElement.OPENS_STATEMENT, JElement.USES_STATEMENT, JElement.PROVIDES_STATEMENT + ) + + val IMPORT_STATEMENT_BASE_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JElement.IMPORT_STATEMENT, JElement.IMPORT_STATIC_STATEMENT, JElement.IMPORT_MODULE_STATEMENT + ) + + val CLASS_KEYWORD_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.CLASS_KEYWORD, JToken.INTERFACE_KEYWORD, JToken.ENUM_KEYWORD, JToken.RECORD_KEYWORD) + val MEMBER_BIT_SET: SyntaxElementTypeSet = syntaxElementTypeSetOf(JElement.CLASS, JElement.FIELD, JElement.ENUM_CONSTANT, JElement.METHOD, JElement.ANNOTATION_METHOD) + val FULL_MEMBER_BIT_SET: SyntaxElementTypeSet = MEMBER_BIT_SET + JElement.CLASS_INITIALIZER + + val INTEGER_LITERALS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.INTEGER_LITERAL, JToken.LONG_LITERAL) + val REAL_LITERALS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.FLOAT_LITERAL, JToken.DOUBLE_LITERAL) + val STRING_LITERALS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.STRING_LITERAL, JToken.TEXT_BLOCK_LITERAL) + val TEXT_LITERALS: SyntaxElementTypeSet = syntaxElementTypeSetOf(JToken.STRING_LITERAL, JToken.TEXT_BLOCK_LITERAL, JToken.CHARACTER_LITERAL) + + val STRING_TEMPLATE_FRAGMENTS: SyntaxElementTypeSet = syntaxElementTypeSetOf( + JToken.STRING_TEMPLATE_BEGIN, JToken.STRING_TEMPLATE_MID, JToken.STRING_TEMPLATE_END, JToken.TEXT_BLOCK_TEMPLATE_BEGIN, + JToken.TEXT_BLOCK_TEMPLATE_MID, JToken.TEXT_BLOCK_TEMPLATE_END + ) + + val ALL_LITERALS: SyntaxElementTypeSet = INTEGER_LITERALS + REAL_LITERALS + TEXT_LITERALS + LITERAL_BIT_SET +} diff --git a/java/java-syntax/src/com/intellij/java/syntax/element/WhiteSpaceAndCommentSetHolder.kt b/java/java-syntax/src/com/intellij/java/syntax/element/WhiteSpaceAndCommentSetHolder.kt new file mode 100644 index 000000000000..8a6cd1c0f137 --- /dev/null +++ b/java/java-syntax/src/com/intellij/java/syntax/element/WhiteSpaceAndCommentSetHolder.kt @@ -0,0 +1,136 @@ +// 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.openapi.util.text.containsLineBreak +import com.intellij.openapi.util.text.getLineBreakCount +import com.intellij.platform.syntax.SyntaxElementType +import com.intellij.platform.syntax.SyntaxElementTypeSet +import com.intellij.platform.syntax.element.SyntaxTokenTypes.WHITE_SPACE +import com.intellij.platform.syntax.parser.WhitespacesAndCommentsBinder +import com.intellij.platform.syntax.syntaxElementTypeSetOf +import com.intellij.pom.java.JavaFeature +import com.intellij.pom.java.LanguageLevel + +/** + * @see com.intellij.psi.impl.source.WhiteSpaceAndCommentSetHolder + */ +object WhiteSpaceAndCommentSetHolder { + private val PRECEDING_COMMENT_BINDER_WITH_MARKDOWN: WhitespacesAndCommentsBinder = PrecedingWhitespacesAndCommentsBinder(false, true) + private val SPECIAL_PRECEDING_COMMENT_BINDER_WITH_MARKDOWN: WhitespacesAndCommentsBinder = PrecedingWhitespacesAndCommentsBinder(true, true) + private val PRECEDING_COMMENT_BINDER_WITHOUT_MARKDOWN: WhitespacesAndCommentsBinder = PrecedingWhitespacesAndCommentsBinder(false, false) + private val SPECIAL_PRECEDING_COMMENT_BINDER_WITHOUT_MARKDOWN: WhitespacesAndCommentsBinder = PrecedingWhitespacesAndCommentsBinder(true, false) + private val TRAILING_COMMENT_BINDER: WhitespacesAndCommentsBinder = TrailingWhitespacesAndCommentsBinder() + + fun getPrecedingCommentBinder(myLanguageLevel: LanguageLevel): WhitespacesAndCommentsBinder { + return if (JavaFeature.MARKDOWN_COMMENT.isSufficient(myLanguageLevel)) + PRECEDING_COMMENT_BINDER_WITH_MARKDOWN + else + PRECEDING_COMMENT_BINDER_WITHOUT_MARKDOWN + } + + fun getSpecialPrecedingCommentBinder(myLanguageLevel: LanguageLevel): WhitespacesAndCommentsBinder { + return if (JavaFeature.MARKDOWN_COMMENT.isSufficient(myLanguageLevel)) + SPECIAL_PRECEDING_COMMENT_BINDER_WITH_MARKDOWN + else + SPECIAL_PRECEDING_COMMENT_BINDER_WITHOUT_MARKDOWN + } + + val trailingCommentBinder: WhitespacesAndCommentsBinder + get() = TRAILING_COMMENT_BINDER + + val precedingCommentSet: SyntaxElementTypeSet = + syntaxElementTypeSetOf(JavaSyntaxElementType.MODULE, JavaSyntaxElementType.IMPLICIT_CLASS) + + SyntaxElementTypes.FULL_MEMBER_BIT_SET + + val trailingCommentSet: SyntaxElementTypeSet = + syntaxElementTypeSetOf(JavaSyntaxElementType.PACKAGE_STATEMENT) + + SyntaxElementTypes.IMPORT_STATEMENT_BASE_BIT_SET + + SyntaxElementTypes.FULL_MEMBER_BIT_SET + + SyntaxElementTypes.JAVA_STATEMENT_BIT_SET +} + +private class PrecedingWhitespacesAndCommentsBinder( + private val myAfterEmptyImport: Boolean, + private val mySupportMarkdown: Boolean, +) : WhitespacesAndCommentsBinder { + override fun getEdgePosition(tokens: List, atStreamEdge: Boolean, getter: WhitespacesAndCommentsBinder.TokenTextGetter): Int { + if (tokens.isEmpty()) return 0 + + + // 1. bind doc comment + // now there are markdown comments. + if (mySupportMarkdown) { + //collect everything + for (idx in tokens.indices.reversed()) { + if (tokens[idx] === JavaDocSyntaxElementType.DOC_COMMENT) return idx + } + } + else { + // To preserve previous orders, let's try to find the first non-markdown comment (and skip markdown comments). + // If there is no non-markdown, take the first markdown + for (idx in tokens.indices.reversed()) { + if (tokens[idx] === JavaDocSyntaxElementType.DOC_COMMENT && !isDocMarkdownComment(idx, getter)) { + return idx + } + } + + for (idx in tokens.indices.reversed()) { + if (tokens[idx] === JavaDocSyntaxElementType.DOC_COMMENT) return idx + } + } + + // 2. bind plain comments + var result = tokens.size + for (idx in tokens.indices.reversed()) { + val tokenType = tokens[idx] + if (tokenType === WHITE_SPACE) { + if (getter.get(idx).getLineBreakCount() > 1) { + break + } + } + else if (SyntaxElementTypes.JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) { + if (atStreamEdge || + (idx == 0 && myAfterEmptyImport) || + (idx > 0 && tokens[idx - 1] === WHITE_SPACE) && getter.get(idx - 1).containsLineBreak()) { + result = idx + } + } + else { + break + } + } + + return result + } + + private fun isDocMarkdownComment(idx: Int, getter: WhitespacesAndCommentsBinder.TokenTextGetter): Boolean { + val sequence = getter.get(idx) + return sequence.startsWith("///") + } +} + +private class TrailingWhitespacesAndCommentsBinder : WhitespacesAndCommentsBinder { + override fun getEdgePosition( + tokens: List, + atStreamEdge: Boolean, + getter: WhitespacesAndCommentsBinder.TokenTextGetter, + ): Int { + if (tokens.isEmpty()) return 0 + + var result = 0 + for (idx in tokens.indices) { + val tokenType = tokens[idx] + if (tokenType === WHITE_SPACE) { + if (getter.get(idx).containsLineBreak()) break + } + else if (SyntaxElementTypes.JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) { + result = idx + 1 + } + else { + break + } + } + + return result + } +}