azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use static initialization for token sets that are used in expect method in Kotlin parser

Browse Source
This commit is contained in:
Ivan Kochurkin
2022-07-25 15:14:28 +02:00
committed by teamcity
parent d65aa67425
commit 6bb2af142c
9 changed files with 127 additions and 92 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocLexer.java
+4 -1
View File
@@ -19,16 +19,19 @@ package org.jetbrains.kotlin.kdoc.lexer;
import com.intellij.lexer.FlexAdapter; import com.intellij.lexer.FlexAdapter;
import com.intellij.lexer.MergingLexerAdapter; import com.intellij.lexer.MergingLexerAdapter;
import com.intellij.psi.tree.TokenSet; import com.intellij.psi.tree.TokenSet;
import org.jetbrains.annotations.NotNull;
import java.io.Reader; import java.io.Reader;
public class KDocLexer extends MergingLexerAdapter { public class KDocLexer extends MergingLexerAdapter {
private static final TokenSet KDOC_TOKENS = TokenSet.create(KDocTokens.TEXT, KDocTokens.CODE_BLOCK_TEXT);
public KDocLexer() { public KDocLexer() {
super( super(
new FlexAdapter( new FlexAdapter(
new _KDocLexer((Reader) null) new _KDocLexer((Reader) null)
), ),
TokenSet.create(KDocTokens.TEXT, KDocTokens.CODE_BLOCK_TEXT) KDOC_TOKENS
); );
} }
} }
compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java
+1 -12
View File
@@ -189,14 +189,7 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*;
/** /**
* Side-effect-free version of atSet() * Side-effect-free version of atSet()
*/ */
protected boolean _atSet(IElementType... tokens) { protected boolean _atSet(TokenSet set) {
return _atSet(TokenSet.create(tokens));
}
/**
* Side-effect-free version of atSet()
*/
private boolean _atSet(TokenSet set) {
IElementType token = tt(); IElementType token = tt();
if (set.contains(token)) return true; if (set.contains(token)) return true;
if (set.contains(EOL_OR_SEMICOLON)) { if (set.contains(EOL_OR_SEMICOLON)) {
@@ -207,10 +200,6 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*;
return false; return false;
} }
protected boolean atSet(IElementType... tokens) {
return atSet(TokenSet.create(tokens));
}
protected boolean atSet(TokenSet set) { protected boolean atSet(TokenSet set) {
if (_atSet(set)) return true; if (_atSet(set)) return true;
IElementType token = tt(); IElementType token = tt();
compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java
+27 -18
View File
@@ -37,19 +37,28 @@ import java.util.Set;
import static org.jetbrains.kotlin.KtNodeTypes.*; import static org.jetbrains.kotlin.KtNodeTypes.*;
import static org.jetbrains.kotlin.lexer.KtTokens.*; import static org.jetbrains.kotlin.lexer.KtTokens.*;
import static org.jetbrains.kotlin.parsing.KotlinParsing.AnnotationParsingMode.DEFAULT; import static org.jetbrains.kotlin.parsing.KotlinParsing.AnnotationParsingMode.DEFAULT;
import static org.jetbrains.kotlin.parsing.KotlinParsing.PARAMETER_NAME_RECOVERY_SET;
import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.PRECEDING_ALL_COMMENTS_BINDER; import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.PRECEDING_ALL_COMMENTS_BINDER;
import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.TRAILING_ALL_COMMENTS_BINDER; import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.TRAILING_ALL_COMMENTS_BINDER;
public class KotlinExpressionParsing extends AbstractKotlinParsing { public class KotlinExpressionParsing extends AbstractKotlinParsing {
private static final TokenSet WHEN_CONDITION_RECOVERY_SET = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD); private static final TokenSet WHEN_CONDITION_RECOVERY_SET = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD);
private static final TokenSet WHEN_CONDITION_RECOVERY_SET_WITH_ARROW = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD, ARROW, DOT); private static final TokenSet WHEN_CONDITION_RECOVERY_SET_WITH_ARROW = TokenSet.create(RBRACE, IN_KEYWORD, NOT_IN, IS_KEYWORD, NOT_IS, ELSE_KEYWORD, ARROW, DOT);
private static final ImmutableMap<String, KtToken> KEYWORD_TEXTS = tokenSetToMap(KEYWORDS); private static final ImmutableMap<String, KtToken> KEYWORD_TEXTS = tokenSetToMap(KEYWORDS);
private static final IElementType[] LOCAL_DECLARATION_FIRST =
new IElementType[] {CLASS_KEYWORD, INTERFACE_KEYWORD, FUN_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, TYPE_ALIAS_KEYWORD};
private static final TokenSet TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA = TokenSet.create(ARROW, COMMA, COLON); private static final TokenSet TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA = TokenSet.create(ARROW, COMMA, COLON);
private static final TokenSet TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA_RECOVERY =
TokenSet.orSet(TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA, PARAMETER_NAME_RECOVERY_SET);
private static final TokenSet EQ_RPAR_SET = TokenSet.create(EQ, RPAR);
private static final TokenSet ARROW_SET = TokenSet.create(ARROW);
private static final TokenSet ARROW_COMMA_SET = TokenSet.create(ARROW, COMMA);
private static final TokenSet IN_KEYWORD_R_PAR_COLON_SET = TokenSet.create(IN_KEYWORD, RPAR, COLON);
private static final TokenSet IN_KEYWORD_L_BRACE_SET = TokenSet.create(IN_KEYWORD, LBRACE);
private static final TokenSet IN_KEYWORD_L_BRACE_RECOVERY_SET = TokenSet.orSet(IN_KEYWORD_L_BRACE_SET, PARAMETER_NAME_RECOVERY_SET);
private static final TokenSet COLON_IN_KEYWORD_SET = TokenSet.create(COLON, IN_KEYWORD);
private static final TokenSet L_PAR_L_BRACE_R_PAR_SET = TokenSet.create(LPAR, LBRACE, RPAR);
private static final TokenSet IN_KEYWORD_SET = TokenSet.create(IN_KEYWORD);
private static final TokenSet TRY_CATCH_RECOVERY_TOKEN_SET = TokenSet.create(LBRACE, RBRACE, FINALLY_KEYWORD, CATCH_KEYWORD);
private static ImmutableMap<String, KtToken> tokenSetToMap(TokenSet tokens) { private static ImmutableMap<String, KtToken> tokenSetToMap(TokenSet tokens) {
ImmutableMap.Builder<String, KtToken> builder = ImmutableMap.builder(); ImmutableMap.Builder<String, KtToken> builder = ImmutableMap.builder();
@@ -848,7 +857,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
advanceAt(LPAR); advanceAt(LPAR);
PsiBuilder.Marker atWhenStart = mark(); PsiBuilder.Marker atWhenStart = mark();
myKotlinParsing.parseAnnotationsList(DEFAULT, TokenSet.create(EQ, RPAR)); myKotlinParsing.parseAnnotationsList(DEFAULT, EQ_RPAR_SET);
if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) { if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) {
IElementType declType = myKotlinParsing.parseProperty(KotlinParsing.DeclarationParsingMode.LOCAL); IElementType declType = myKotlinParsing.parseProperty(KotlinParsing.DeclarationParsingMode.LOCAL);
@@ -1239,16 +1248,17 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
} }
else if (at(LPAR)) { else if (at(LPAR)) {
PsiBuilder.Marker destructuringDeclaration = mark(); PsiBuilder.Marker destructuringDeclaration = mark();
myKotlinParsing.parseMultiDeclarationName(TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA); myKotlinParsing.parseMultiDeclarationName(TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA,
TOKEN_SET_TO_FOLLOW_AFTER_DESTRUCTURING_DECLARATION_IN_LAMBDA_RECOVERY);
destructuringDeclaration.done(DESTRUCTURING_DECLARATION); destructuringDeclaration.done(DESTRUCTURING_DECLARATION);
} }
else { else {
expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(ARROW)); expect(IDENTIFIER, "Expecting parameter name", ARROW_SET);
} }
if (at(COLON)) { if (at(COLON)) {
advance(); // COLON advance(); // COLON
myKotlinParsing.parseTypeRef(TokenSet.create(ARROW, COMMA)); myKotlinParsing.parseTypeRef(ARROW_COMMA_SET);
} }
parameter.done(VALUE_PARAMETER); parameter.done(VALUE_PARAMETER);
@@ -1459,27 +1469,27 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
PsiBuilder.Marker parameter = mark(); PsiBuilder.Marker parameter = mark();
if (!at(IN_KEYWORD)) { if (!at(IN_KEYWORD)) {
myKotlinParsing.parseModifierList(DEFAULT, TokenSet.create(IN_KEYWORD, RPAR, COLON)); myKotlinParsing.parseModifierList(DEFAULT, IN_KEYWORD_R_PAR_COLON_SET);
} }
if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD
if (at(LPAR)) { if (at(LPAR)) {
PsiBuilder.Marker destructuringDeclaration = mark(); PsiBuilder.Marker destructuringDeclaration = mark();
myKotlinParsing.parseMultiDeclarationName(TokenSet.create(IN_KEYWORD, LBRACE)); myKotlinParsing.parseMultiDeclarationName(IN_KEYWORD_L_BRACE_SET, IN_KEYWORD_L_BRACE_RECOVERY_SET);
destructuringDeclaration.done(DESTRUCTURING_DECLARATION); destructuringDeclaration.done(DESTRUCTURING_DECLARATION);
} }
else { else {
expect(IDENTIFIER, "Expecting a variable name", TokenSet.create(COLON, IN_KEYWORD)); expect(IDENTIFIER, "Expecting a variable name", COLON_IN_KEYWORD_SET);
if (at(COLON)) { if (at(COLON)) {
advance(); // COLON advance(); // COLON
myKotlinParsing.parseTypeRef(TokenSet.create(IN_KEYWORD)); myKotlinParsing.parseTypeRef(IN_KEYWORD_SET);
} }
} }
parameter.done(VALUE_PARAMETER); parameter.done(VALUE_PARAMETER);
if (expect(IN_KEYWORD, "Expecting 'in'", TokenSet.create(LPAR, LBRACE, RPAR))) { if (expect(IN_KEYWORD, "Expecting 'in'", L_PAR_L_BRACE_R_PAR_SET)) {
PsiBuilder.Marker range = mark(); PsiBuilder.Marker range = mark();
parseExpression(); parseExpression();
range.done(LOOP_RANGE); range.done(LOOP_RANGE);
@@ -1542,19 +1552,18 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing {
PsiBuilder.Marker catchBlock = mark(); PsiBuilder.Marker catchBlock = mark();
advance(); // CATCH_KEYWORD advance(); // CATCH_KEYWORD
TokenSet recoverySet = TokenSet.create(LBRACE, RBRACE, FINALLY_KEYWORD, CATCH_KEYWORD); if (atSet(TRY_CATCH_RECOVERY_TOKEN_SET)) {
if (atSet(recoverySet)) {
error("Expecting exception variable declaration"); error("Expecting exception variable declaration");
} }
else { else {
PsiBuilder.Marker parameters = mark(); PsiBuilder.Marker parameters = mark();
expect(LPAR, "Expecting '('", recoverySet); expect(LPAR, "Expecting '('", TRY_CATCH_RECOVERY_TOKEN_SET);
if (!atSet(recoverySet)) { if (!atSet(TRY_CATCH_RECOVERY_TOKEN_SET)) {
myKotlinParsing.parseValueParameter(/*typeRequired = */ true); myKotlinParsing.parseValueParameter(/*typeRequired = */ true);
if (at(COMMA)) { if (at(COMMA)) {
advance(); // trailing comma advance(); // trailing comma
} }
expect(RPAR, "Expecting ')'", recoverySet); expect(RPAR, "Expecting ')'", TRY_CATCH_RECOVERY_TOKEN_SET);
} }
else { else {
error("Expecting exception variable declaration"); error("Expecting exception variable declaration");
compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java
+75 -48
View File
@@ -34,21 +34,30 @@ import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.
import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.TRAILING_ALL_BINDER; import static org.jetbrains.kotlin.parsing.KotlinWhitespaceAndCommentsBindersKt.TRAILING_ALL_BINDER;
public class KotlinParsing extends AbstractKotlinParsing { public class KotlinParsing extends AbstractKotlinParsing {
private static final TokenSet GT_COMMA_COLON_SET = TokenSet.create(GT, COMMA, COLON);
private static final Logger LOG = Logger.getInstance(KotlinParsing.class); private static final Logger LOG = Logger.getInstance(KotlinParsing.class);
private static final TokenSet TOP_LEVEL_DECLARATION_FIRST = TokenSet.create( private static final TokenSet TOP_LEVEL_DECLARATION_FIRST = TokenSet.create(
TYPE_ALIAS_KEYWORD, INTERFACE_KEYWORD, CLASS_KEYWORD, OBJECT_KEYWORD, TYPE_ALIAS_KEYWORD, INTERFACE_KEYWORD, CLASS_KEYWORD, OBJECT_KEYWORD,
FUN_KEYWORD, VAL_KEYWORD, PACKAGE_KEYWORD); FUN_KEYWORD, VAL_KEYWORD, PACKAGE_KEYWORD);
private static final TokenSet TOP_LEVEL_DECLARATION_FIRST_SEMICOLON_SET =
TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST, TokenSet.create(SEMICOLON));
private static final TokenSet LT_EQ_SEMICOLON_TOP_LEVEL_DECLARATION_FIRST_SET =
TokenSet.orSet(TokenSet.create(LT, EQ, SEMICOLON), TOP_LEVEL_DECLARATION_FIRST);
private static final TokenSet DECLARATION_FIRST = TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST, private static final TokenSet DECLARATION_FIRST = TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST,
TokenSet.create(INIT_KEYWORD, GET_KEYWORD, SET_KEYWORD, CONSTRUCTOR_KEYWORD)); TokenSet.create(INIT_KEYWORD, GET_KEYWORD, SET_KEYWORD, CONSTRUCTOR_KEYWORD));
private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, LPAR, COLON, LBRACE), private static final TokenSet CLASS_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, LPAR, COLON, LBRACE),
TOP_LEVEL_DECLARATION_FIRST); TOP_LEVEL_DECLARATION_FIRST);
private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, LPAR, COLON, LBRACE, GT); private static final TokenSet TYPE_PARAMETER_GT_RECOVERY_SET = TokenSet.create(WHERE_KEYWORD, LPAR, COLON, LBRACE, GT);
private static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR, VAL_KEYWORD, VAR_KEYWORD); public static final TokenSet PARAMETER_NAME_RECOVERY_SET = TokenSet.create(COLON, EQ, COMMA, RPAR, VAL_KEYWORD, VAR_KEYWORD);
private static final TokenSet PACKAGE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON); private static final TokenSet PACKAGE_NAME_RECOVERY_SET = TokenSet.create(DOT, EOL_OR_SEMICOLON);
private static final TokenSet IMPORT_RECOVERY_SET = TokenSet.create(AS_KEYWORD, DOT, EOL_OR_SEMICOLON); private static final TokenSet IMPORT_RECOVERY_SET = TokenSet.create(AS_KEYWORD, DOT, EOL_OR_SEMICOLON);
private static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, LPAR, HASH, DYNAMIC_KEYWORD); private static final TokenSet TYPE_REF_FIRST = TokenSet.create(LBRACKET, IDENTIFIER, LPAR, HASH, DYNAMIC_KEYWORD);
private static final TokenSet LBRACE_RBRACE_TYPE_REF_FIRST_SET =
TokenSet.orSet(TokenSet.create(LBRACE, RBRACE), TYPE_REF_FIRST);
private static final TokenSet COLON_COMMA_LBRACE_RBRACE_TYPE_REF_FIRST_SET =
TokenSet.orSet(TokenSet.create(COLON, COMMA, LBRACE, RBRACE), TYPE_REF_FIRST);
private static final TokenSet RECEIVER_TYPE_TERMINATORS = TokenSet.create(DOT, SAFE_ACCESS); private static final TokenSet RECEIVER_TYPE_TERMINATORS = TokenSet.create(DOT, SAFE_ACCESS);
private static final TokenSet VALUE_PARAMETER_FIRST = private static final TokenSet VALUE_PARAMETER_FIRST =
TokenSet.orSet( TokenSet.orSet(
@@ -64,6 +73,37 @@ public class KotlinParsing extends AbstractKotlinParsing {
private static final TokenSet ANNOTATION_TARGETS = TokenSet.create( private static final TokenSet ANNOTATION_TARGETS = TokenSet.create(
FILE_KEYWORD, FIELD_KEYWORD, GET_KEYWORD, SET_KEYWORD, PROPERTY_KEYWORD, FILE_KEYWORD, FIELD_KEYWORD, GET_KEYWORD, SET_KEYWORD, PROPERTY_KEYWORD,
RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD, DELEGATE_KEYWORD); RECEIVER_KEYWORD, PARAM_KEYWORD, SETPARAM_KEYWORD, DELEGATE_KEYWORD);
private static final TokenSet BLOCK_DOC_COMMENT_SET = TokenSet.create(BLOCK_COMMENT, DOC_COMMENT);
private static final TokenSet SEMICOLON_SET = TokenSet.create(SEMICOLON);
private static final TokenSet COMMA_COLON_GT_SET = TokenSet.create(COMMA, COLON, GT);
private static final TokenSet IDENTIFIER_RBRACKET_LBRACKET_SET = TokenSet.create(IDENTIFIER, RBRACKET, LBRACKET);
private static final TokenSet LBRACE_RBRACE_SET = TokenSet.create(LBRACE, RBRACE);
private static final TokenSet COMMA_SEMICOLON_RBRACE_SET = TokenSet.create(COMMA, SEMICOLON, RBRACE);
private static final TokenSet VALUE_ARGS_RECOVERY_SET = TokenSet.create(LBRACE, SEMICOLON, RPAR, EOL_OR_SEMICOLON, RBRACE);
private static final TokenSet PROPERTY_NAME_FOLLOW_SET =
TokenSet.create(COLON, EQ, LBRACE, RBRACE, SEMICOLON, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD);
private static final TokenSet PROPERTY_NAME_FOLLOW_MULTI_DECLARATION_RECOVERY_SET = TokenSet.orSet(PROPERTY_NAME_FOLLOW_SET, PARAMETER_NAME_RECOVERY_SET);
private static final TokenSet PROPERTY_NAME_FOLLOW_FUNCTION_OR_PROPERTY_RECOVERY_SET = TokenSet.orSet(PROPERTY_NAME_FOLLOW_SET, LBRACE_RBRACE_SET, TOP_LEVEL_DECLARATION_FIRST);
private static final TokenSet IDENTIFIER_EQ_COLON_SEMICOLON_SET = TokenSet.create(IDENTIFIER, EQ, COLON, SEMICOLON);
private static final TokenSet COMMA_RPAR_COLON_EQ_SET = TokenSet.create(COMMA, RPAR, COLON, EQ);
private static final TokenSet ACCESSOR_FIRST_OR_PROPERTY_END =
TokenSet.orSet(MODIFIER_KEYWORDS, TokenSet.create(AT, GET_KEYWORD, SET_KEYWORD, FIELD_KEYWORD, EOL_OR_SEMICOLON, RBRACE));
private static final TokenSet RPAR_IDENTIFIER_COLON_LBRACE_EQ_SET = TokenSet.create(RPAR, IDENTIFIER, COLON, LBRACE, EQ);
private static final TokenSet COMMA_COLON_RPAR_SET = TokenSet.create(COMMA, COLON, RPAR);
private static final TokenSet RPAR_COLON_LBRACE_EQ_SET = TokenSet.create(RPAR, COLON, LBRACE, EQ);
private static final TokenSet LBRACKET_LBRACE_RBRACE_LPAR_SET = TokenSet.create(LBRACKET, LBRACE, RBRACE, LPAR);
private static final TokenSet FUNCTION_NAME_FOLLOW_SET = TokenSet.create(LT, LPAR, RPAR, COLON, EQ);
private static final TokenSet FUNCTION_NAME_RECOVERY_SET = TokenSet.orSet(TokenSet.create(LT, LPAR, RPAR, COLON, EQ), LBRACE_RBRACE_SET, TOP_LEVEL_DECLARATION_FIRST);
private static final TokenSet VALUE_PARAMETERS_FOLLOW_SET = TokenSet.create(EQ, LBRACE, RBRACE, SEMICOLON, RPAR);
private static final TokenSet LPAR_VALUE_PARAMETERS_FOLLOW_SET = TokenSet.orSet(TokenSet.create(LPAR), VALUE_PARAMETERS_FOLLOW_SET);
private static final TokenSet
LPAR_LBRACE_COLON_CONSTRUCTOR_KEYWORD_SET = TokenSet.create(LPAR, LBRACE, COLON, CONSTRUCTOR_KEYWORD);
private static final TokenSet definitelyOutOfReceiverSet = TokenSet.orSet(
TokenSet.create(EQ, COLON, LBRACE, RBRACE, BY_KEYWORD),
TOP_LEVEL_DECLARATION_FIRST
);
private final static TokenSet EOL_OR_SEMICOLON_RBRACE_SET = TokenSet.create(EOL_OR_SEMICOLON, RBRACE);
private final static TokenSet CLASS_INTERFACE_SET = TokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD);
static KotlinParsing createForTopLevel(SemanticWhitespaceAwarePsiBuilder builder) { static KotlinParsing createForTopLevel(SemanticWhitespaceAwarePsiBuilder builder) {
KotlinParsing kotlinParsing = new KotlinParsing(builder); KotlinParsing kotlinParsing = new KotlinParsing(builder);
@@ -116,7 +156,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
private void checkUnclosedBlockComment() { private void checkUnclosedBlockComment() {
if (TokenSet.create(BLOCK_COMMENT, DOC_COMMENT).contains(myBuilder.rawLookup(-1))) { if (BLOCK_DOC_COMMENT_SET.contains(myBuilder.rawLookup(-1))) {
int startOffset = myBuilder.rawTokenTypeStart(-1); int startOffset = myBuilder.rawTokenTypeStart(-1);
int endOffset = myBuilder.rawTokenTypeStart(0); int endOffset = myBuilder.rawTokenTypeStart(0);
CharSequence tokenChars = myBuilder.getOriginalText().subSequence(startOffset, endOffset); CharSequence tokenChars = myBuilder.getOriginalText().subSequence(startOffset, endOffset);
@@ -370,7 +410,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
if (closeImportWithErrorIfNewline(importDirective, alias, "Expecting identifier")) { if (closeImportWithErrorIfNewline(importDirective, alias, "Expecting identifier")) {
return; return;
} }
expect(IDENTIFIER, "Expecting identifier", TokenSet.create(SEMICOLON)); expect(IDENTIFIER, "Expecting identifier", SEMICOLON_SET);
alias.done(IMPORT_ALIAS); alias.done(IMPORT_ALIAS);
} }
consumeIf(SEMICOLON); consumeIf(SEMICOLON);
@@ -523,7 +563,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
private boolean parseTypeArgumentModifierList() { private boolean parseTypeArgumentModifierList() {
return doParseModifierList(null, TYPE_ARGUMENT_MODIFIER_KEYWORDS, NO_ANNOTATIONS, TokenSet.create(COMMA, COLON, GT)); return doParseModifierList(null, TYPE_ARGUMENT_MODIFIER_KEYWORDS, NO_ANNOTATIONS, COMMA_COLON_GT_SET);
} }
private boolean doParseModifierListBody( private boolean doParseModifierListBody(
@@ -844,7 +884,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
marker.done(ANNOTATION_TARGET); marker.done(ANNOTATION_TARGET);
} }
expect(COLON, message, TokenSet.create(IDENTIFIER, RBRACKET, LBRACKET)); expect(COLON, message, IDENTIFIER_RBRACKET_LBRACKET_SET);
} }
@Nullable @Nullable
@@ -958,7 +998,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
assert _at(OBJECT_KEYWORD); assert _at(OBJECT_KEYWORD);
} }
else { else {
assert _atSet(CLASS_KEYWORD, INTERFACE_KEYWORD); assert _atSet(CLASS_INTERFACE_SET);
} }
advance(); // CLASS_KEYWORD, INTERFACE_KEYWORD or OBJECT_KEYWORD advance(); // CLASS_KEYWORD, INTERFACE_KEYWORD or OBJECT_KEYWORD
} }
@@ -990,7 +1030,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
boolean hasConstructorModifiers = parseModifierList(DEFAULT, TokenSet.EMPTY); boolean hasConstructorModifiers = parseModifierList(DEFAULT, TokenSet.EMPTY);
// Some modifiers found, but no parentheses following: class has already ended, and we are looking at something else // Some modifiers found, but no parentheses following: class has already ended, and we are looking at something else
if (hasConstructorModifiers && !atSet(LPAR, LBRACE, COLON, CONSTRUCTOR_KEYWORD)) { if (hasConstructorModifiers && !atSet(LPAR_LBRACE_COLON_CONSTRUCTOR_KEYWORD_SET)) {
beforeConstructorModifiers.rollbackTo(); beforeConstructorModifiers.rollbackTo();
return object ? OBJECT_DECLARATION : CLASS; return object ? OBJECT_DECLARATION : CLASS;
} }
@@ -1004,7 +1044,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
if (at(LPAR)) { if (at(LPAR)) {
parseValueParameterList(false, /* typeRequired = */ true, TokenSet.create(LBRACE, RBRACE)); parseValueParameterList(false, /* typeRequired = */ true, LBRACE_RBRACE_SET);
primaryConstructorMarker.done(PRIMARY_CONSTRUCTOR); primaryConstructorMarker.done(PRIMARY_CONSTRUCTOR);
} }
else if (hasConstructorModifiers || hasConstructorKeyword) { else if (hasConstructorModifiers || hasConstructorKeyword) {
@@ -1126,7 +1166,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
private ParseEnumEntryResult parseEnumEntry() { private ParseEnumEntryResult parseEnumEntry() {
PsiBuilder.Marker entry = mark(); PsiBuilder.Marker entry = mark();
parseModifierList(DEFAULT, TokenSet.create(COMMA, SEMICOLON, RBRACE)); parseModifierList(DEFAULT, COMMA_SEMICOLON_RBRACE_SET);
if (!atSet(SOFT_KEYWORDS_AT_MEMBER_START) && at(IDENTIFIER)) { if (!atSet(SOFT_KEYWORDS_AT_MEMBER_START) && at(IDENTIFIER)) {
advance(); // IDENTIFIER advance(); // IDENTIFIER
@@ -1291,12 +1331,11 @@ public class KotlinParsing extends AbstractKotlinParsing {
advance(); // CONSTRUCTOR_KEYWORD advance(); // CONSTRUCTOR_KEYWORD
TokenSet valueArgsRecoverySet = TokenSet.create(LBRACE, SEMICOLON, RPAR, EOL_OR_SEMICOLON, RBRACE);
if (at(LPAR)) { if (at(LPAR)) {
parseValueParameterList(false, /*typeRequired = */ true, valueArgsRecoverySet); parseValueParameterList(false, /*typeRequired = */ true, VALUE_ARGS_RECOVERY_SET);
} }
else { else {
errorWithRecovery("Expecting '('", TokenSet.orSet(valueArgsRecoverySet, TokenSet.create(COLON))); errorWithRecovery("Expecting '('", TokenSet.orSet(VALUE_ARGS_RECOVERY_SET, TokenSet.create(COLON)));
} }
if (at(COLON)) { if (at(COLON)) {
@@ -1360,7 +1399,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
advance(); // TYPE_ALIAS_KEYWORD advance(); // TYPE_ALIAS_KEYWORD
expect(IDENTIFIER, "Type name expected", TokenSet.orSet(TokenSet.create(LT, EQ, SEMICOLON), TOP_LEVEL_DECLARATION_FIRST)); expect(IDENTIFIER, "Type name expected", LT_EQ_SEMICOLON_TOP_LEVEL_DECLARATION_FIRST_SET);
parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET); parseTypeParameterList(TYPE_PARAMETER_GT_RECOVERY_SET);
@@ -1370,7 +1409,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
error.error("Type alias parameters can't have bounds"); error.error("Type alias parameters can't have bounds");
} }
expect(EQ, "Expecting '='", TokenSet.orSet(TOP_LEVEL_DECLARATION_FIRST, TokenSet.create(SEMICOLON))); expect(EQ, "Expecting '='", TOP_LEVEL_DECLARATION_FIRST_SEMICOLON_SET);
parseTypeRef(); parseTypeRef();
@@ -1414,14 +1453,12 @@ public class KotlinParsing extends AbstractKotlinParsing {
assert (at(VAL_KEYWORD) || at(VAR_KEYWORD)); assert (at(VAL_KEYWORD) || at(VAR_KEYWORD));
advance(); advance();
boolean typeParametersDeclared = at(LT) && parseTypeParameterList(TokenSet.create(IDENTIFIER, EQ, COLON, SEMICOLON)); boolean typeParametersDeclared = at(LT) && parseTypeParameterList(IDENTIFIER_EQ_COLON_SEMICOLON_SET);
TokenSet propertyNameFollow = TokenSet.create(COLON, EQ, LBRACE, RBRACE, SEMICOLON, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, CLASS_KEYWORD);
myBuilder.disableJoiningComplexTokens(); myBuilder.disableJoiningComplexTokens();
PsiBuilder.Marker receiver = mark(); PsiBuilder.Marker receiver = mark();
boolean receiverTypeDeclared = parseReceiverType("property", propertyNameFollow); boolean receiverTypeDeclared = parseReceiverType("property", PROPERTY_NAME_FOLLOW_SET);
boolean multiDeclaration = at(LPAR); boolean multiDeclaration = at(LPAR);
@@ -1432,11 +1469,11 @@ public class KotlinParsing extends AbstractKotlinParsing {
if (multiDeclaration) { if (multiDeclaration) {
PsiBuilder.Marker multiDecl = mark(); PsiBuilder.Marker multiDecl = mark();
parseMultiDeclarationName(propertyNameFollow); parseMultiDeclarationName(PROPERTY_NAME_FOLLOW_SET, PROPERTY_NAME_FOLLOW_MULTI_DECLARATION_RECOVERY_SET);
errorIf(multiDecl, !mode.destructuringAllowed, "Destructuring declarations are only allowed for local variables/values"); errorIf(multiDecl, !mode.destructuringAllowed, "Destructuring declarations are only allowed for local variables/values");
} }
else { else {
parseFunctionOrPropertyName(receiverTypeDeclared, "property", propertyNameFollow, /*nameRequired = */ true); parseFunctionOrPropertyName(receiverTypeDeclared, "property", PROPERTY_NAME_FOLLOW_SET, PROPERTY_NAME_FOLLOW_FUNCTION_OR_PROPERTY_RECOVERY_SET, /*nameRequired = */ true);
} }
myBuilder.restoreJoiningComplexTokensState(); myBuilder.restoreJoiningComplexTokensState();
@@ -1479,7 +1516,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
propertyComponentKind = parsePropertyComponent(alreadyRead); propertyComponentKind = parsePropertyComponent(alreadyRead);
} }
if (!atSet(EOL_OR_SEMICOLON, RBRACE)) { if (!atSet(EOL_OR_SEMICOLON_RBRACE_SET)) {
if (getLastToken() != SEMICOLON) { if (getLastToken() != SEMICOLON) {
errorUntil( errorUntil(
"Property getter or setter expected", "Property getter or setter expected",
@@ -1525,13 +1562,12 @@ public class KotlinParsing extends AbstractKotlinParsing {
/* /*
* (SimpleName (":" type){","}) * (SimpleName (":" type){","})
*/ */
public void parseMultiDeclarationName(TokenSet follow) { public void parseMultiDeclarationName(TokenSet follow, TokenSet recoverySet) {
// Parsing multi-name, e.g. // Parsing multi-name, e.g.
// val (a, b) = foo() // val (a, b) = foo()
myBuilder.disableNewlines(); myBuilder.disableNewlines();
advance(); // LPAR advance(); // LPAR
TokenSet recoverySet = TokenSet.orSet(PARAMETER_NAME_RECOVERY_SET, follow);
if (!atSet(follow)) { if (!atSet(follow)) {
while (true) { while (true) {
if (at(COMMA)) { if (at(COMMA)) {
@@ -1543,7 +1579,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
PsiBuilder.Marker property = mark(); PsiBuilder.Marker property = mark();
parseModifierList(DEFAULT, TokenSet.create(COMMA, RPAR, COLON, EQ)); parseModifierList(DEFAULT, COMMA_RPAR_COLON_EQ_SET);
expect(IDENTIFIER, "Expecting a name", recoverySet); expect(IDENTIFIER, "Expecting a name", recoverySet);
@@ -1623,7 +1659,6 @@ public class KotlinParsing extends AbstractKotlinParsing {
if (!at(LPAR) && propertyComponentKind != PropertyComponentKind.FIELD) { if (!at(LPAR) && propertyComponentKind != PropertyComponentKind.FIELD) {
// Account for Jet-114 (val a : int get {...}) // Account for Jet-114 (val a : int get {...})
TokenSet ACCESSOR_FIRST_OR_PROPERTY_END = TokenSet.orSet(MODIFIER_KEYWORDS, TokenSet.create(AT, GET_KEYWORD, SET_KEYWORD, FIELD_KEYWORD, EOL_OR_SEMICOLON, RBRACE));
if (!atSet(ACCESSOR_FIRST_OR_PROPERTY_END)) { if (!atSet(ACCESSOR_FIRST_OR_PROPERTY_END)) {
errorUntil("Accessor body expected", TokenSet.orSet(ACCESSOR_FIRST_OR_PROPERTY_END, TokenSet.create(LBRACE, LPAR, EQ))); errorUntil("Accessor body expected", TokenSet.orSet(ACCESSOR_FIRST_OR_PROPERTY_END, TokenSet.create(LBRACE, LPAR, EQ)));
} }
@@ -1636,12 +1671,12 @@ public class KotlinParsing extends AbstractKotlinParsing {
myBuilder.disableNewlines(); myBuilder.disableNewlines();
if (propertyComponentKind != PropertyComponentKind.FIELD) { if (propertyComponentKind != PropertyComponentKind.FIELD) {
expect(LPAR, "Expecting '('", TokenSet.create(RPAR, IDENTIFIER, COLON, LBRACE, EQ)); expect(LPAR, "Expecting '('", RPAR_IDENTIFIER_COLON_LBRACE_EQ_SET);
if (propertyComponentKind == PropertyComponentKind.SET) { if (propertyComponentKind == PropertyComponentKind.SET) {
PsiBuilder.Marker parameterList = mark(); PsiBuilder.Marker parameterList = mark();
PsiBuilder.Marker setterParameter = mark(); PsiBuilder.Marker setterParameter = mark();
parseModifierList(DEFAULT, TokenSet.create(COMMA, COLON, RPAR)); parseModifierList(DEFAULT, COMMA_COLON_RPAR_SET);
expect(IDENTIFIER, "Expecting parameter name", TokenSet.create(RPAR, COLON, LBRACE, EQ)); expect(IDENTIFIER, "Expecting parameter name", RPAR_COLON_LBRACE_EQ_SET);
if (at(COLON)) { if (at(COLON)) {
advance(); // COLON advance(); // COLON
@@ -1715,14 +1750,13 @@ public class KotlinParsing extends AbstractKotlinParsing {
boolean typeParameterListOccurred = false; boolean typeParameterListOccurred = false;
if (at(LT)) { if (at(LT)) {
parseTypeParameterList(TokenSet.create(LBRACKET, LBRACE, RBRACE, LPAR)); parseTypeParameterList(LBRACKET_LBRACE_RBRACE_LPAR_SET);
typeParameterListOccurred = true; typeParameterListOccurred = true;
} }
myBuilder.disableJoiningComplexTokens(); myBuilder.disableJoiningComplexTokens();
TokenSet functionNameFollow = TokenSet.create(LT, LPAR, RPAR, COLON, EQ); boolean receiverFound = parseReceiverType("function", FUNCTION_NAME_FOLLOW_SET);
boolean receiverFound = parseReceiverType("function", functionNameFollow);
if (at(IDENTIFIER) && failIfIdentifierExists) { if (at(IDENTIFIER) && failIfIdentifierExists) {
myBuilder.restoreJoiningComplexTokensState(); myBuilder.restoreJoiningComplexTokensState();
@@ -1730,15 +1764,13 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
// function as expression has no name // function as expression has no name
parseFunctionOrPropertyName(receiverFound, "function", functionNameFollow, /*nameRequired = */ false); parseFunctionOrPropertyName(receiverFound, "function", FUNCTION_NAME_FOLLOW_SET, FUNCTION_NAME_RECOVERY_SET, /*nameRequired = */ false);
myBuilder.restoreJoiningComplexTokensState(); myBuilder.restoreJoiningComplexTokensState();
TokenSet valueParametersFollow = TokenSet.create(EQ, LBRACE, RBRACE, SEMICOLON, RPAR);
if (at(LT)) { if (at(LT)) {
PsiBuilder.Marker error = mark(); PsiBuilder.Marker error = mark();
parseTypeParameterList(TokenSet.orSet(TokenSet.create(LPAR), valueParametersFollow)); parseTypeParameterList(LPAR_VALUE_PARAMETERS_FOLLOW_SET);
if (typeParameterListOccurred) { if (typeParameterListOccurred) {
int finishIndex = myBuilder.rawTokenIndex(); int finishIndex = myBuilder.rawTokenIndex();
error.rollbackTo(); error.rollbackTo();
@@ -1753,7 +1785,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
if (at(LPAR)) { if (at(LPAR)) {
parseValueParameterList(false, /* typeRequired = */ false, valueParametersFollow); parseValueParameterList(false, /* typeRequired = */ false, VALUE_PARAMETERS_FOLLOW_SET);
} }
else { else {
error("Expecting '('"); error("Expecting '('");
@@ -1851,22 +1883,17 @@ public class KotlinParsing extends AbstractKotlinParsing {
} }
private boolean definitelyOutOfReceiver() { private boolean definitelyOutOfReceiver() {
return atSet(EQ, COLON, LBRACE, RBRACE, BY_KEYWORD) || atSet(TOP_LEVEL_DECLARATION_FIRST); return atSet(definitelyOutOfReceiverSet);
} }
/* /*
* IDENTIFIER * IDENTIFIER
*/ */
private boolean parseFunctionOrPropertyName(boolean receiverFound, String title, TokenSet nameFollow, boolean nameRequired) { private boolean parseFunctionOrPropertyName(boolean receiverFound, String title, TokenSet nameFollow, TokenSet recoverySet, boolean nameRequired) {
if (!nameRequired && atSet(nameFollow)) return true; // no name if (!nameRequired && atSet(nameFollow)) return true; // no name
TokenSet recoverySet = TokenSet.orSet(nameFollow, TokenSet.create(LBRACE, RBRACE), TOP_LEVEL_DECLARATION_FIRST); String expectingMessage = "Expecting " + title + " name" + (!receiverFound ? " or receiver type" : "");
if (!receiverFound) { return expect(IDENTIFIER, expectingMessage, recoverySet);
return expect(IDENTIFIER, "Expecting " + title + " name or receiver type", recoverySet);
}
else {
return expect(IDENTIFIER, "Expecting " + title + " name", recoverySet);
}
} }
/* /*
@@ -2079,14 +2106,14 @@ public class KotlinParsing extends AbstractKotlinParsing {
parseAnnotations(DEFAULT); parseAnnotations(DEFAULT);
PsiBuilder.Marker reference = mark(); PsiBuilder.Marker reference = mark();
if (expect(IDENTIFIER, "Expecting type parameter name", TokenSet.orSet(TokenSet.create(COLON, COMMA, LBRACE, RBRACE), TYPE_REF_FIRST))) { if (expect(IDENTIFIER, "Expecting type parameter name", COLON_COMMA_LBRACE_RBRACE_TYPE_REF_FIRST_SET)) {
reference.done(REFERENCE_EXPRESSION); reference.done(REFERENCE_EXPRESSION);
} }
else { else {
reference.drop(); reference.drop();
} }
expect(COLON, "Expecting ':' before the upper bound", TokenSet.orSet(TokenSet.create(LBRACE, RBRACE), TYPE_REF_FIRST)); expect(COLON, "Expecting ':' before the upper bound", LBRACE_RBRACE_TYPE_REF_FIRST_SET);
parseTypeRef(); parseTypeRef();
@@ -2114,7 +2141,7 @@ public class KotlinParsing extends AbstractKotlinParsing {
PsiBuilder.Marker mark = mark(); PsiBuilder.Marker mark = mark();
parseModifierList(DEFAULT, TokenSet.create(GT, COMMA, COLON)); parseModifierList(DEFAULT, GT_COMMA_COLON_SET);
expect(IDENTIFIER, "Type parameter name expected", TokenSet.EMPTY); expect(IDENTIFIER, "Type parameter name expected", TokenSet.EMPTY);
compiler/psi/src/org/jetbrains/kotlin/psi/KtClass.kt
+3 -1
View File
@@ -13,6 +13,8 @@ import org.jetbrains.kotlin.psi.stubs.KotlinClassStub
import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
open class KtClass : KtClassOrObject { open class KtClass : KtClassOrObject {
private val classInterfaceTokenSet = TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD)
constructor(node: ASTNode) : super(node) constructor(node: ASTNode) : super(node)
constructor(stub: KotlinClassStub) : super(stub, KtStubElementTypes.CLASS) constructor(stub: KotlinClassStub) : super(stub, KtStubElementTypes.CLASS)
@@ -36,7 +38,7 @@ open class KtClass : KtClassOrObject {
override fun getCompanionObjects(): List<KtObjectDeclaration> = body?.allCompanionObjects.orEmpty() override fun getCompanionObjects(): List<KtObjectDeclaration> = body?.allCompanionObjects.orEmpty()
fun getClassOrInterfaceKeyword(): PsiElement? = findChildByType(TokenSet.create(KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD)) fun getClassOrInterfaceKeyword(): PsiElement? = findChildByType(classInterfaceTokenSet)
fun getClassKeyword(): PsiElement? = findChildByType(KtTokens.CLASS_KEYWORD) fun getClassKeyword(): PsiElement? = findChildByType(KtTokens.CLASS_KEYWORD)
compiler/psi/src/org/jetbrains/kotlin/psi/KtClassBody.kt
+5 -2
View File
@@ -27,6 +27,9 @@ import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes.*
import java.util.* import java.util.*
class KtClassBody : KtElementImplStub<KotlinPlaceHolderStub<KtClassBody>>, KtDeclarationContainer { class KtClassBody : KtElementImplStub<KotlinPlaceHolderStub<KtClassBody>>, KtDeclarationContainer {
private val lBraceTokenSet = TokenSet.create(KtTokens.LBRACE)
private val rBraceTokenSet = TokenSet.create(KtTokens.RBRACE)
constructor(node: ASTNode) : super(node) constructor(node: ASTNode) : super(node)
constructor(stub: KotlinPlaceHolderStub<KtClassBody>) : super(stub, CLASS_BODY) constructor(stub: KotlinPlaceHolderStub<KtClassBody>) : super(stub, CLASS_BODY)
@@ -56,10 +59,10 @@ class KtClassBody : KtElementImplStub<KotlinPlaceHolderStub<KtClassBody>>, KtDec
get() = getStubOrPsiChildrenAsList(KtStubElementTypes.OBJECT_DECLARATION).filter { it.isCompanion() } get() = getStubOrPsiChildrenAsList(KtStubElementTypes.OBJECT_DECLARATION).filter { it.isCompanion() }
val rBrace: PsiElement? val rBrace: PsiElement?
get() = node.getChildren(TokenSet.create(KtTokens.RBRACE)).singleOrNull()?.psi get() = node.getChildren(rBraceTokenSet).singleOrNull()?.psi
val lBrace: PsiElement? val lBrace: PsiElement?
get() = node.getChildren(TokenSet.create(KtTokens.LBRACE)).singleOrNull()?.psi get() = node.getChildren(lBraceTokenSet).singleOrNull()?.psi
/** /**
* @return annotations that do not belong to any declaration due to incomplete code or syntax errors * @return annotations that do not belong to any declaration due to incomplete code or syntax errors
compiler/psi/src/org/jetbrains/kotlin/psi/KtClassOrObject.kt
+5 -8
View File
@@ -25,10 +25,8 @@ import com.intellij.psi.impl.CheckUtil
import com.intellij.psi.stubs.IStubElementType import com.intellij.psi.stubs.IStubElementType
import com.intellij.psi.tree.TokenSet import com.intellij.psi.tree.TokenSet
import com.intellij.psi.util.PsiTreeUtil import com.intellij.psi.util.PsiTreeUtil
import org.jetbrains.kotlin.KtNodeTypes
import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.psi.psiUtil.ClassIdCalculator import org.jetbrains.kotlin.psi.psiUtil.ClassIdCalculator
import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub
import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
@@ -124,12 +122,11 @@ abstract class KtClassOrObject :
fun isAnnotation(): Boolean = hasModifier(KtTokens.ANNOTATION_KEYWORD) fun isAnnotation(): Boolean = hasModifier(KtTokens.ANNOTATION_KEYWORD)
fun getDeclarationKeyword(): PsiElement? = fun getDeclarationKeyword(): PsiElement? = findChildByType(classInterfaceObjectTokenSet)
findChildByType(
TokenSet.create( private val classInterfaceObjectTokenSet = TokenSet.create(
KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD, KtTokens.OBJECT_KEYWORD KtTokens.CLASS_KEYWORD, KtTokens.INTERFACE_KEYWORD, KtTokens.OBJECT_KEYWORD
) )
)
override fun delete() { override fun delete() {
CheckUtil.checkWritable(this) CheckUtil.checkWritable(this)
compiler/psi/src/org/jetbrains/kotlin/psi/KtDestructuringDeclaration.java
+3 -1
View File
@@ -31,6 +31,8 @@ import java.util.List;
import static org.jetbrains.kotlin.lexer.KtTokens.*; import static org.jetbrains.kotlin.lexer.KtTokens.*;
public class KtDestructuringDeclaration extends KtDeclarationImpl implements KtValVarKeywordOwner, KtDeclarationWithInitializer { public class KtDestructuringDeclaration extends KtDeclarationImpl implements KtValVarKeywordOwner, KtDeclarationWithInitializer {
private static final TokenSet VAL_VAR_KEYWORDS = TokenSet.create(VAL_KEYWORD, VAR_KEYWORD);
public KtDestructuringDeclaration(@NotNull ASTNode node) { public KtDestructuringDeclaration(@NotNull ASTNode node) {
super(node); super(node);
} }
@@ -67,7 +69,7 @@ public class KtDestructuringDeclaration extends KtDeclarationImpl implements KtV
@Override @Override
@Nullable @Nullable
public PsiElement getValOrVarKeyword() { public PsiElement getValOrVarKeyword() {
return findChildByType(TokenSet.create(VAL_KEYWORD, VAR_KEYWORD)); return findChildByType(VAL_VAR_KEYWORDS);
} }
@Nullable @Nullable
compiler/psi/src/org/jetbrains/kotlin/psi/KtDestructuringDeclarationEntry.java
+4 -1
View File
@@ -36,6 +36,9 @@ import static org.jetbrains.kotlin.lexer.KtTokens.VAR_KEYWORD;
@SuppressWarnings("deprecation") @SuppressWarnings("deprecation")
public class KtDestructuringDeclarationEntry extends KtNamedDeclarationNotStubbed implements KtVariableDeclaration { public class KtDestructuringDeclarationEntry extends KtNamedDeclarationNotStubbed implements KtVariableDeclaration {
private static final TokenSet VAL_VAR_KEYWORDS = TokenSet.create(VAL_KEYWORD, VAR_KEYWORD);
public KtDestructuringDeclarationEntry(@NotNull ASTNode node) { public KtDestructuringDeclarationEntry(@NotNull ASTNode node) {
super(node); super(node);
} }
@@ -136,7 +139,7 @@ public class KtDestructuringDeclarationEntry extends KtNamedDeclarationNotStubbe
@Override @Override
public PsiElement getValOrVarKeyword() { public PsiElement getValOrVarKeyword() {
ASTNode node = getParentNode().findChildByType(TokenSet.create(VAL_KEYWORD, VAR_KEYWORD)); ASTNode node = getParentNode().findChildByType(VAL_VAR_KEYWORDS);
if (node == null) return null; if (node == null) return null;
return node.getPsi(); return node.getPsi();
} }