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

[java-rd] IDEA-322563 refactoring for java rem-dev

Browse Source 
- rename basic token sets to BASIC_

GitOrigin-RevId: 1f6191a6fddbee5676fefeff2e40d718b15dee53
This commit is contained in:
Mikhail Pyltsin
2023-09-22 18:09:14 +02:00
committed by intellij-monorepo-bot
parent bb5b036281
commit e2bf8301c0
24 changed files with 121 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -17,8 +17,8 @@ import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.TEXT_LITERALS;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_TEXT_LITERALS;
import static com.intellij.psi.impl.source.BasicJavaElementType.BASIC_LITERAL_EXPRESSION;
import static com.intellij.psi.impl.source.BasicJavaElementType.REFERENCE_EXPRESSION_SET;
@@ -26,12 +26,12 @@ public class JavaQuoteHandler extends SimpleTokenSetQuoteHandler implements Java
private final BasicJavaTokenSet myConcatenableStrings = BasicJavaTokenSet.create(JavaTokenType.STRING_LITERAL);
private final BasicJavaTokenSet myAppropriateElementTypeForLiteral = BasicJavaTokenSet.orSet(
BasicJavaTokenSet.create(JavaDocTokenType.ALL_JAVADOC_TOKENS),
JAVA_COMMENT_OR_WHITESPACE_BIT_SET, TEXT_LITERALS,
BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET, BASIC_TEXT_LITERALS,
BasicJavaTokenSet.create(JavaTokenType.SEMICOLON, JavaTokenType.COMMA, JavaTokenType.RPARENTH, JavaTokenType.RBRACKET,
JavaTokenType.RBRACE));
public JavaQuoteHandler() {
super(BasicJavaTokenSet.orSet(TEXT_LITERALS, BasicJavaTokenSet.create(JavaDocTokenType.DOC_TAG_VALUE_QUOTE)).toTokenSet());
super(BasicJavaTokenSet.orSet(BASIC_TEXT_LITERALS, BasicJavaTokenSet.create(JavaDocTokenType.DOC_TAG_VALUE_QUOTE)).toTokenSet());
}
@Override

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

