From cf190f0cf2109e39b8464430a257745ab5e699f6 Mon Sep 17 00:00:00 2001 From: Ivan Kochurkin Date: Sun, 31 Jul 2022 22:03:53 +0200 Subject: [PATCH] Use switch case statement instead of sequence of if comparisons in parser --- .../kotlin/kdoc/lexer/KDocToken.java | 4 +- .../kotlin/kdoc/lexer/KDocTokens.java | 26 +- .../kotlin/lexer/KtKeywordToken.java | 16 +- .../kotlin/lexer/KtModifierKeywordToken.java | 12 +- .../kotlin/lexer/KtSingleValueToken.java | 5 +- .../org/jetbrains/kotlin/lexer/KtToken.java | 5 +- .../org/jetbrains/kotlin/lexer/KtTokens.java | 448 ++++++++++++------ .../kotlin/parsing/AbstractKotlinParsing.java | 70 +-- .../parsing/KotlinExpressionParsing.java | 251 +++++----- .../kotlin/parsing/KotlinParsing.java | 37 +- 10 files changed, 526 insertions(+), 348 deletions(-) diff --git a/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java b/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java index aea59f749cb..5ce83b73ca7 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java +++ b/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocToken.java @@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.lexer.KtToken; public class KDocToken extends KtToken { - public KDocToken(@NotNull @NonNls String debugName) { - super(debugName); + public KDocToken(@NotNull @NonNls String debugName, int tokenId) { + super(debugName, tokenId); } } diff --git a/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocTokens.java b/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocTokens.java index 4d7e1127af1..86d2c5e93db 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocTokens.java +++ b/compiler/psi/src/org/jetbrains/kotlin/kdoc/lexer/KDocTokens.java @@ -50,14 +50,23 @@ public interface KDocTokens { } }; - KDocToken START = new KDocToken("KDOC_START"); - KDocToken END = new KDocToken("KDOC_END"); - KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK"); + int START_Id = 0; + int END_Id = 1; + int LEADING_ASTERISK_Id = 2; + int TEXT_Id = 3; + int CODE_BLOCK_TEXT_Id = 4; + int TAG_NAME_Id = 5; + int MARKDOWN_ESCAPED_CHAR_Id = 6; + int MARKDOWN_INLINE_LINK_Id = 7; - KDocToken TEXT = new KDocToken("KDOC_TEXT"); - KDocToken CODE_BLOCK_TEXT = new KDocToken("KDOC_CODE_BLOCK_TEXT"); + KDocToken START = new KDocToken("KDOC_START", START_Id); + KDocToken END = new KDocToken("KDOC_END", END_Id); + KDocToken LEADING_ASTERISK = new KDocToken("KDOC_LEADING_ASTERISK", LEADING_ASTERISK_Id); - KDocToken TAG_NAME = new KDocToken("KDOC_TAG_NAME"); + KDocToken TEXT = new KDocToken("KDOC_TEXT", TEXT_Id); + KDocToken CODE_BLOCK_TEXT = new KDocToken("KDOC_CODE_BLOCK_TEXT", CODE_BLOCK_TEXT_Id); + + KDocToken TAG_NAME = new KDocToken("KDOC_TAG_NAME", TAG_NAME_Id); ILazyParseableElementType MARKDOWN_LINK = new ILazyParseableElementType("KDOC_MARKDOWN_LINK", KotlinLanguage.INSTANCE) { @Override public ASTNode parseContents(ASTNode chameleon) { @@ -65,9 +74,8 @@ public interface KDocTokens { } }; - KDocToken MARKDOWN_ESCAPED_CHAR = new KDocToken("KDOC_MARKDOWN_ESCAPED_CHAR"); - KDocToken MARKDOWN_INLINE_LINK = new KDocToken("KDOC_MARKDOWN_INLINE_LINK"); - + KDocToken MARKDOWN_ESCAPED_CHAR = new KDocToken("KDOC_MARKDOWN_ESCAPED_CHAR", MARKDOWN_ESCAPED_CHAR_Id); + KDocToken MARKDOWN_INLINE_LINK = new KDocToken("KDOC_MARKDOWN_INLINE_LINK", MARKDOWN_INLINE_LINK_Id); TokenSet KDOC_HIGHLIGHT_TOKENS = TokenSet.create(START, END, LEADING_ASTERISK, TEXT, CODE_BLOCK_TEXT, MARKDOWN_LINK, MARKDOWN_ESCAPED_CHAR, MARKDOWN_INLINE_LINK); TokenSet CONTENT_TOKENS = TokenSet.create(TEXT, CODE_BLOCK_TEXT, TAG_NAME, MARKDOWN_LINK, MARKDOWN_ESCAPED_CHAR, MARKDOWN_INLINE_LINK); } diff --git a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java index a13e950ce3e..9dca66addeb 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java +++ b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtKeywordToken.java @@ -24,25 +24,25 @@ public class KtKeywordToken extends KtSingleValueToken { /** * Generate keyword (identifier that has a keyword meaning in all possible contexts) */ - public static KtKeywordToken keyword(String value) { - return keyword(value, value); + public static KtKeywordToken keyword(String value, int tokenId) { + return keyword(value, value, tokenId); } - public static KtKeywordToken keyword(String debugName, String value) { - return new KtKeywordToken(debugName, value, false); + public static KtKeywordToken keyword(String debugName, String value, int tokenId) { + return new KtKeywordToken(debugName, value, false, tokenId); } /** * Generate soft keyword (identifier that has a keyword meaning only in some contexts) */ - public static KtKeywordToken softKeyword(String value) { - return new KtKeywordToken(value, value, true); + public static KtKeywordToken softKeyword(String value, int tokenId) { + return new KtKeywordToken(value, value, true, tokenId); } private final boolean myIsSoft; - protected KtKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) { - super(debugName, value); + protected KtKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft, int tokenId) { + super(debugName, value, tokenId); myIsSoft = isSoft; } diff --git a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java index c83d08ec5ab..61b4dd632e1 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java +++ b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtModifierKeywordToken.java @@ -25,18 +25,18 @@ public final class KtModifierKeywordToken extends KtKeywordToken { /** * Generate keyword (identifier that has a keyword meaning in all possible contexts) */ - public static KtModifierKeywordToken keywordModifier(String value) { - return new KtModifierKeywordToken(value, value, false); + public static KtModifierKeywordToken keywordModifier(String value, int tokenId) { + return new KtModifierKeywordToken(value, value, false, tokenId); } /** * Generate soft keyword (identifier that has a keyword meaning only in some contexts) */ - public static KtModifierKeywordToken softKeywordModifier(String value) { - return new KtModifierKeywordToken(value, value, true); + public static KtModifierKeywordToken softKeywordModifier(String value, int tokenId) { + return new KtModifierKeywordToken(value, value, true, tokenId); } - private KtModifierKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft) { - super(debugName, value, isSoft); + private KtModifierKeywordToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, boolean isSoft, int tokenId) { + super(debugName, value, isSoft, tokenId); } } diff --git a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java index eab2649fdb0..310303f0354 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java +++ b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtSingleValueToken.java @@ -20,11 +20,10 @@ import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; public class KtSingleValueToken extends KtToken { - private final String myValue; - public KtSingleValueToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value) { - super(debugName); + public KtSingleValueToken(@NotNull @NonNls String debugName, @NotNull @NonNls String value, int tokenId) { + super(debugName, tokenId); myValue = value; } diff --git a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtToken.java b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtToken.java index c9c13fd230e..90d5983b635 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtToken.java +++ b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtToken.java @@ -22,7 +22,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.KotlinLanguage; public class KtToken extends IElementType { - public KtToken(@NotNull @NonNls String debugName) { + public final int tokenId; + + public KtToken(@NotNull @NonNls String debugName, int tokenId) { super(debugName, KotlinLanguage.INSTANCE); + this.tokenId = tokenId; } } diff --git a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtTokens.java b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtTokens.java index 4346d238bc7..4ae4d9724a2 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/lexer/KtTokens.java +++ b/compiler/psi/src/org/jetbrains/kotlin/lexer/KtTokens.java @@ -26,181 +26,331 @@ import static org.jetbrains.kotlin.KtNodeTypes.DOT_QUALIFIED_EXPRESSION; import static org.jetbrains.kotlin.KtNodeTypes.SAFE_ACCESS_EXPRESSION; public interface KtTokens { - KtToken EOF = new KtToken("EOF"); + int INVALID_Id = 0; + int EOF_Id = 1; + int RESERVED_Id = 2; + int BLOCK_COMMENT_Id = 3; + int EOL_COMMENT_Id = 4; + int SHEBANG_COMMENT_Id = 5; + int INTEGER_LITERAL_Id = 6; + int FLOAT_LITERAL_Id = 7; + int CHARACTER_LITERAL_Id = 8; + int CLOSING_QUOTE_Id = 9; + int OPEN_QUOTE_Id = 10; + int REGULAR_STRING_PART_Id = 11; + int ESCAPE_SEQUENCE_Id = 12; + int SHORT_TEMPLATE_ENTRY_START_Id = 13; + int LONG_TEMPLATE_ENTRY_START_Id = 14; + int LONG_TEMPLATE_ENTRY_END_Id = 15; + int DANGLING_NEWLINE_Id = 16; + int PACKAGE_KEYWORD_Id = 17; + int AS_KEYWORD_Id = 18; + int TYPE_ALIAS_KEYWORD_Id = 19; + int CLASS_KEYWORD_Id = 20; + int THIS_KEYWORD_Id = 21; + int SUPER_KEYWORD_Id = 22; + int VAL_KEYWORD_Id = 23; + int VAR_KEYWORD_Id = 24; + int FUN_KEYWORD_Id = 25; + int FOR_KEYWORD_Id = 26; + int NULL_KEYWORD_Id = 27; + int TRUE_KEYWORD_Id = 28; + int FALSE_KEYWORD_Id = 29; + int IS_KEYWORD_Id = 30; + int IN_KEYWORD_Id = 31; + int THROW_KEYWORD_Id = 32; + int RETURN_KEYWORD_Id = 33; + int BREAK_KEYWORD_Id = 34; + int CONTINUE_KEYWORD_Id = 35; + int OBJECT_KEYWORD_Id = 36; + int IF_KEYWORD_Id = 37; + int TRY_KEYWORD_Id = 38; + int ELSE_KEYWORD_Id = 39; + int WHILE_KEYWORD_Id = 40; + int DO_KEYWORD_Id = 41; + int WHEN_KEYWORD_Id = 42; + int INTERFACE_KEYWORD_Id = 43; + int TYPEOF_KEYWORD_Id = 44; + int AS_SAFE_Id = 45; + int IDENTIFIER_Id = 46; + int FIELD_IDENTIFIER_Id = 47; + int LBRACKET_Id = 48; + int RBRACKET_Id = 49; + int LBRACE_Id = 50; + int RBRACE_Id = 51; + int LPAR_Id = 52; + int RPAR_Id = 53; + int DOT_Id = 54; + int PLUSPLUS_Id = 55; + int MINUSMINUS_Id = 56; + int MUL_Id = 57; + int PLUS_Id = 58; + int MINUS_Id = 59; + int EXCL_Id = 60; + int DIV_Id = 61; + int PERC_Id = 62; + int LT_Id = 63; + int GT_Id = 64; + int LTEQ_Id = 65; + int GTEQ_Id = 66; + int EQEQEQ_Id = 67; + int ARROW_Id = 68; + int DOUBLE_ARROW_Id = 69; + int EXCLEQEQEQ_Id = 70; + int EQEQ_Id = 71; + int EXCLEQ_Id = 72; + int EXCLEXCL_Id = 73; + int ANDAND_Id = 74; + int AND_Id = 75; + int OROR_Id = 76; + int SAFE_ACCESS_Id = 77; + int ELVIS_Id = 78; + int QUEST_Id = 79; + int COLONCOLON_Id = 80; + int COLON_Id = 81; + int SEMICOLON_Id = 82; + int DOUBLE_SEMICOLON_Id = 83; + int RANGE_Id = 84; + int RANGE_UNTIL_Id = 85; + int EQ_Id = 86; + int MULTEQ_Id = 87; + int DIVEQ_Id = 88; + int PERCEQ_Id = 89; + int PLUSEQ_Id = 90; + int MINUSEQ_Id = 91; + int NOT_IN_Id = 92; + int NOT_IS_Id = 93; + int HASH_Id = 94; + int AT_Id = 95; + int COMMA_Id = 96; + int EOL_OR_SEMICOLON_Id = 97; + int FILE_KEYWORD_Id = 98; + int FIELD_KEYWORD_Id = 99; + int PROPERTY_KEYWORD_Id = 100; + int RECEIVER_KEYWORD_Id = 101; + int PARAM_KEYWORD_Id = 102; + int SETPARAM_KEYWORD_Id = 103; + int DELEGATE_KEYWORD_Id = 104; + int IMPORT_KEYWORD_Id = 105; + int WHERE_KEYWORD_Id = 106; + int BY_KEYWORD_Id = 107; + int GET_KEYWORD_Id = 108; + int SET_KEYWORD_Id = 109; + int CONSTRUCTOR_KEYWORD_Id = 110; + int INIT_KEYWORD_Id = 111; + int CONTEXT_KEYWORD_Id = 112; + int ABSTRACT_KEYWORD_Id = 113; + int ENUM_KEYWORD_Id = 114; + int CONTRACT_KEYWORD_Id = 115; + int OPEN_KEYWORD_Id = 116; + int INNER_KEYWORD_Id = 117; + int OVERRIDE_KEYWORD_Id = 118; + int PRIVATE_KEYWORD_Id = 119; + int PUBLIC_KEYWORD_Id = 120; + int INTERNAL_KEYWORD_Id = 121; + int PROTECTED_KEYWORD_Id = 122; + int CATCH_KEYWORD_Id = 123; + int OUT_KEYWORD_Id = 124; + int VARARG_KEYWORD_Id = 125; + int REIFIED_KEYWORD_Id = 126; + int DYNAMIC_KEYWORD_Id = 127; + int COMPANION_KEYWORD_Id = 128; + int SEALED_KEYWORD_Id = 129; + int FINALLY_KEYWORD_Id = 130; + int FINAL_KEYWORD_Id = 131; + int LATEINIT_KEYWORD_Id = 132; + int DATA_KEYWORD_Id = 133; + int VALUE_KEYWORD_Id = 134; + int INLINE_KEYWORD_Id = 135; + int NOINLINE_KEYWORD_Id = 136; + int TAILREC_KEYWORD_Id = 137; + int EXTERNAL_KEYWORD_Id = 138; + int ANNOTATION_KEYWORD_Id = 139; + int CROSSINLINE_KEYWORD_Id = 140; + int OPERATOR_KEYWORD_Id = 141; + int INFIX_KEYWORD_Id = 142; + int CONST_KEYWORD_Id = 143; + int SUSPEND_KEYWORD_Id = 144; + int HEADER_KEYWORD_Id = 145; + int IMPL_KEYWORD_Id = 146; + int EXPECT_KEYWORD_Id = 147; + int ACTUAL_KEYWORD_Id = 148; - KtToken RESERVED = new KtToken("RESERVED"); + KtToken EOF = new KtToken("EOF", EOF_Id); - KtToken BLOCK_COMMENT = new KtToken("BLOCK_COMMENT"); - KtToken EOL_COMMENT = new KtToken("EOL_COMMENT"); - KtToken SHEBANG_COMMENT = new KtToken("SHEBANG_COMMENT"); + KtToken RESERVED = new KtToken("RESERVED", RESERVED_Id); + + KtToken BLOCK_COMMENT = new KtToken("BLOCK_COMMENT", BLOCK_COMMENT_Id); + KtToken EOL_COMMENT = new KtToken("EOL_COMMENT", EOL_COMMENT_Id); + KtToken SHEBANG_COMMENT = new KtToken("SHEBANG_COMMENT", SHEBANG_COMMENT_Id); - //KtToken DOC_COMMENT = new KtToken("DOC_COMMENT"); IElementType DOC_COMMENT = KDocTokens.KDOC; IElementType WHITE_SPACE = TokenType.WHITE_SPACE; - KtToken INTEGER_LITERAL = new KtToken("INTEGER_LITERAL"); - KtToken FLOAT_LITERAL = new KtToken("FLOAT_CONSTANT"); - KtToken CHARACTER_LITERAL = new KtToken("CHARACTER_LITERAL"); + KtToken INTEGER_LITERAL = new KtToken("INTEGER_LITERAL", INTEGER_LITERAL_Id); + KtToken FLOAT_LITERAL = new KtToken("FLOAT_CONSTANT", FLOAT_LITERAL_Id); + KtToken CHARACTER_LITERAL = new KtToken("CHARACTER_LITERAL", CHARACTER_LITERAL_Id); - KtToken CLOSING_QUOTE = new KtToken("CLOSING_QUOTE"); - KtToken OPEN_QUOTE = new KtToken("OPEN_QUOTE"); - KtToken REGULAR_STRING_PART = new KtToken("REGULAR_STRING_PART"); - KtToken ESCAPE_SEQUENCE = new KtToken("ESCAPE_SEQUENCE"); - KtToken SHORT_TEMPLATE_ENTRY_START = new KtToken("SHORT_TEMPLATE_ENTRY_START"); - KtToken LONG_TEMPLATE_ENTRY_START = new KtToken("LONG_TEMPLATE_ENTRY_START"); - KtToken LONG_TEMPLATE_ENTRY_END = new KtToken("LONG_TEMPLATE_ENTRY_END"); - KtToken DANGLING_NEWLINE = new KtToken("DANGLING_NEWLINE"); + KtToken CLOSING_QUOTE = new KtToken("CLOSING_QUOTE", CLOSING_QUOTE_Id); + KtToken OPEN_QUOTE = new KtToken("OPEN_QUOTE", OPEN_QUOTE_Id); + KtToken REGULAR_STRING_PART = new KtToken("REGULAR_STRING_PART", REGULAR_STRING_PART_Id); + KtToken ESCAPE_SEQUENCE = new KtToken("ESCAPE_SEQUENCE", ESCAPE_SEQUENCE_Id); + KtToken SHORT_TEMPLATE_ENTRY_START = new KtToken("SHORT_TEMPLATE_ENTRY_START", SHORT_TEMPLATE_ENTRY_START_Id); + KtToken LONG_TEMPLATE_ENTRY_START = new KtToken("LONG_TEMPLATE_ENTRY_START", LONG_TEMPLATE_ENTRY_START_Id); + KtToken LONG_TEMPLATE_ENTRY_END = new KtToken("LONG_TEMPLATE_ENTRY_END", LONG_TEMPLATE_ENTRY_END_Id); + KtToken DANGLING_NEWLINE = new KtToken("DANGLING_NEWLINE", DANGLING_NEWLINE_Id); - KtKeywordToken PACKAGE_KEYWORD = KtKeywordToken.keyword("package"); - KtKeywordToken AS_KEYWORD = KtKeywordToken.keyword("as"); - KtKeywordToken TYPE_ALIAS_KEYWORD = KtKeywordToken.keyword("typealias"); - KtKeywordToken CLASS_KEYWORD = KtKeywordToken.keyword("class"); - KtKeywordToken THIS_KEYWORD = KtKeywordToken.keyword("this"); - KtKeywordToken SUPER_KEYWORD = KtKeywordToken.keyword("super"); - KtKeywordToken VAL_KEYWORD = KtKeywordToken.keyword("val"); - KtKeywordToken VAR_KEYWORD = KtKeywordToken.keyword("var"); - KtModifierKeywordToken FUN_KEYWORD = KtModifierKeywordToken.keywordModifier("fun"); - KtKeywordToken FOR_KEYWORD = KtKeywordToken.keyword("for"); - KtKeywordToken NULL_KEYWORD = KtKeywordToken.keyword("null"); - KtKeywordToken TRUE_KEYWORD = KtKeywordToken.keyword("true"); - KtKeywordToken FALSE_KEYWORD = KtKeywordToken.keyword("false"); - KtKeywordToken IS_KEYWORD = KtKeywordToken.keyword("is"); - KtModifierKeywordToken IN_KEYWORD = KtModifierKeywordToken.keywordModifier("in"); - KtKeywordToken THROW_KEYWORD = KtKeywordToken.keyword("throw"); - KtKeywordToken RETURN_KEYWORD = KtKeywordToken.keyword("return"); - KtKeywordToken BREAK_KEYWORD = KtKeywordToken.keyword("break"); - KtKeywordToken CONTINUE_KEYWORD = KtKeywordToken.keyword("continue"); - KtKeywordToken OBJECT_KEYWORD = KtKeywordToken.keyword("object"); - KtKeywordToken IF_KEYWORD = KtKeywordToken.keyword("if"); - KtKeywordToken TRY_KEYWORD = KtKeywordToken.keyword("try"); - KtKeywordToken ELSE_KEYWORD = KtKeywordToken.keyword("else"); - KtKeywordToken WHILE_KEYWORD = KtKeywordToken.keyword("while"); - KtKeywordToken DO_KEYWORD = KtKeywordToken.keyword("do"); - KtKeywordToken WHEN_KEYWORD = KtKeywordToken.keyword("when"); - KtKeywordToken INTERFACE_KEYWORD = KtKeywordToken.keyword("interface"); + KtKeywordToken PACKAGE_KEYWORD = KtKeywordToken.keyword("package", PACKAGE_KEYWORD_Id); + KtKeywordToken AS_KEYWORD = KtKeywordToken.keyword("as", AS_KEYWORD_Id); + KtKeywordToken TYPE_ALIAS_KEYWORD = KtKeywordToken.keyword("typealias", TYPE_ALIAS_KEYWORD_Id); + KtKeywordToken CLASS_KEYWORD = KtKeywordToken.keyword("class", CLASS_KEYWORD_Id); + KtKeywordToken THIS_KEYWORD = KtKeywordToken.keyword("this", THIS_KEYWORD_Id); + KtKeywordToken SUPER_KEYWORD = KtKeywordToken.keyword("super", SUPER_KEYWORD_Id); + KtKeywordToken VAL_KEYWORD = KtKeywordToken.keyword("val", VAL_KEYWORD_Id); + KtKeywordToken VAR_KEYWORD = KtKeywordToken.keyword("var", VAR_KEYWORD_Id); + KtModifierKeywordToken FUN_KEYWORD = KtModifierKeywordToken.keywordModifier("fun", FUN_KEYWORD_Id); + KtKeywordToken FOR_KEYWORD = KtKeywordToken.keyword("for", FOR_KEYWORD_Id); + KtKeywordToken NULL_KEYWORD = KtKeywordToken.keyword("null", NULL_KEYWORD_Id); + KtKeywordToken TRUE_KEYWORD = KtKeywordToken.keyword("true", TRUE_KEYWORD_Id); + KtKeywordToken FALSE_KEYWORD = KtKeywordToken.keyword("false", FALSE_KEYWORD_Id); + KtKeywordToken IS_KEYWORD = KtKeywordToken.keyword("is", IS_KEYWORD_Id); + KtModifierKeywordToken IN_KEYWORD = KtModifierKeywordToken.keywordModifier("in", IN_KEYWORD_Id); + KtKeywordToken THROW_KEYWORD = KtKeywordToken.keyword("throw", THROW_KEYWORD_Id); + KtKeywordToken RETURN_KEYWORD = KtKeywordToken.keyword("return", RETURN_KEYWORD_Id); + KtKeywordToken BREAK_KEYWORD = KtKeywordToken.keyword("break", BREAK_KEYWORD_Id); + KtKeywordToken CONTINUE_KEYWORD = KtKeywordToken.keyword("continue", CONTINUE_KEYWORD_Id); + KtKeywordToken OBJECT_KEYWORD = KtKeywordToken.keyword("object", OBJECT_KEYWORD_Id); + KtKeywordToken IF_KEYWORD = KtKeywordToken.keyword("if", IF_KEYWORD_Id); + KtKeywordToken TRY_KEYWORD = KtKeywordToken.keyword("try", TRY_KEYWORD_Id); + KtKeywordToken ELSE_KEYWORD = KtKeywordToken.keyword("else", ELSE_KEYWORD_Id); + KtKeywordToken WHILE_KEYWORD = KtKeywordToken.keyword("while", WHILE_KEYWORD_Id); + KtKeywordToken DO_KEYWORD = KtKeywordToken.keyword("do", DO_KEYWORD_Id); + KtKeywordToken WHEN_KEYWORD = KtKeywordToken.keyword("when", WHEN_KEYWORD_Id); + KtKeywordToken INTERFACE_KEYWORD = KtKeywordToken.keyword("interface", INTERFACE_KEYWORD_Id); // Reserved for future use: - KtKeywordToken TYPEOF_KEYWORD = KtKeywordToken.keyword("typeof"); + KtKeywordToken TYPEOF_KEYWORD = KtKeywordToken.keyword("typeof", TYPEOF_KEYWORD_Id); - KtToken AS_SAFE = KtKeywordToken.keyword("AS_SAFE");//new KtToken("as?"); + KtToken AS_SAFE = KtKeywordToken.keyword("AS_SAFE", AS_SAFE_Id); - KtToken IDENTIFIER = new KtToken("IDENTIFIER"); + KtToken IDENTIFIER = new KtToken("IDENTIFIER", IDENTIFIER_Id); - KtToken FIELD_IDENTIFIER = new KtToken("FIELD_IDENTIFIER"); - KtSingleValueToken LBRACKET = new KtSingleValueToken("LBRACKET", "["); - KtSingleValueToken RBRACKET = new KtSingleValueToken("RBRACKET", "]"); - KtSingleValueToken LBRACE = new KtSingleValueToken("LBRACE", "{"); - KtSingleValueToken RBRACE = new KtSingleValueToken("RBRACE", "}"); - KtSingleValueToken LPAR = new KtSingleValueToken("LPAR", "("); - KtSingleValueToken RPAR = new KtSingleValueToken("RPAR", ")"); - KtSingleValueToken DOT = new KtSingleValueToken("DOT", "."); - KtSingleValueToken PLUSPLUS = new KtSingleValueToken("PLUSPLUS", "++"); - KtSingleValueToken MINUSMINUS = new KtSingleValueToken("MINUSMINUS", "--"); - KtSingleValueToken MUL = new KtSingleValueToken("MUL", "*"); - KtSingleValueToken PLUS = new KtSingleValueToken("PLUS", "+"); - KtSingleValueToken MINUS = new KtSingleValueToken("MINUS", "-"); - KtSingleValueToken EXCL = new KtSingleValueToken("EXCL", "!"); - KtSingleValueToken DIV = new KtSingleValueToken("DIV", "/"); - KtSingleValueToken PERC = new KtSingleValueToken("PERC", "%"); - KtSingleValueToken LT = new KtSingleValueToken("LT", "<"); - KtSingleValueToken GT = new KtSingleValueToken("GT", ">"); - KtSingleValueToken LTEQ = new KtSingleValueToken("LTEQ", "<="); - KtSingleValueToken GTEQ = new KtSingleValueToken("GTEQ", ">="); - KtSingleValueToken EQEQEQ = new KtSingleValueToken("EQEQEQ", "==="); - KtSingleValueToken ARROW = new KtSingleValueToken("ARROW", "->"); - KtSingleValueToken DOUBLE_ARROW = new KtSingleValueToken("DOUBLE_ARROW", "=>"); - KtSingleValueToken EXCLEQEQEQ = new KtSingleValueToken("EXCLEQEQEQ", "!=="); - KtSingleValueToken EQEQ = new KtSingleValueToken("EQEQ", "=="); - KtSingleValueToken EXCLEQ = new KtSingleValueToken("EXCLEQ", "!="); - KtSingleValueToken EXCLEXCL = new KtSingleValueToken("EXCLEXCL", "!!"); - KtSingleValueToken ANDAND = new KtSingleValueToken("ANDAND", "&&"); - KtSingleValueToken AND = new KtSingleValueToken("AND", "&"); - KtSingleValueToken OROR = new KtSingleValueToken("OROR", "||"); - KtSingleValueToken SAFE_ACCESS = new KtSingleValueToken("SAFE_ACCESS", "?."); - KtSingleValueToken ELVIS = new KtSingleValueToken("ELVIS", "?:"); - KtSingleValueToken QUEST = new KtSingleValueToken("QUEST", "?"); - KtSingleValueToken COLONCOLON = new KtSingleValueToken("COLONCOLON", "::"); - KtSingleValueToken COLON = new KtSingleValueToken("COLON", ":"); - KtSingleValueToken SEMICOLON = new KtSingleValueToken("SEMICOLON", ";"); - KtSingleValueToken DOUBLE_SEMICOLON = new KtSingleValueToken("DOUBLE_SEMICOLON", ";;"); - KtSingleValueToken RANGE = new KtSingleValueToken("RANGE", ".."); - KtSingleValueToken RANGE_UNTIL = new KtSingleValueToken("RANGE_UNTIL", "..<"); - KtSingleValueToken EQ = new KtSingleValueToken("EQ", "="); - KtSingleValueToken MULTEQ = new KtSingleValueToken("MULTEQ", "*="); - KtSingleValueToken DIVEQ = new KtSingleValueToken("DIVEQ", "/="); - KtSingleValueToken PERCEQ = new KtSingleValueToken("PERCEQ", "%="); - KtSingleValueToken PLUSEQ = new KtSingleValueToken("PLUSEQ", "+="); - KtSingleValueToken MINUSEQ = new KtSingleValueToken("MINUSEQ", "-="); - KtKeywordToken NOT_IN = KtKeywordToken.keyword("NOT_IN", "!in"); - KtKeywordToken NOT_IS = KtKeywordToken.keyword("NOT_IS", "!is"); - KtSingleValueToken HASH = new KtSingleValueToken("HASH", "#"); - KtSingleValueToken AT = new KtSingleValueToken("AT", "@"); + KtToken FIELD_IDENTIFIER = new KtToken("FIELD_IDENTIFIER", FIELD_IDENTIFIER_Id); + KtSingleValueToken LBRACKET = new KtSingleValueToken("LBRACKET", "[", LBRACKET_Id); + KtSingleValueToken RBRACKET = new KtSingleValueToken("RBRACKET", "]", RBRACKET_Id); + KtSingleValueToken LBRACE = new KtSingleValueToken("LBRACE", "{", LBRACE_Id); + KtSingleValueToken RBRACE = new KtSingleValueToken("RBRACE", "}", RBRACE_Id); + KtSingleValueToken LPAR = new KtSingleValueToken("LPAR", "(", LPAR_Id); + KtSingleValueToken RPAR = new KtSingleValueToken("RPAR", ")", RPAR_Id); + KtSingleValueToken DOT = new KtSingleValueToken("DOT", ".", DOT_Id); + KtSingleValueToken PLUSPLUS = new KtSingleValueToken("PLUSPLUS", "++", PLUSPLUS_Id); + KtSingleValueToken MINUSMINUS = new KtSingleValueToken("MINUSMINUS", "--", MINUSMINUS_Id); + KtSingleValueToken MUL = new KtSingleValueToken("MUL", "*", MUL_Id); + KtSingleValueToken PLUS = new KtSingleValueToken("PLUS", "+", PLUS_Id); + KtSingleValueToken MINUS = new KtSingleValueToken("MINUS", "-", MINUS_Id); + KtSingleValueToken EXCL = new KtSingleValueToken("EXCL", "!", EXCL_Id); + KtSingleValueToken DIV = new KtSingleValueToken("DIV", "/", DIV_Id); + KtSingleValueToken PERC = new KtSingleValueToken("PERC", "%", PERC_Id); + KtSingleValueToken LT = new KtSingleValueToken("LT", "<", LT_Id); + KtSingleValueToken GT = new KtSingleValueToken("GT", ">", GT_Id); + KtSingleValueToken LTEQ = new KtSingleValueToken("LTEQ", "<=", LTEQ_Id); + KtSingleValueToken GTEQ = new KtSingleValueToken("GTEQ", ">=", GTEQ_Id); + KtSingleValueToken EQEQEQ = new KtSingleValueToken("EQEQEQ", "===", EQEQEQ_Id); + KtSingleValueToken ARROW = new KtSingleValueToken("ARROW", "->", ARROW_Id); + KtSingleValueToken DOUBLE_ARROW = new KtSingleValueToken("DOUBLE_ARROW", "=>", DOUBLE_ARROW_Id); + KtSingleValueToken EXCLEQEQEQ = new KtSingleValueToken("EXCLEQEQEQ", "!==", EXCLEQEQEQ_Id); + KtSingleValueToken EQEQ = new KtSingleValueToken("EQEQ", "==", EQEQ_Id); + KtSingleValueToken EXCLEQ = new KtSingleValueToken("EXCLEQ", "!=", EXCLEQ_Id); + KtSingleValueToken EXCLEXCL = new KtSingleValueToken("EXCLEXCL", "!!", EXCLEXCL_Id); + KtSingleValueToken ANDAND = new KtSingleValueToken("ANDAND", "&&", ANDAND_Id); + KtSingleValueToken AND = new KtSingleValueToken("AND", "&", AND_Id); + KtSingleValueToken OROR = new KtSingleValueToken("OROR", "||", OROR_Id); + KtSingleValueToken SAFE_ACCESS = new KtSingleValueToken("SAFE_ACCESS", "?.", SAFE_ACCESS_Id); + KtSingleValueToken ELVIS = new KtSingleValueToken("ELVIS", "?:", ELVIS_Id); + KtSingleValueToken QUEST = new KtSingleValueToken("QUEST", "?", QUEST_Id); + KtSingleValueToken COLONCOLON = new KtSingleValueToken("COLONCOLON", "::", COLONCOLON_Id); + KtSingleValueToken COLON = new KtSingleValueToken("COLON", ":", COLON_Id); + KtSingleValueToken SEMICOLON = new KtSingleValueToken("SEMICOLON", ";", SEMICOLON_Id); + KtSingleValueToken DOUBLE_SEMICOLON = new KtSingleValueToken("DOUBLE_SEMICOLON", ";;", DOUBLE_SEMICOLON_Id); + KtSingleValueToken RANGE = new KtSingleValueToken("RANGE", "..", RANGE_Id); + KtSingleValueToken RANGE_UNTIL = new KtSingleValueToken("RANGE_UNTIL", "..<", RANGE_UNTIL_Id); + KtSingleValueToken EQ = new KtSingleValueToken("EQ", "=", EQ_Id); + KtSingleValueToken MULTEQ = new KtSingleValueToken("MULTEQ", "*=", MULTEQ_Id); + KtSingleValueToken DIVEQ = new KtSingleValueToken("DIVEQ", "/=", DIVEQ_Id); + KtSingleValueToken PERCEQ = new KtSingleValueToken("PERCEQ", "%=", PERCEQ_Id); + KtSingleValueToken PLUSEQ = new KtSingleValueToken("PLUSEQ", "+=", PLUSEQ_Id); + KtSingleValueToken MINUSEQ = new KtSingleValueToken("MINUSEQ", "-=", MINUSEQ_Id); + KtKeywordToken NOT_IN = KtKeywordToken.keyword("NOT_IN", "!in", NOT_IN_Id); + KtKeywordToken NOT_IS = KtKeywordToken.keyword("NOT_IS", "!is", NOT_IS_Id); + KtSingleValueToken HASH = new KtSingleValueToken("HASH", "#", HASH_Id); + KtSingleValueToken AT = new KtSingleValueToken("AT", "@", AT_Id); - KtSingleValueToken COMMA = new KtSingleValueToken("COMMA", ","); + KtSingleValueToken COMMA = new KtSingleValueToken("COMMA", ",", COMMA_Id); - KtToken EOL_OR_SEMICOLON = new KtToken("EOL_OR_SEMICOLON"); - KtKeywordToken FILE_KEYWORD = KtKeywordToken.softKeyword("file"); - KtKeywordToken FIELD_KEYWORD = KtKeywordToken.softKeyword("field"); - KtKeywordToken PROPERTY_KEYWORD = KtKeywordToken.softKeyword("property"); - KtKeywordToken RECEIVER_KEYWORD = KtKeywordToken.softKeyword("receiver"); - KtKeywordToken PARAM_KEYWORD = KtKeywordToken.softKeyword("param"); - KtKeywordToken SETPARAM_KEYWORD = KtKeywordToken.softKeyword("setparam"); - KtKeywordToken DELEGATE_KEYWORD = KtKeywordToken.softKeyword("delegate"); - KtKeywordToken IMPORT_KEYWORD = KtKeywordToken.softKeyword("import"); - KtKeywordToken WHERE_KEYWORD = KtKeywordToken.softKeyword("where"); - KtKeywordToken BY_KEYWORD = KtKeywordToken.softKeyword("by"); - KtKeywordToken GET_KEYWORD = KtKeywordToken.softKeyword("get"); - KtKeywordToken SET_KEYWORD = KtKeywordToken.softKeyword("set"); - KtKeywordToken CONSTRUCTOR_KEYWORD = KtKeywordToken.softKeyword("constructor"); - KtKeywordToken INIT_KEYWORD = KtKeywordToken.softKeyword("init"); - KtKeywordToken CONTEXT_KEYWORD = KtKeywordToken.softKeyword("context"); + KtToken EOL_OR_SEMICOLON = new KtToken("EOL_OR_SEMICOLON", EOL_OR_SEMICOLON_Id); + KtKeywordToken FILE_KEYWORD = KtKeywordToken.softKeyword("file", FILE_KEYWORD_Id); + KtKeywordToken FIELD_KEYWORD = KtKeywordToken.softKeyword("field", FIELD_KEYWORD_Id); + KtKeywordToken PROPERTY_KEYWORD = KtKeywordToken.softKeyword("property", PROPERTY_KEYWORD_Id); + KtKeywordToken RECEIVER_KEYWORD = KtKeywordToken.softKeyword("receiver", RECEIVER_KEYWORD_Id); + KtKeywordToken PARAM_KEYWORD = KtKeywordToken.softKeyword("param", PARAM_KEYWORD_Id); + KtKeywordToken SETPARAM_KEYWORD = KtKeywordToken.softKeyword("setparam", SETPARAM_KEYWORD_Id); + KtKeywordToken DELEGATE_KEYWORD = KtKeywordToken.softKeyword("delegate", DELEGATE_KEYWORD_Id); + KtKeywordToken IMPORT_KEYWORD = KtKeywordToken.softKeyword("import", IMPORT_KEYWORD_Id); + KtKeywordToken WHERE_KEYWORD = KtKeywordToken.softKeyword("where", WHERE_KEYWORD_Id); + KtKeywordToken BY_KEYWORD = KtKeywordToken.softKeyword("by", BY_KEYWORD_Id); + KtKeywordToken GET_KEYWORD = KtKeywordToken.softKeyword("get", GET_KEYWORD_Id); + KtKeywordToken SET_KEYWORD = KtKeywordToken.softKeyword("set", SET_KEYWORD_Id); + KtKeywordToken CONSTRUCTOR_KEYWORD = KtKeywordToken.softKeyword("constructor", CONSTRUCTOR_KEYWORD_Id); + KtKeywordToken INIT_KEYWORD = KtKeywordToken.softKeyword("init", INIT_KEYWORD_Id); + KtKeywordToken CONTEXT_KEYWORD = KtKeywordToken.softKeyword("context", CONTEXT_KEYWORD_Id); - KtModifierKeywordToken ABSTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("abstract"); - KtModifierKeywordToken ENUM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("enum"); - KtModifierKeywordToken CONTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("contract"); - KtModifierKeywordToken OPEN_KEYWORD = KtModifierKeywordToken.softKeywordModifier("open"); - KtModifierKeywordToken INNER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inner"); - KtModifierKeywordToken OVERRIDE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("override"); - KtModifierKeywordToken PRIVATE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("private"); - KtModifierKeywordToken PUBLIC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("public"); - KtModifierKeywordToken INTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("internal"); - KtModifierKeywordToken PROTECTED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("protected"); - KtKeywordToken CATCH_KEYWORD = KtKeywordToken.softKeyword("catch"); - KtModifierKeywordToken OUT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("out"); - KtModifierKeywordToken VARARG_KEYWORD = KtModifierKeywordToken.softKeywordModifier("vararg"); - KtModifierKeywordToken REIFIED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("reified"); - KtKeywordToken DYNAMIC_KEYWORD = KtKeywordToken.softKeyword("dynamic"); - KtModifierKeywordToken COMPANION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("companion"); - KtModifierKeywordToken SEALED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("sealed"); + KtModifierKeywordToken ABSTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("abstract", ABSTRACT_KEYWORD_Id); + KtModifierKeywordToken ENUM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("enum", ENUM_KEYWORD_Id); + KtModifierKeywordToken CONTRACT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("contract", CONTRACT_KEYWORD_Id); + KtModifierKeywordToken OPEN_KEYWORD = KtModifierKeywordToken.softKeywordModifier("open", OPEN_KEYWORD_Id); + KtModifierKeywordToken INNER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inner", INNER_KEYWORD_Id); + KtModifierKeywordToken OVERRIDE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("override", OVERRIDE_KEYWORD_Id); + KtModifierKeywordToken PRIVATE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("private", PRIVATE_KEYWORD_Id); + KtModifierKeywordToken PUBLIC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("public", PUBLIC_KEYWORD_Id); + KtModifierKeywordToken INTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("internal", INTERNAL_KEYWORD_Id); + KtModifierKeywordToken PROTECTED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("protected", PROTECTED_KEYWORD_Id); + KtKeywordToken CATCH_KEYWORD = KtKeywordToken.softKeyword("catch", CATCH_KEYWORD_Id); + KtModifierKeywordToken OUT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("out", OUT_KEYWORD_Id); + KtModifierKeywordToken VARARG_KEYWORD = KtModifierKeywordToken.softKeywordModifier("vararg", VARARG_KEYWORD_Id); + KtModifierKeywordToken REIFIED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("reified", REIFIED_KEYWORD_Id); + KtKeywordToken DYNAMIC_KEYWORD = KtKeywordToken.softKeyword("dynamic", DYNAMIC_KEYWORD_Id); + KtModifierKeywordToken COMPANION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("companion", COMPANION_KEYWORD_Id); + KtModifierKeywordToken SEALED_KEYWORD = KtModifierKeywordToken.softKeywordModifier("sealed", SEALED_KEYWORD_Id); KtModifierKeywordToken DEFAULT_VISIBILITY_KEYWORD = PUBLIC_KEYWORD; - KtKeywordToken FINALLY_KEYWORD = KtKeywordToken.softKeyword("finally"); - KtModifierKeywordToken FINAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("final"); + KtKeywordToken FINALLY_KEYWORD = KtKeywordToken.softKeyword("finally", FINALLY_KEYWORD_Id); + KtModifierKeywordToken FINAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("final", FINAL_KEYWORD_Id); - KtModifierKeywordToken LATEINIT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("lateinit"); + KtModifierKeywordToken LATEINIT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("lateinit", LATEINIT_KEYWORD_Id); - KtModifierKeywordToken DATA_KEYWORD = KtModifierKeywordToken.softKeywordModifier("data"); - KtModifierKeywordToken VALUE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("value"); - KtModifierKeywordToken INLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inline"); - KtModifierKeywordToken NOINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("noinline"); - KtModifierKeywordToken TAILREC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("tailrec"); - KtModifierKeywordToken EXTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("external"); - KtModifierKeywordToken ANNOTATION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("annotation"); - KtModifierKeywordToken CROSSINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("crossinline"); - KtModifierKeywordToken OPERATOR_KEYWORD = KtModifierKeywordToken.softKeywordModifier("operator"); - KtModifierKeywordToken INFIX_KEYWORD = KtModifierKeywordToken.softKeywordModifier("infix"); + KtModifierKeywordToken DATA_KEYWORD = KtModifierKeywordToken.softKeywordModifier("data", DATA_KEYWORD_Id); + KtModifierKeywordToken VALUE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("value", VALUE_KEYWORD_Id); + KtModifierKeywordToken INLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("inline", INLINE_KEYWORD_Id); + KtModifierKeywordToken NOINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("noinline", NOINLINE_KEYWORD_Id); + KtModifierKeywordToken TAILREC_KEYWORD = KtModifierKeywordToken.softKeywordModifier("tailrec", TAILREC_KEYWORD_Id); + KtModifierKeywordToken EXTERNAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("external", EXTERNAL_KEYWORD_Id); + KtModifierKeywordToken ANNOTATION_KEYWORD = KtModifierKeywordToken.softKeywordModifier("annotation", ANNOTATION_KEYWORD_Id); + KtModifierKeywordToken CROSSINLINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("crossinline", CROSSINLINE_KEYWORD_Id); + KtModifierKeywordToken OPERATOR_KEYWORD = KtModifierKeywordToken.softKeywordModifier("operator", OPERATOR_KEYWORD_Id); + KtModifierKeywordToken INFIX_KEYWORD = KtModifierKeywordToken.softKeywordModifier("infix", INFIX_KEYWORD_Id); - KtModifierKeywordToken CONST_KEYWORD = KtModifierKeywordToken.softKeywordModifier("const"); + KtModifierKeywordToken CONST_KEYWORD = KtModifierKeywordToken.softKeywordModifier("const", CONST_KEYWORD_Id); - KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend"); + KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend", SUSPEND_KEYWORD_Id); - KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header"); - KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl"); + KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header", HEADER_KEYWORD_Id); + KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl", IMPL_KEYWORD_Id); + + KtModifierKeywordToken EXPECT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("expect", EXPECT_KEYWORD_Id); + KtModifierKeywordToken ACTUAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("actual", ACTUAL_KEYWORD_Id); - KtModifierKeywordToken EXPECT_KEYWORD = KtModifierKeywordToken.softKeywordModifier("expect"); - KtModifierKeywordToken ACTUAL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("actual"); TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD, THIS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, FUN_KEYWORD, FOR_KEYWORD, diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java index 5bb17b8a36c..0ff0b549c89 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/AbstractKotlinParsing.java @@ -144,6 +144,11 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*; myBuilder.advanceLexer(); } + protected int getTokenId() { + IElementType elementType = tt(); + return (elementType instanceof KtToken) ? ((KtToken)elementType).tokenId : INVALID_Id; + } + protected IElementType tt() { return myBuilder.getTokenType(); } @@ -302,39 +307,42 @@ import static org.jetbrains.kotlin.lexer.KtTokens.*; pattern.isTopLevel(openAngleBrackets, openBrackets, openBraces, openParentheses))) { break; } - if (at(LPAR)) { - openParentheses++; - opens.push(LPAR); - } - else if (at(LT)) { - openAngleBrackets++; - opens.push(LT); - } - else if (at(LBRACE)) { - openBraces++; - opens.push(LBRACE); - } - else if (at(LBRACKET)) { - openBrackets++; - opens.push(LBRACKET); - } - else if (at(RPAR)) { - openParentheses--; - if (opens.isEmpty() || opens.pop() != LPAR) { - if (pattern.handleUnmatchedClosing(RPAR)) { - break; + switch (getTokenId()) { + case LPAR_Id: + openParentheses++; + opens.push(LPAR); + break; + case LT_Id: + openAngleBrackets++; + opens.push(LT); + break; + case LBRACE_Id: + openBraces++; + opens.push(LBRACE); + break; + case LBRACKET_Id: + openBrackets++; + opens.push(LBRACKET); + break; + case RPAR_Id: + openParentheses--; + if (opens.isEmpty() || opens.pop() != LPAR) { + if (pattern.handleUnmatchedClosing(RPAR)) { + break; + } } - } - } - else if (at(GT)) { - openAngleBrackets--; - } - else if (at(RBRACE)) { - openBraces--; - } - else if (at(RBRACKET)) { - openBrackets--; + break; + case GT_Id: + openAngleBrackets--; + break; + case RBRACE_Id: + openBraces--; + break; + case RBRACKET_Id: + openBrackets--; + break; } + advance(); // skip token } diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java index bfd0a4284dc..edb7b674227 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java @@ -630,66 +630,104 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { private boolean parseAtomicExpression() { boolean ok = true; - if (at(LPAR)) { - parseParenthesizedExpression(); + switch (getTokenId()) { + case LPAR_Id: + parseParenthesizedExpression(); + break; + case LBRACKET_Id: + parseCollectionLiteralExpression(); + break; + case THIS_KEYWORD_Id: + parseThisExpression(); + break; + case SUPER_KEYWORD_Id: + parseSuperExpression(); + break; + case OBJECT_KEYWORD_Id: + parseObjectLiteral(); + break; + case THROW_KEYWORD_Id: + parseThrow(); + break; + case RETURN_KEYWORD_Id: + parseReturn(); + break; + case CONTINUE_KEYWORD_Id: + parseJump(CONTINUE); + break; + case BREAK_KEYWORD_Id: + parseJump(BREAK); + break; + case IF_KEYWORD_Id: + parseIf(); + break; + case WHEN_KEYWORD_Id: + parseWhen(); + break; + case TRY_KEYWORD_Id: + parseTry(); + break; + case FOR_KEYWORD_Id: + parseFor(); + break; + case WHILE_KEYWORD_Id: + parseWhile(); + break; + case DO_KEYWORD_Id: + parseDoWhile(); + break; + case IDENTIFIER_Id: + parseSimpleNameExpression(); + break; + case LBRACE_Id: + parseFunctionLiteral(); + break; + case OPEN_QUOTE_Id: + parseStringTemplate(); + break; + /* + * literalConstant + * : "true" | "false" + * : stringTemplate + * : NoEscapeString + * : IntegerLiteral + * : CharacterLiteral + * : FloatLiteral + * : "null" + * ; + */ + case TRUE_KEYWORD_Id: + case FALSE_KEYWORD_Id: + parseOneTokenExpression(BOOLEAN_CONSTANT); + break; + case INTEGER_LITERAL_Id: + parseOneTokenExpression(INTEGER_CONSTANT); + break; + case CHARACTER_LITERAL_Id: + parseOneTokenExpression(CHARACTER_CONSTANT); + break; + case FLOAT_LITERAL_Id: + parseOneTokenExpression(FLOAT_CONSTANT); + break; + case NULL_KEYWORD_Id: + parseOneTokenExpression(NULL); + break; + case CLASS_KEYWORD_Id: + case INTERFACE_KEYWORD_Id: + case FUN_KEYWORD_Id: + case VAL_KEYWORD_Id: + case VAR_KEYWORD_Id: + case TYPE_ALIAS_KEYWORD_Id: + if (!parseLocalDeclaration(/* rollbackIfDefinitelyNotExpression = */ myBuilder.newlineBeforeCurrentToken(), false)) { + ok = false; + } + // declaration was parsed, do nothing + break; + default: + ok = false; } - else if (at(LBRACKET)) { - parseCollectionLiteralExpression(); - } - else if (at(THIS_KEYWORD)) { - parseThisExpression(); - } - else if (at(SUPER_KEYWORD)) { - parseSuperExpression(); - } - else if (at(OBJECT_KEYWORD)) { - parseObjectLiteral(); - } - else if (at(THROW_KEYWORD)) { - parseThrow(); - } - else if (at(RETURN_KEYWORD)) { - parseReturn(); - } - else if (at(CONTINUE_KEYWORD)) { - parseJump(CONTINUE); - } - else if (at(BREAK_KEYWORD)) { - parseJump(BREAK); - } - else if (at(IF_KEYWORD)) { - parseIf(); - } - else if (at(WHEN_KEYWORD)) { - parseWhen(); - } - else if (at(TRY_KEYWORD)) { - parseTry(); - } - else if (at(FOR_KEYWORD)) { - parseFor(); - } - else if (at(WHILE_KEYWORD)) { - parseWhile(); - } - else if (at(DO_KEYWORD)) { - parseDoWhile(); - } - else if (atSet(LOCAL_DECLARATION_FIRST) && - parseLocalDeclaration(/* rollbackIfDefinitelyNotExpression = */ myBuilder.newlineBeforeCurrentToken(), false)) { - // declaration was parsed, do nothing - } - else if (at(IDENTIFIER)) { - parseSimpleNameExpression(); - } - else if (at(LBRACE)) { - parseFunctionLiteral(); - } - else if (at(OPEN_QUOTE)) { - parseStringTemplate(); - } - else if (!parseLiteralConstant()) { - ok = false; + + if (!ok) { // TODO: better recovery if FIRST(element) did not match errorWithRecovery("Expecting an element", TokenSet.orSet(EXPRESSION_FOLLOW, TokenSet.create(LONG_TEMPLATE_ENTRY_END))); } @@ -804,39 +842,6 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } } - /* - * literalConstant - * : "true" | "false" - * : stringTemplate - * : NoEscapeString - * : IntegerLiteral - * : CharacterLiteral - * : FloatLiteral - * : "null" - * ; - */ - private boolean parseLiteralConstant() { - if (at(TRUE_KEYWORD) || at(FALSE_KEYWORD)) { - parseOneTokenExpression(BOOLEAN_CONSTANT); - } - else if (at(INTEGER_LITERAL)) { - parseOneTokenExpression(INTEGER_CONSTANT); - } - else if (at(CHARACTER_LITERAL)) { - parseOneTokenExpression(CHARACTER_CONSTANT); - } - else if (at(FLOAT_LITERAL)) { - parseOneTokenExpression(FLOAT_CONSTANT); - } - else if (at(NULL_KEYWORD)) { - parseOneTokenExpression(NULL); - } - else { - return false; - } - return true; - } - /* * when * : "when" ("(" (modifiers "val" SimpleName "=")? element ")")? "{" @@ -963,39 +968,45 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { private void parseWhenCondition() { PsiBuilder.Marker condition = mark(); myBuilder.disableNewlines(); - if (at(IN_KEYWORD) || at(NOT_IN)) { - PsiBuilder.Marker mark = mark(); - advance(); // IN_KEYWORD or NOT_IN - mark.done(OPERATION_REFERENCE); + switch (getTokenId()) { + case IN_KEYWORD_Id: + case NOT_IN_Id: + PsiBuilder.Marker mark = mark(); + advance(); // IN_KEYWORD or NOT_IN + mark.done(OPERATION_REFERENCE); - if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) { - error("Expecting an element"); - } - else { - parseExpression(); - } - condition.done(WHEN_CONDITION_IN_RANGE); - } - else if (at(IS_KEYWORD) || at(NOT_IS)) { - advance(); // IS_KEYWORD or NOT_IS + if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) { + error("Expecting an element"); + } + else { + parseExpression(); + } + condition.done(WHEN_CONDITION_IN_RANGE); + break; + case IS_KEYWORD_Id: + case NOT_IS_Id: + advance(); // IS_KEYWORD or NOT_IS - if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) { - error("Expecting a type"); - } - else { - myKotlinParsing.parseTypeRef(); - } - condition.done(WHEN_CONDITION_IS_PATTERN); - } - else { - if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) { + if (atSet(WHEN_CONDITION_RECOVERY_SET_WITH_ARROW)) { + error("Expecting a type"); + } + else { + myKotlinParsing.parseTypeRef(); + } + condition.done(WHEN_CONDITION_IS_PATTERN); + break; + case RBRACE_Id: + case ELSE_KEYWORD_Id: + case ARROW_Id: + case DOT_Id: error("Expecting an expression, is-condition or in-condition"); - } - else { + condition.done(WHEN_CONDITION_EXPRESSION); + break; + default: parseExpression(); - } - condition.done(WHEN_CONDITION_EXPRESSION); + condition.done(WHEN_CONDITION_EXPRESSION); + break; } myBuilder.restoreNewlinesState(); } diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java index 724586291c4..a2bd46aa745 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java @@ -497,25 +497,24 @@ public class KotlinParsing extends AbstractKotlinParsing { @NotNull NameParsingMode nameParsingModeForObject, @NotNull DeclarationParsingMode declarationParsingMode ) { - IElementType keywordToken = tt(); - - if (keywordToken == CLASS_KEYWORD || keywordToken == INTERFACE_KEYWORD) { - return parseClass(detector.isEnumDetected(), true); - } - else if (keywordToken == FUN_KEYWORD) { - return parseFunction(); - } - else if (keywordToken == VAL_KEYWORD || keywordToken == VAR_KEYWORD) { - return parseProperty(declarationParsingMode); - } - else if (keywordToken == TYPE_ALIAS_KEYWORD) { - return parseTypeAlias(); - } - else if (keywordToken == OBJECT_KEYWORD) { - parseObject(nameParsingModeForObject, true); - return OBJECT_DECLARATION; - } else if (keywordToken == IDENTIFIER && detector.isEnumDetected() && declarationParsingMode.canBeEnumUsedAsSoftKeyword) { - return parseClass(true, false); + switch (getTokenId()) { + case CLASS_KEYWORD_Id: + case INTERFACE_KEYWORD_Id: + return parseClass(detector.isEnumDetected(), true); + case FUN_KEYWORD_Id: + return parseFunction(); + case VAL_KEYWORD_Id: + case VAR_KEYWORD_Id: + return parseProperty(declarationParsingMode); + case TYPE_ALIAS_KEYWORD_Id: + return parseTypeAlias(); + case OBJECT_KEYWORD_Id: + parseObject(nameParsingModeForObject, true); + return OBJECT_DECLARATION; + case IDENTIFIER_Id: + if (detector.isEnumDetected() && declarationParsingMode.canBeEnumUsedAsSoftKeyword) { + return parseClass(true, false); + } } return null;