@@ -33,7 +33,7 @@ import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
public abstract class AbstractBasicJavaSmartEnterProcessor extends SmartEnterProcessor {
@@ -300,7 +300,7 @@ public abstract class AbstractBasicJavaSmartEnterProcessor extends SmartEnterPro
return each.getPsi();
}
if (BasicJavaAstTreeUtil.is(each, BASIC_CODE_BLOCK) ||
BasicJavaAstTreeUtil.is(each, JAVA_COMMENT_BIT_SET)) {
BasicJavaAstTreeUtil.is(each, BASIC_JAVA_COMMENT_BIT_SET)) {
return null;
}
if (BasicJavaAstTreeUtil.is(each, STATEMENT_SET)) {

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

@@ -17,7 +17,7 @@ import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
public abstract class AbstractBasicSemicolonFixer implements Fixer {
@@ -93,7 +93,7 @@ public abstract class AbstractBasicSemicolonFixer implements Fixer {
int tailLength = 0;
ASTNode leaf = TreeUtil.findLastLeaf(astNode);
while (leaf != null && JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(leaf.getElementType())) {
while (leaf != null && BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(leaf.getElementType())) {
tailLength += leaf.getTextLength();
leaf = TreeUtil.prevLeaf(leaf);
}

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

@@ -34,7 +34,7 @@ import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
public class CommentBreakerEnterProcessor implements ASTNodeEnterProcessor {
private final BasicJavaTokenSet myCommentTypes = BasicJavaTokenSet.orSet(
BasicElementTypes.JAVA_PLAIN_COMMENT_BIT_SET, BasicJavaTokenSet.create(DOC_COMMENT)
BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET, BasicJavaTokenSet.create(DOC_COMMENT)
);
@Override

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

@@ -13,7 +13,7 @@ import com.intellij.psi.util.PsiUtilCore;
import com.intellij.util.IncorrectOperationException;
import org.jetbrains.annotations.NotNull;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_PLAIN_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
@@ -43,7 +43,7 @@ public class IfConditionFixer implements Fixer {
innerComment = lastChild.getText();
}
else if (BasicJavaAstTreeUtil.is(lastChild, DOC_COMMENT) ||
BasicJavaAstTreeUtil.is(lastChild, JAVA_PLAIN_COMMENT_BIT_SET)
BasicJavaAstTreeUtil.is(lastChild, BASIC_JAVA_PLAIN_COMMENT_BIT_SET)
) {
lastComment = lastChild.getText();
}

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

@@ -12,7 +12,7 @@ import org.jetbrains.annotations.NotNull;
import java.util.function.Predicate;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.*;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
@@ -30,7 +30,7 @@ public abstract class AbstractBasicBackBasicSelectioner extends ExtendWordSelect
ASTNode node = BasicJavaAstTreeUtil.toNode(e);
return
!BasicJavaAstTreeUtil.is(node, TokenType.WHITE_SPACE) &&
!BasicJavaAstTreeUtil.is(node, JAVA_COMMENT_BIT_SET) &&
!BasicJavaAstTreeUtil.is(node, BASIC_JAVA_COMMENT_BIT_SET) &&
!BasicJavaAstTreeUtil.is(node, BASIC_CODE_BLOCK) &&
!BasicJavaAstTreeUtil.is(node, BASIC_ARRAY_INITIALIZER_EXPRESSION) &&
!BasicJavaAstTreeUtil.is(node, BASIC_PARAMETER_LIST) &&

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

@@ -17,7 +17,7 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET;
public class AntLikePropertySelectionHandler extends ExtendWordSelectionHandlerBase {
@Override
@@ -49,7 +49,7 @@ public class AntLikePropertySelectionHandler extends ExtendWordSelectionHandlerB
return false;
}
if (BasicJavaAstTreeUtil.getParentOfType(BasicJavaAstTreeUtil.toNode(e), JAVA_COMMENT_BIT_SET) == null) {
if (BasicJavaAstTreeUtil.getParentOfType(BasicJavaAstTreeUtil.toNode(e), BASIC_JAVA_COMMENT_BIT_SET) == null) {
return true;
}
return PsiTreeUtil.getParentOfType(e, PsiComment.class) == null;

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

@@ -15,7 +15,7 @@ import org.jetbrains.annotations.NotNull;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.STRING_LITERALS;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_STRING_LITERALS;
import static com.intellij.psi.impl.source.BasicJavaElementType.BASIC_LITERAL_EXPRESSION;
public class LiteralSelectioner extends AbstractBasicBackBasicSelectioner {
@@ -27,7 +27,7 @@ public class LiteralSelectioner extends AbstractBasicBackBasicSelectioner {
}
private static boolean isStringLiteral(PsiElement element) {
return BasicJavaAstTreeUtil.is(BasicJavaAstTreeUtil.toNode(element), STRING_LITERALS)
return BasicJavaAstTreeUtil.is(BasicJavaAstTreeUtil.toNode(element), BASIC_STRING_LITERALS)
&& element.getText().startsWith("\"")
&& element.getText().endsWith("\"");
}

8
java/java-frontback-impl/src/com/intellij/codeInsight/editorActions/wordSelection/MethodOrClassSelectioner.java
View File

@@ -14,8 +14,8 @@ import java.util.Collection;
import java.util.Collections;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
@@ -57,8 +57,8 @@ public class MethodOrClassSelectioner extends AbstractBasicBackBasicSelectioner
firstChild = children.get(i++);
}
if (BasicJavaAstTreeUtil.is(firstChild, JAVA_COMMENT_BIT_SET)) {
while (BasicJavaAstTreeUtil.is(children.get(i), JAVA_COMMENT_OR_WHITESPACE_BIT_SET)) {
if (BasicJavaAstTreeUtil.is(firstChild, BASIC_JAVA_COMMENT_BIT_SET)) {
while (BasicJavaAstTreeUtil.is(children.get(i), BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET)) {
i++;
}
ASTNode last = BasicJavaAstTreeUtil.isWhiteSpace(children.get(i - 1)) ? children.get(i - 2) : children.get(i - 1);

8
java/java-frontback-impl/src/com/intellij/codeInsight/highlighting/JavaBraceMatcher.java
View File

@@ -41,7 +41,7 @@ public class JavaBraceMatcher implements PairedBraceMatcher {
}
private static boolean isPairedBracesAllowedBeforeTypeInJava(final IElementType tokenType) {
return JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(tokenType)
return BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains(tokenType)
|| tokenType == JavaTokenType.SEMICOLON
|| tokenType == JavaTokenType.COMMA
|| tokenType == JavaTokenType.RPARENTH
@@ -65,15 +65,15 @@ public class JavaBraceMatcher implements PairedBraceMatcher {
TextRange range = DeclarationRangeUtil.getDeclarationRange(parentNode.getPsi());
return range.getStartOffset();
}
else if (BasicJavaAstTreeUtil.is(parentNode, JAVA_STATEMENT_BIT_SET)) {
else if (BasicJavaAstTreeUtil.is(parentNode, BASIC_JAVA_STATEMENT_BIT_SET)) {
if (BasicJavaAstTreeUtil.is(parentNode, BASIC_BLOCK_STATEMENT) &&
BasicJavaAstTreeUtil.is(parentNode.getTreeParent(), JAVA_STATEMENT_BIT_SET)) {
BasicJavaAstTreeUtil.is(parentNode.getTreeParent(), BASIC_JAVA_STATEMENT_BIT_SET)) {
parentNode = parentNode.getTreeParent();
}
return parentNode.getTextRange().getStartOffset();
}
}
else if (BasicJavaAstTreeUtil.is(parentNode, CLASS_KEYWORD_BIT_SET)) {
else if (BasicJavaAstTreeUtil.is(parentNode, BASIC_CLASS_KEYWORD_BIT_SET)) {
TextRange range = DeclarationRangeUtil.getDeclarationRange(parent);
return range.getStartOffset();
}

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

@@ -14,7 +14,7 @@ public class JavaPairedBraceMatcher extends PairedBraceAndAnglesMatcher {
private static class Holder {
private static final BasicJavaTokenSet TYPE_TOKENS =
BasicJavaTokenSet.orSet(BaseJavaJspElementType.WHITE_SPACE_BIT_SET,
BasicElementTypes.JAVA_COMMENT_BIT_SET,
BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET,
BasicJavaTokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.COMMA,
JavaTokenType.AT,//anno
JavaTokenType.RBRACKET, JavaTokenType.LBRACKET, //arrays

6
java/java-frontback-impl/src/com/intellij/ide/highlighter/AbstractBasicJavaFileHighlighter.java
View File

@@ -29,9 +29,9 @@ public abstract class AbstractBasicJavaFileHighlighter extends SyntaxHighlighter
ourMap1 = new HashMap<>();
ourMap2 = new HashMap<>();
fillMap(ourMap1, KEYWORD_BIT_SET.toTokenSet(), JavaHighlightingColors.KEYWORD);
fillMap(ourMap1, LITERAL_BIT_SET.toTokenSet(), JavaHighlightingColors.KEYWORD);
fillMap(ourMap1, OPERATION_BIT_SET.toTokenSet(), JavaHighlightingColors.OPERATION_SIGN);
fillMap(ourMap1, BASIC_KEYWORD_BIT_SET.toTokenSet(), JavaHighlightingColors.KEYWORD);
fillMap(ourMap1, BASIC_LITERAL_BIT_SET.toTokenSet(), JavaHighlightingColors.KEYWORD);
fillMap(ourMap1, BASIC_OPERATION_BIT_SET.toTokenSet(), JavaHighlightingColors.OPERATION_SIGN);
for (IElementType type : JavaDocTokenType.ALL_JAVADOC_TOKENS.getTypes()) {
ourMap1.put(type, JavaHighlightingColors.DOC_COMMENT);

2
java/java-frontback-impl/src/com/intellij/lexer/JavaStringLiteralLexer.java
View File

@@ -25,7 +25,7 @@ class JavaStringLiteralLexer extends StringLiteralLexer {
IElementType tokenType = super.getTokenType();
if (tokenType == StringEscapesTokenTypes.INVALID_CHARACTER_ESCAPE_TOKEN) {
char c = myBuffer.charAt(myStart + 1);
if (c == '{' && BasicElementTypes.STRING_TEMPLATE_FRAGMENTS.contains(myOriginalLiteralToken)) {
if (c == '{' && BasicElementTypes.BASIC_STRING_TEMPLATE_FRAGMENTS.contains(myOriginalLiteralToken)) {
// don't highlight \{ in template fragment as bad escape
return myOriginalLiteralToken;
}

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

@@ -51,7 +51,7 @@ public class BasicDeclarationParser {
myParser = javaParser;
myJavaElementTypeContainer = javaParser.getJavaElementTypeFactory().getContainer();
TYPE_START = TokenSet.orSet(
PRIMITIVE_TYPE_BIT_SET.toTokenSet(),
BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(),
TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT, JavaTokenType.VAR_KEYWORD));
RESOURCE_EXPRESSIONS = TokenSet.create(
myJavaElementTypeContainer.REFERENCE_EXPRESSION, myJavaElementTypeContainer.THIS_EXPRESSION,
@@ -96,7 +96,7 @@ public class BasicDeclarationParser {
builder.remapCurrentToken(JavaTokenType.RECORD_KEYWORD);
keywordTokenType = JavaTokenType.RECORD_KEYWORD;
}
assert CLASS_KEYWORD_BIT_SET.contains(keywordTokenType) : keywordTokenType;
assert BASIC_CLASS_KEYWORD_BIT_SET.contains(keywordTokenType) : keywordTokenType;
builder.advanceLexer();
final boolean isEnum = (keywordTokenType == JavaTokenType.ENUM_KEYWORD);
@@ -264,8 +264,8 @@ public class BasicDeclarationParser {
builder.advanceLexer();
return null;
}
else if (!MODIFIER_BIT_SET.contains(tokenType) &&
!CLASS_KEYWORD_BIT_SET.contains(tokenType) &&
else if (!BASIC_MODIFIER_BIT_SET.contains(tokenType) &&
!BASIC_CLASS_KEYWORD_BIT_SET.contains(tokenType) &&
tokenType != JavaTokenType.AT &&
(context == BaseContext.CODE_BLOCK || tokenType != JavaTokenType.LT)) {
return null;
@@ -289,7 +289,7 @@ public class BasicDeclarationParser {
return null;
}
}
if (CLASS_KEYWORD_BIT_SET.contains(builder.getTokenType()) || isRecordToken(builder, builder.getTokenType())) {
if (BASIC_CLASS_KEYWORD_BIT_SET.contains(builder.getTokenType()) || isRecordToken(builder, builder.getTokenType())) {
final PsiBuilder.Marker result = parseClassFromKeyword(builder, declaration, false, context);
return result != null ? result : modList;
}
@@ -437,7 +437,7 @@ public class BasicDeclarationParser {
@NotNull
public Pair<PsiBuilder.Marker, Boolean> parseModifierList(final PsiBuilder builder) {
return parseModifierList(builder, MODIFIER_BIT_SET.toTokenSet());
return parseModifierList(builder, BASIC_MODIFIER_BIT_SET.toTokenSet());
}
@NotNull
@@ -463,7 +463,7 @@ public class BasicDeclarationParser {
isEmpty = false;
}
else if (tokenType == JavaTokenType.AT) {
if (KEYWORD_BIT_SET.contains(builder.lookAhead(1))) {
if (BASIC_KEYWORD_BIT_SET.contains(builder.lookAhead(1))) {
break;
}
parseAnnotation(builder);

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

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

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

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

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

@@ -49,7 +49,7 @@ public class BasicOldExpressionParser {
myParser = javaParser;
myJavaElementTypeContainer = javaParser.getJavaElementTypeFactory().getContainer();
TYPE_START = TokenSet.orSet(
PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
}
@Nullable
@@ -528,7 +528,7 @@ public class BasicOldExpressionParser {
return parseStringTemplate(builder, null, tokenType == JavaTokenType.TEXT_BLOCK_TEMPLATE_BEGIN);
}
if (ALL_LITERALS.contains(tokenType)) {
if (BASIC_ALL_LITERALS.contains(tokenType)) {
final PsiBuilder.Marker literal = builder.mark();
builder.advanceLexer();
literal.done(myJavaElementTypeContainer.LITERAL_EXPRESSION);
@@ -753,7 +753,7 @@ public class BasicOldExpressionParser {
return newExpr;
}
}
else if (PRIMITIVE_TYPE_BIT_SET.contains(tokenType)) {
else if (BASIC_PRIMITIVE_TYPE_BIT_SET.contains(tokenType)) {
refOrType = null;
builder.advanceLexer();
}
@@ -825,7 +825,7 @@ public class BasicOldExpressionParser {
private PsiBuilder.Marker parseClassAccessOrMethodReference(PsiBuilder builder) {
PsiBuilder.Marker expr = builder.mark();
boolean primitive = PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
boolean primitive = BASIC_PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
if (myParser.getReferenceParser().parseType(builder, 0) == null) {
expr.drop();
return null;
@@ -894,8 +894,8 @@ public class BasicOldExpressionParser {
isTyped = false;
}
else if (nextToken1 == JavaTokenType.AT ||
MODIFIER_BIT_SET.contains(nextToken1) ||
PRIMITIVE_TYPE_BIT_SET.contains(nextToken1)) {
BASIC_MODIFIER_BIT_SET.contains(nextToken1) ||
BASIC_PRIMITIVE_TYPE_BIT_SET.contains(nextToken1)) {
isLambda = true;
isTyped = true;
}

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

@@ -35,7 +35,7 @@ public class BasicPrattExpressionParser {
JavaTokenType.IDENTIFIER, TokenType.BAD_CHARACTER, JavaTokenType.COMMA, JavaTokenType.INTEGER_LITERAL, JavaTokenType.STRING_LITERAL);
private static final TokenSet ARGS_LIST_END = TokenSet.create(JavaTokenType.RPARENTH, JavaTokenType.RBRACE, JavaTokenType.RBRACKET);
private final TokenSet TYPE_START = TokenSet.orSet(PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
private final TokenSet TYPE_START = TokenSet.orSet(BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet(), TokenSet.create(JavaTokenType.IDENTIFIER, JavaTokenType.AT));
private static final TokenSet POSTFIX_OPS = TokenSet.create(JavaTokenType.PLUSPLUS, JavaTokenType.MINUSMINUS);
private static final TokenSet PREF_ARITHMETIC_OPS = TokenSet.orSet(POSTFIX_OPS, TokenSet.create(JavaTokenType.PLUS, JavaTokenType.MINUS));
private static final TokenSet PREFIX_OPS = TokenSet.orSet(PREF_ARITHMETIC_OPS, TokenSet.create(JavaTokenType.TILDE, JavaTokenType.EXCL));
@@ -383,7 +383,7 @@ public class BasicPrattExpressionParser {
private PsiBuilder.Marker parsePrimaryExpressionStart(final PsiBuilder builder, final int mode) {
IElementType tokenType = builder.getTokenType();
if (ALL_LITERALS.contains(tokenType)) {
if (BASIC_ALL_LITERALS.contains(tokenType)) {
final PsiBuilder.Marker literal = builder.mark();
builder.advanceLexer();
literal.done(myJavaElementTypeContainer.LITERAL_EXPRESSION);
@@ -513,7 +513,7 @@ public class BasicPrattExpressionParser {
private PsiBuilder.Marker parseClassAccessOrMethodReference(PsiBuilder builder) {
PsiBuilder.Marker expr = builder.mark();
boolean primitive = PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
boolean primitive = BASIC_PRIMITIVE_TYPE_BIT_SET.contains(builder.getTokenType());
if (myParser.getReferenceParser().parseType(builder, 0) == null) {
expr.drop();
return null;
@@ -570,7 +570,7 @@ public class BasicPrattExpressionParser {
return newExpr;
}
}
else if (PRIMITIVE_TYPE_BIT_SET.contains(tokenType)) {
else if (BASIC_PRIMITIVE_TYPE_BIT_SET.contains(tokenType)) {
refOrType = null;
builder.advanceLexer();
}
@@ -757,8 +757,8 @@ public class BasicPrattExpressionParser {
isTyped = false;
}
else if (nextToken1 == JavaTokenType.AT ||
MODIFIER_BIT_SET.contains(nextToken1) ||
PRIMITIVE_TYPE_BIT_SET.contains(nextToken1)) {
BASIC_MODIFIER_BIT_SET.contains(nextToken1) ||
BASIC_PRIMITIVE_TYPE_BIT_SET.contains(nextToken1)) {
isLambda = true;
isTyped = true;
}

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

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

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

@@ -20,7 +20,7 @@ import org.jetbrains.annotations.Nullable;
import static com.intellij.lang.PsiBuilderUtil.*;
import static com.intellij.lang.java.parser.BasicJavaParserUtil.*;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET;
public class BasicStatementParser {
private static final TokenSet YIELD_STMT_INDICATOR_TOKENS = TokenSet.create(
@@ -460,7 +460,7 @@ public class BasicStatementParser {
private static IElementType getLastToken(PsiBuilder builder) {
IElementType token;
int offset = -1;
while (JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains((token = builder.rawLookup(offset)))) offset--;
while (BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET.contains((token = builder.rawLookup(offset)))) offset--;
return token;
}

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

@@ -6,13 +6,13 @@ import com.intellij.psi.JavaTokenType;
public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, BasicJavaElementType, BasicJavaDocElementType {
BasicJavaTokenSet JAVA_PLAIN_COMMENT_BIT_SET = BasicJavaTokenSet.create(END_OF_LINE_COMMENT, C_STYLE_COMMENT);
BasicJavaTokenSet JAVA_COMMENT_BIT_SET =
BasicJavaTokenSet.orSet(JAVA_PLAIN_COMMENT_BIT_SET, BasicJavaTokenSet.create(DOC_COMMENT));
BasicJavaTokenSet JAVA_COMMENT_OR_WHITESPACE_BIT_SET =
BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(WHITE_SPACE), JAVA_COMMENT_BIT_SET);
BasicJavaTokenSet BASIC_JAVA_PLAIN_COMMENT_BIT_SET = BasicJavaTokenSet.create(END_OF_LINE_COMMENT, C_STYLE_COMMENT);
BasicJavaTokenSet BASIC_JAVA_COMMENT_BIT_SET =
BasicJavaTokenSet.orSet(BASIC_JAVA_PLAIN_COMMENT_BIT_SET, BasicJavaTokenSet.create(DOC_COMMENT));
BasicJavaTokenSet BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET =
BasicJavaTokenSet.orSet(BasicJavaTokenSet.create(WHITE_SPACE), BASIC_JAVA_COMMENT_BIT_SET);
BasicJavaTokenSet KEYWORD_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_KEYWORD_BIT_SET = BasicJavaTokenSet.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,
@@ -25,21 +25,21 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
NON_SEALED_KEYWORD, WHEN_KEYWORD
);
BasicJavaTokenSet LITERAL_BIT_SET = BasicJavaTokenSet.create(TRUE_KEYWORD, FALSE_KEYWORD, NULL_KEYWORD);
BasicJavaTokenSet BASIC_LITERAL_BIT_SET = BasicJavaTokenSet.create(TRUE_KEYWORD, FALSE_KEYWORD, NULL_KEYWORD);
BasicJavaTokenSet OPERATION_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_OPERATION_BIT_SET = BasicJavaTokenSet.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);
BasicJavaTokenSet MODIFIER_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_MODIFIER_BIT_SET = BasicJavaTokenSet.create(
PUBLIC_KEYWORD, PROTECTED_KEYWORD, PRIVATE_KEYWORD, STATIC_KEYWORD, ABSTRACT_KEYWORD, FINAL_KEYWORD, NATIVE_KEYWORD,
SYNCHRONIZED_KEYWORD, STRICTFP_KEYWORD, TRANSIENT_KEYWORD, VOLATILE_KEYWORD, DEFAULT_KEYWORD, SEALED_KEYWORD, NON_SEALED_KEYWORD);
BasicJavaTokenSet PRIMITIVE_TYPE_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_PRIMITIVE_TYPE_BIT_SET = BasicJavaTokenSet.create(
BOOLEAN_KEYWORD, BYTE_KEYWORD, SHORT_KEYWORD, INT_KEYWORD, LONG_KEYWORD, CHAR_KEYWORD, FLOAT_KEYWORD, DOUBLE_KEYWORD, VOID_KEYWORD);
BasicJavaTokenSet EXPRESSION_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_EXPRESSION_BIT_SET = BasicJavaTokenSet.create(
BASIC_REFERENCE_EXPRESSION, BASIC_LITERAL_EXPRESSION, BASIC_THIS_EXPRESSION, BASIC_SUPER_EXPRESSION,
BASIC_PARENTH_EXPRESSION, BASIC_METHOD_CALL_EXPRESSION,
BASIC_TYPE_CAST_EXPRESSION, BASIC_PREFIX_EXPRESSION, BASIC_POSTFIX_EXPRESSION, BASIC_BINARY_EXPRESSION,
@@ -50,11 +50,11 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_EMPTY_EXPRESSION,
BASIC_TEMPLATE_EXPRESSION);
BasicJavaTokenSet ANNOTATION_MEMBER_VALUE_BIT_SET =
BasicJavaTokenSet.orSet(EXPRESSION_BIT_SET, BasicJavaTokenSet.create(BASIC_ANNOTATION,
BASIC_ANNOTATION_ARRAY_INITIALIZER));
BasicJavaTokenSet BASIC_ANNOTATION_MEMBER_VALUE_BIT_SET =
BasicJavaTokenSet.orSet(BASIC_EXPRESSION_BIT_SET, BasicJavaTokenSet.create(BASIC_ANNOTATION,
BASIC_ANNOTATION_ARRAY_INITIALIZER));
BasicJavaTokenSet ARRAY_DIMENSION_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_ARRAY_DIMENSION_BIT_SET = BasicJavaTokenSet.create(
BASIC_REFERENCE_EXPRESSION, BASIC_LITERAL_EXPRESSION, BASIC_THIS_EXPRESSION, BASIC_SUPER_EXPRESSION,
BASIC_PARENTH_EXPRESSION, BASIC_METHOD_CALL_EXPRESSION,
BASIC_TYPE_CAST_EXPRESSION, BASIC_PREFIX_EXPRESSION, BASIC_POSTFIX_EXPRESSION, BASIC_BINARY_EXPRESSION,
@@ -63,7 +63,7 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_CLASS_OBJECT_ACCESS_EXPRESSION,
BASIC_EMPTY_EXPRESSION);
BasicJavaTokenSet JAVA_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_JAVA_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
BASIC_EMPTY_STATEMENT, BASIC_BLOCK_STATEMENT, BASIC_EXPRESSION_STATEMENT, BASIC_EXPRESSION_LIST_STATEMENT,
BASIC_DECLARATION_STATEMENT, BASIC_IF_STATEMENT,
BASIC_WHILE_STATEMENT, BASIC_FOR_STATEMENT, BASIC_FOREACH_STATEMENT, BASIC_DO_WHILE_STATEMENT,
@@ -72,35 +72,35 @@ public interface BasicElementTypes extends JavaTokenType, JavaDocTokenType, Basi
BASIC_TRY_STATEMENT, BASIC_LABELED_STATEMENT, BASIC_ASSERT_STATEMENT,
BASIC_YIELD_STATEMENT);
BasicJavaTokenSet JAVA_PATTERN_BIT_SET =
BasicJavaTokenSet BASIC_JAVA_PATTERN_BIT_SET =
BasicJavaTokenSet.create(BASIC_TYPE_TEST_PATTERN, BASIC_PARENTHESIZED_PATTERN, BASIC_DECONSTRUCTION_PATTERN, BASIC_UNNAMED_PATTERN);
BasicJavaTokenSet JAVA_CASE_LABEL_ELEMENT_BIT_SET =
BasicJavaTokenSet.orSet(JAVA_PATTERN_BIT_SET, EXPRESSION_BIT_SET, BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_JAVA_CASE_LABEL_ELEMENT_BIT_SET =
BasicJavaTokenSet.orSet(BASIC_JAVA_PATTERN_BIT_SET, BASIC_EXPRESSION_BIT_SET, BasicJavaTokenSet.create(
BASIC_DEFAULT_CASE_LABEL_ELEMENT));
BasicJavaTokenSet JAVA_MODULE_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_JAVA_MODULE_STATEMENT_BIT_SET = BasicJavaTokenSet.create(
BASIC_REQUIRES_STATEMENT, BASIC_EXPORTS_STATEMENT, BASIC_OPENS_STATEMENT, BASIC_USES_STATEMENT,
BASIC_PROVIDES_STATEMENT);
BasicJavaTokenSet IMPORT_STATEMENT_BASE_BIT_SET = BasicJavaTokenSet.create(BASIC_IMPORT_STATEMENT,
BASIC_IMPORT_STATIC_STATEMENT);
BasicJavaTokenSet CLASS_KEYWORD_BIT_SET =
BasicJavaTokenSet BASIC_IMPORT_STATEMENT_BASE_BIT_SET = BasicJavaTokenSet.create(BASIC_IMPORT_STATEMENT,
BASIC_IMPORT_STATIC_STATEMENT);
BasicJavaTokenSet BASIC_CLASS_KEYWORD_BIT_SET =
BasicJavaTokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD, ENUM_KEYWORD, RECORD_KEYWORD);
BasicJavaTokenSet MEMBER_BIT_SET = BasicJavaTokenSet.create(BASIC_CLASS, BASIC_FIELD, BASIC_ENUM_CONSTANT,
BASIC_METHOD, BASIC_ANNOTATION_METHOD);
BasicJavaTokenSet FULL_MEMBER_BIT_SET = BasicJavaTokenSet.orSet(MEMBER_BIT_SET, BasicJavaTokenSet.create(
BasicJavaTokenSet BASIC_MEMBER_BIT_SET = BasicJavaTokenSet.create(BASIC_CLASS, BASIC_FIELD, BASIC_ENUM_CONSTANT,
BASIC_METHOD, BASIC_ANNOTATION_METHOD);
BasicJavaTokenSet BASIC_FULL_MEMBER_BIT_SET = BasicJavaTokenSet.orSet(BASIC_MEMBER_BIT_SET, BasicJavaTokenSet.create(
BASIC_CLASS_INITIALIZER));
BasicJavaTokenSet INTEGER_LITERALS = BasicJavaTokenSet.create(INTEGER_LITERAL, LONG_LITERAL);
BasicJavaTokenSet REAL_LITERALS = BasicJavaTokenSet.create(FLOAT_LITERAL, DOUBLE_LITERAL);
BasicJavaTokenSet STRING_LITERALS = BasicJavaTokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL);
BasicJavaTokenSet TEXT_LITERALS = BasicJavaTokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL, CHARACTER_LITERAL);
BasicJavaTokenSet BASIC_INTEGER_LITERALS = BasicJavaTokenSet.create(INTEGER_LITERAL, LONG_LITERAL);
BasicJavaTokenSet BASIC_REAL_LITERALS = BasicJavaTokenSet.create(FLOAT_LITERAL, DOUBLE_LITERAL);
BasicJavaTokenSet BASIC_STRING_LITERALS = BasicJavaTokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL);
BasicJavaTokenSet BASIC_TEXT_LITERALS = BasicJavaTokenSet.create(STRING_LITERAL, TEXT_BLOCK_LITERAL, CHARACTER_LITERAL);
BasicJavaTokenSet STRING_TEMPLATE_FRAGMENTS =
BasicJavaTokenSet BASIC_STRING_TEMPLATE_FRAGMENTS =
BasicJavaTokenSet.create(STRING_TEMPLATE_BEGIN, STRING_TEMPLATE_MID, STRING_TEMPLATE_END,
TEXT_BLOCK_TEMPLATE_BEGIN, TEXT_BLOCK_TEMPLATE_MID, TEXT_BLOCK_TEMPLATE_END);
BasicJavaTokenSet ALL_LITERALS =
BasicJavaTokenSet.orSet(INTEGER_LITERALS, REAL_LITERALS, TEXT_LITERALS, LITERAL_BIT_SET);
BasicJavaTokenSet BASIC_ALL_LITERALS =
BasicJavaTokenSet.orSet(BASIC_INTEGER_LITERALS, BASIC_REAL_LITERALS, BASIC_TEXT_LITERALS, BASIC_LITERAL_BIT_SET);
}

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

@@ -23,7 +23,7 @@ import java.util.Set;
import static com.intellij.psi.JavaTokenType.JAVA_TOKEN_TYPE_SET;
import static com.intellij.psi.JavaTokenType.RPARENTH;
import static com.intellij.psi.impl.source.BasicElementTypes.KEYWORD_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_KEYWORD_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_SNIPPET_ATTRIBUTE_VALUE;
import static com.intellij.psi.impl.source.BasicJavaElementType.*;
@@ -271,7 +271,7 @@ public final class BasicJavaAstTreeUtil {
}
public static boolean isKeyword(@Nullable ASTNode element) {
return is(element, KEYWORD_BIT_SET);
return is(element, BASIC_KEYWORD_BIT_SET);
}
public static boolean isWhiteSpace(@Nullable ASTNode element) {
@@ -371,7 +371,7 @@ public final class BasicJavaAstTreeUtil {
}
public static boolean isComment(@Nullable ASTNode element) {
return is(element, BasicElementTypes.JAVA_COMMENT_BIT_SET);
return is(element, BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET);
}
public static boolean isDocToken(@Nullable ASTNode element) {

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

@@ -8,7 +8,7 @@ import com.intellij.psi.tree.TokenSet;
import java.util.List;
import static com.intellij.psi.impl.source.BasicElementTypes.JAVA_PLAIN_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET;
import static com.intellij.psi.impl.source.BasicJavaDocElementType.DOC_COMMENT;
import static com.intellij.psi.impl.source.BasicJavaTokenSet.create;
import static com.intellij.psi.impl.source.BasicJavaTokenSet.orSet;
@@ -16,11 +16,11 @@ import static com.intellij.psi.impl.source.BasicJavaTokenSet.orSet;
public class WhiteSpaceAndCommentSetHolder {
public static final WhiteSpaceAndCommentSetHolder INSTANCE = new WhiteSpaceAndCommentSetHolder();
private static final BasicJavaTokenSet PRECEDING_COMMENT_SET =
orSet(create(BasicJavaElementType.BASIC_MODULE), BasicElementTypes.FULL_MEMBER_BIT_SET);
orSet(create(BasicJavaElementType.BASIC_MODULE), BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET);
private static final BasicJavaTokenSet TRAILING_COMMENT_SET =
orSet(create(BasicJavaElementType.BASIC_PACKAGE_STATEMENT), BasicElementTypes.IMPORT_STATEMENT_BASE_BIT_SET,
BasicElementTypes.FULL_MEMBER_BIT_SET, BasicElementTypes.JAVA_STATEMENT_BIT_SET);
orSet(create(BasicJavaElementType.BASIC_PACKAGE_STATEMENT), BasicElementTypes.BASIC_IMPORT_STATEMENT_BASE_BIT_SET,
BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET, BasicElementTypes.BASIC_JAVA_STATEMENT_BIT_SET);
private WhiteSpaceAndCommentSetHolder() {
}
@@ -74,7 +74,7 @@ public class WhiteSpaceAndCommentSetHolder {
if (TokenSet.WHITE_SPACE.contains(tokenType)) {
if (StringUtil.getLineBreakCount(getter.get(idx)) > 1) break;
}
else if (JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) {
else if (BASIC_JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) {
if (atStreamEdge ||
(idx == 0 && myAfterEmptyImport) ||
(idx > 0 && TokenSet.WHITE_SPACE.contains(tokens.get(idx - 1)) && StringUtil.containsLineBreak(getter.get(idx - 1)))) {
@@ -102,7 +102,7 @@ public class WhiteSpaceAndCommentSetHolder {
if (TokenSet.WHITE_SPACE.contains(tokenType)) {
if (StringUtil.containsLineBreak(getter.get(idx))) break;
}
else if (JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) {
else if (BASIC_JAVA_PLAIN_COMMENT_BIT_SET.contains(tokenType)) {
result = idx + 1;
}
else {

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

@@ -7,44 +7,44 @@ import com.intellij.psi.impl.source.BasicElementTypes;
import com.intellij.psi.tree.TokenSet;
public interface ElementType extends JavaTokenType, JavaDocTokenType, JavaElementType, JavaDocElementType {
TokenSet JAVA_PLAIN_COMMENT_BIT_SET = BasicElementTypes.JAVA_PLAIN_COMMENT_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_BIT_SET = BasicElementTypes.JAVA_COMMENT_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_OR_WHITESPACE_BIT_SET = BasicElementTypes.JAVA_COMMENT_OR_WHITESPACE_BIT_SET.toTokenSet();
TokenSet JAVA_PLAIN_COMMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_PLAIN_COMMENT_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_COMMENT_BIT_SET.toTokenSet();
TokenSet JAVA_COMMENT_OR_WHITESPACE_BIT_SET = BasicElementTypes.BASIC_JAVA_COMMENT_OR_WHITESPACE_BIT_SET.toTokenSet();
TokenSet KEYWORD_BIT_SET = BasicElementTypes.KEYWORD_BIT_SET.toTokenSet();
TokenSet KEYWORD_BIT_SET = BasicElementTypes.BASIC_KEYWORD_BIT_SET.toTokenSet();
TokenSet LITERAL_BIT_SET = BasicElementTypes.LITERAL_BIT_SET.toTokenSet();
TokenSet LITERAL_BIT_SET = BasicElementTypes.BASIC_LITERAL_BIT_SET.toTokenSet();
TokenSet OPERATION_BIT_SET = BasicElementTypes.OPERATION_BIT_SET.toTokenSet();
TokenSet OPERATION_BIT_SET = BasicElementTypes.BASIC_OPERATION_BIT_SET.toTokenSet();
TokenSet MODIFIER_BIT_SET = BasicElementTypes.MODIFIER_BIT_SET.toTokenSet();
TokenSet MODIFIER_BIT_SET = BasicElementTypes.BASIC_MODIFIER_BIT_SET.toTokenSet();
TokenSet PRIMITIVE_TYPE_BIT_SET = BasicElementTypes.PRIMITIVE_TYPE_BIT_SET.toTokenSet();
TokenSet PRIMITIVE_TYPE_BIT_SET = BasicElementTypes.BASIC_PRIMITIVE_TYPE_BIT_SET.toTokenSet();
TokenSet EXPRESSION_BIT_SET = BasicElementTypes.EXPRESSION_BIT_SET.toTokenSet();
TokenSet EXPRESSION_BIT_SET = BasicElementTypes.BASIC_EXPRESSION_BIT_SET.toTokenSet();
TokenSet ANNOTATION_MEMBER_VALUE_BIT_SET = BasicElementTypes.ANNOTATION_MEMBER_VALUE_BIT_SET.toTokenSet();
TokenSet ARRAY_DIMENSION_BIT_SET = BasicElementTypes.ARRAY_DIMENSION_BIT_SET.toTokenSet();
TokenSet ANNOTATION_MEMBER_VALUE_BIT_SET = BasicElementTypes.BASIC_ANNOTATION_MEMBER_VALUE_BIT_SET.toTokenSet();
TokenSet ARRAY_DIMENSION_BIT_SET = BasicElementTypes.BASIC_ARRAY_DIMENSION_BIT_SET.toTokenSet();
TokenSet JAVA_STATEMENT_BIT_SET = BasicElementTypes.JAVA_STATEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_STATEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_STATEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_PATTERN_BIT_SET = BasicElementTypes.JAVA_PATTERN_BIT_SET.toTokenSet();
TokenSet JAVA_PATTERN_BIT_SET = BasicElementTypes.BASIC_JAVA_PATTERN_BIT_SET.toTokenSet();
TokenSet JAVA_CASE_LABEL_ELEMENT_BIT_SET = BasicElementTypes.JAVA_CASE_LABEL_ELEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_CASE_LABEL_ELEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_CASE_LABEL_ELEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_MODULE_STATEMENT_BIT_SET = BasicElementTypes.JAVA_MODULE_STATEMENT_BIT_SET.toTokenSet();
TokenSet JAVA_MODULE_STATEMENT_BIT_SET = BasicElementTypes.BASIC_JAVA_MODULE_STATEMENT_BIT_SET.toTokenSet();
TokenSet IMPORT_STATEMENT_BASE_BIT_SET = BasicElementTypes.IMPORT_STATEMENT_BASE_BIT_SET.toTokenSet();
TokenSet CLASS_KEYWORD_BIT_SET = BasicElementTypes.CLASS_KEYWORD_BIT_SET.toTokenSet();
TokenSet MEMBER_BIT_SET = BasicElementTypes.MEMBER_BIT_SET.toTokenSet();
TokenSet FULL_MEMBER_BIT_SET = BasicElementTypes.FULL_MEMBER_BIT_SET.toTokenSet();
TokenSet IMPORT_STATEMENT_BASE_BIT_SET = BasicElementTypes.BASIC_IMPORT_STATEMENT_BASE_BIT_SET.toTokenSet();
TokenSet CLASS_KEYWORD_BIT_SET = BasicElementTypes.BASIC_CLASS_KEYWORD_BIT_SET.toTokenSet();
TokenSet MEMBER_BIT_SET = BasicElementTypes.BASIC_MEMBER_BIT_SET.toTokenSet();
TokenSet FULL_MEMBER_BIT_SET = BasicElementTypes.BASIC_FULL_MEMBER_BIT_SET.toTokenSet();
TokenSet INTEGER_LITERALS = BasicElementTypes.INTEGER_LITERALS.toTokenSet();
TokenSet REAL_LITERALS = BasicElementTypes.REAL_LITERALS.toTokenSet();
TokenSet STRING_LITERALS = BasicElementTypes.STRING_LITERALS.toTokenSet();
TokenSet TEXT_LITERALS = BasicElementTypes.TEXT_LITERALS.toTokenSet();
TokenSet INTEGER_LITERALS = BasicElementTypes.BASIC_INTEGER_LITERALS.toTokenSet();
TokenSet REAL_LITERALS = BasicElementTypes.BASIC_REAL_LITERALS.toTokenSet();
TokenSet STRING_LITERALS = BasicElementTypes.BASIC_STRING_LITERALS.toTokenSet();
TokenSet TEXT_LITERALS = BasicElementTypes.BASIC_TEXT_LITERALS.toTokenSet();
TokenSet STRING_TEMPLATE_FRAGMENTS = BasicElementTypes.STRING_TEMPLATE_FRAGMENTS.toTokenSet();
TokenSet STRING_TEMPLATE_FRAGMENTS = BasicElementTypes.BASIC_STRING_TEMPLATE_FRAGMENTS.toTokenSet();
TokenSet ALL_LITERALS = BasicElementTypes.ALL_LITERALS.toTokenSet();
TokenSet ALL_LITERALS = BasicElementTypes.BASIC_ALL_LITERALS.toTokenSet();
}