diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java index 7c79500c79c..fffc0e738f5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java @@ -148,7 +148,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { AS(AS_KEYWORD, AS_SAFE) { @Override public KtNodeType parseRightHandSide(IElementType operation, KotlinExpressionParsing parser) { - parser.myJetParsing.parseTypeRef(); + parser.myKotlinParsing.parseTypeRef(); return BINARY_WITH_TYPE; } @@ -167,7 +167,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { @Override public KtNodeType parseRightHandSide(IElementType operation, KotlinExpressionParsing parser) { if (operation == IS_KEYWORD || operation == NOT_IS) { - parser.myJetParsing.parseTypeRef(); + parser.myKotlinParsing.parseTypeRef(); return IS_EXPRESSION; } @@ -257,11 +257,11 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } - private final KotlinParsing myJetParsing; + private final KotlinParsing myKotlinParsing; - public KotlinExpressionParsing(SemanticWhitespaceAwarePsiBuilder builder, KotlinParsing jetParsing) { + public KotlinExpressionParsing(SemanticWhitespaceAwarePsiBuilder builder, KotlinParsing kotlinParsing) { super(builder); - myJetParsing = jetParsing; + myKotlinParsing = kotlinParsing; } /* @@ -337,7 +337,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(AT)) { if (!parseLocalDeclaration()) { PsiBuilder.Marker expression = mark(); - myJetParsing.parseAnnotations(DEFAULT); + myKotlinParsing.parseAnnotations(DEFAULT); parsePrefixExpression(); expression.done(ANNOTATED_EXPRESSION); } @@ -375,8 +375,8 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (!at(COLONCOLON)) { PsiBuilder.Marker typeReference = mark(); - myJetParsing.parseUserType(); - typeReference = myJetParsing.parseNullableTypeSuffix(typeReference); + myKotlinParsing.parseUserType(); + typeReference = myKotlinParsing.parseNullableTypeSuffix(typeReference); typeReference.done(TYPE_REFERENCE); if (!at(COLONCOLON)) { @@ -396,7 +396,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(LT)) { PsiBuilder.Marker typeArgumentList = mark(); - if (myJetParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { + if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { typeArgumentList.error("Type arguments are not allowed"); } else { @@ -494,7 +494,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } else if (at(LT)) { PsiBuilder.Marker typeArgumentList = mark(); - if (myJetParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { + if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { typeArgumentList.done(TYPE_ARGUMENT_LIST); if (!myBuilder.newlineBeforeCurrentToken() && at(LPAR)) parseValueArgumentList(); parseCallWithClosure(); @@ -559,7 +559,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { private boolean parseAnnotatedLambda(boolean preferBlock) { PsiBuilder.Marker annotated = mark(); - boolean wereAnnotations = myJetParsing.parseAnnotations(DEFAULT); + boolean wereAnnotations = myKotlinParsing.parseAnnotations(DEFAULT); PsiBuilder.Marker labeled = mark(); boolean wasLabel = isAtLabelDefinitionOrMissingIdentifier(); @@ -837,9 +837,9 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { advanceAt(LPAR); PsiBuilder.Marker property = mark(); - myJetParsing.parseModifierList(DEFAULT, TokenSet.create(EQ, RPAR)); + myKotlinParsing.parseModifierList(DEFAULT, TokenSet.create(EQ, RPAR)); if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) { - myJetParsing.parseProperty(true); + myKotlinParsing.parseProperty(true); property.done(PROPERTY); } else { @@ -959,7 +959,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { error("Expecting a type"); } else { - myJetParsing.parseTypeRef(); + myKotlinParsing.parseTypeRef(); } condition.done(WHEN_CONDITION_IS_PATTERN); } @@ -1020,7 +1020,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { private boolean parseLocalDeclaration() { PsiBuilder.Marker decl = mark(); KotlinParsing.ModifierDetector detector = new KotlinParsing.ModifierDetector(); - myJetParsing.parseModifierList(detector, DEFAULT, TokenSet.EMPTY); + myKotlinParsing.parseModifierList(detector, DEFAULT, TokenSet.EMPTY); IElementType declType = parseLocalDeclarationRest(detector.isEnumDetected()); @@ -1153,7 +1153,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - myJetParsing.parseTypeRef(TokenSet.create(ARROW, COMMA)); + myKotlinParsing.parseTypeRef(TokenSet.create(ARROW, COMMA)); } parameter.done(VALUE_PARAMETER); @@ -1248,17 +1248,17 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { IElementType keywordToken = tt(); IElementType declType = null; if (keywordToken == CLASS_KEYWORD || keywordToken == INTERFACE_KEYWORD) { - declType = myJetParsing.parseClass(isEnum); + declType = myKotlinParsing.parseClass(isEnum); } else if (keywordToken == FUN_KEYWORD) { - declType = myJetParsing.parseFunction(); + declType = myKotlinParsing.parseFunction(); } else if (keywordToken == VAL_KEYWORD || keywordToken == VAR_KEYWORD) { - declType = myJetParsing.parseProperty(true); + declType = myKotlinParsing.parseProperty(true); } /* else if (keywordToken == TYPE_ALIAS_KEYWORD) { - declType = myJetParsing.parseTypeAlias(); + declType = myKotlinParsing.parseTypeAlias(); } */ else if (keywordToken == OBJECT_KEYWORD) { @@ -1274,7 +1274,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { return null; } - myJetParsing.parseObject(NameParsingMode.REQUIRED, true); + myKotlinParsing.parseObject(NameParsingMode.REQUIRED, true); declType = OBJECT_DECLARATION; } return declType; @@ -1343,13 +1343,13 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { PsiBuilder.Marker parameter = mark(); if (!at(IN_KEYWORD)) { - myJetParsing.parseModifierList(DEFAULT, TokenSet.create(IN_KEYWORD, RPAR, COLON)); + myKotlinParsing.parseModifierList(DEFAULT, TokenSet.create(IN_KEYWORD, RPAR, COLON)); } if (at(VAL_KEYWORD) || at(VAR_KEYWORD)) advance(); // VAL_KEYWORD or VAR_KEYWORD if (at(LPAR)) { - myJetParsing.parseMultiDeclarationName(TokenSet.create(IN_KEYWORD, LBRACE)); + myKotlinParsing.parseMultiDeclarationName(TokenSet.create(IN_KEYWORD, LBRACE)); parameter.done(DESTRUCTURING_DECLARATION); } else { @@ -1357,7 +1357,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - myJetParsing.parseTypeRef(TokenSet.create(IN_KEYWORD)); + myKotlinParsing.parseTypeRef(TokenSet.create(IN_KEYWORD)); } parameter.done(VALUE_PARAMETER); } @@ -1420,7 +1420,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { advance(); // TRY_KEYWORD - myJetParsing.parseBlock(); + myKotlinParsing.parseBlock(); boolean catchOrFinally = false; while (at(CATCH_KEYWORD)) { @@ -1436,7 +1436,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { PsiBuilder.Marker parameters = mark(); expect(LPAR, "Expecting '('", recoverySet); if (!atSet(recoverySet)) { - myJetParsing.parseValueParameter(/*typeRequired = */ true); + myKotlinParsing.parseValueParameter(/*typeRequired = */ true); expect(RPAR, "Expecting ')'", recoverySet); } else { @@ -1446,7 +1446,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } if (at(LBRACE)) { - myJetParsing.parseBlock(); + myKotlinParsing.parseBlock(); } else { error("Expecting a block: { ... }"); @@ -1460,7 +1460,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { advance(); // FINALLY_KEYWORD - myJetParsing.parseBlock(); + myKotlinParsing.parseBlock(); finallyBlock.done(FINALLY); } @@ -1690,7 +1690,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { myBuilder.disableNewlines(); advance(); // LT - myJetParsing.parseTypeRef(); + myKotlinParsing.parseTypeRef(); if (at(GT)) { advance(); // GT @@ -1767,7 +1767,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { public void parseObjectLiteral() { PsiBuilder.Marker literal = mark(); PsiBuilder.Marker declaration = mark(); - myJetParsing.parseObject(NameParsingMode.PROHIBITED, false); // Body is not optional because of foo(object : A, B) + myKotlinParsing.parseObject(NameParsingMode.PROHIBITED, false); // Body is not optional because of foo(object : A, B) declaration.done(OBJECT_DECLARATION); literal.done(OBJECT_LITERAL); } @@ -1780,7 +1780,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { @Override protected KotlinParsing create(SemanticWhitespaceAwarePsiBuilder builder) { - return myJetParsing.create(builder); + return myKotlinParsing.create(builder); } private boolean interruptedWithNewLine() { diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt index 5c43cbb3af8..85c9ce5dc7f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt +++ b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt @@ -44,8 +44,8 @@ fun SpacingBuilder.afterInside(element: IElementType, tokenSet: TokenSet, spacin } fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { - val jetSettings = settings.getCustomSettings(KotlinCodeStyleSettings::class.java)!! - val jetCommonSettings = settings.getCommonSettings(KotlinLanguage.INSTANCE)!! + val kotlinSettings = settings.getCustomSettings(KotlinCodeStyleSettings::class.java)!! + val kotlinCommonSettings = settings.getCommonSettings(KotlinLanguage.INSTANCE)!! return rules(settings) { val DECLARATIONS = @@ -122,18 +122,18 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { // =============== Spacing ================ betweenInside(LBRACE, RBRACE, CLASS_BODY).spaces(0) - before(COMMA).spaceIf(jetCommonSettings.SPACE_BEFORE_COMMA) - after(COMMA).spaceIf(jetCommonSettings.SPACE_AFTER_COMMA) + before(COMMA).spaceIf(kotlinCommonSettings.SPACE_BEFORE_COMMA) + after(COMMA).spaceIf(kotlinCommonSettings.SPACE_AFTER_COMMA) - around(TokenSet.create(EQ, MULTEQ, DIVEQ, PLUSEQ, MINUSEQ, PERCEQ)).spaceIf(jetCommonSettings.SPACE_AROUND_ASSIGNMENT_OPERATORS) - around(TokenSet.create(ANDAND, OROR)).spaceIf(jetCommonSettings.SPACE_AROUND_LOGICAL_OPERATORS) - around(TokenSet.create(EQEQ, EXCLEQ, EQEQEQ, EXCLEQEQEQ)).spaceIf(jetCommonSettings.SPACE_AROUND_EQUALITY_OPERATORS) - aroundInside(TokenSet.create(LT, GT, LTEQ, GTEQ), BINARY_EXPRESSION).spaceIf(jetCommonSettings.SPACE_AROUND_RELATIONAL_OPERATORS) - aroundInside(TokenSet.create(PLUS, MINUS), BINARY_EXPRESSION).spaceIf(jetCommonSettings.SPACE_AROUND_ADDITIVE_OPERATORS) - aroundInside(TokenSet.create(MUL, DIV, PERC), BINARY_EXPRESSION).spaceIf(jetCommonSettings.SPACE_AROUND_MULTIPLICATIVE_OPERATORS) - around(TokenSet.create(PLUSPLUS, MINUSMINUS, EXCLEXCL, MINUS, PLUS, EXCL)).spaceIf(jetCommonSettings.SPACE_AROUND_UNARY_OPERATOR) + around(TokenSet.create(EQ, MULTEQ, DIVEQ, PLUSEQ, MINUSEQ, PERCEQ)).spaceIf(kotlinCommonSettings.SPACE_AROUND_ASSIGNMENT_OPERATORS) + around(TokenSet.create(ANDAND, OROR)).spaceIf(kotlinCommonSettings.SPACE_AROUND_LOGICAL_OPERATORS) + around(TokenSet.create(EQEQ, EXCLEQ, EQEQEQ, EXCLEQEQEQ)).spaceIf(kotlinCommonSettings.SPACE_AROUND_EQUALITY_OPERATORS) + aroundInside(TokenSet.create(LT, GT, LTEQ, GTEQ), BINARY_EXPRESSION).spaceIf(kotlinCommonSettings.SPACE_AROUND_RELATIONAL_OPERATORS) + aroundInside(TokenSet.create(PLUS, MINUS), BINARY_EXPRESSION).spaceIf(kotlinCommonSettings.SPACE_AROUND_ADDITIVE_OPERATORS) + aroundInside(TokenSet.create(MUL, DIV, PERC), BINARY_EXPRESSION).spaceIf(kotlinCommonSettings.SPACE_AROUND_MULTIPLICATIVE_OPERATORS) + around(TokenSet.create(PLUSPLUS, MINUSMINUS, EXCLEXCL, MINUS, PLUS, EXCL)).spaceIf(kotlinCommonSettings.SPACE_AROUND_UNARY_OPERATOR) around(ELVIS).spaces(1) - around(RANGE).spaceIf(jetSettings.SPACE_AROUND_RANGE) + around(RANGE).spaceIf(kotlinSettings.SPACE_AROUND_RANGE) after(MODIFIER_LIST).spaces(1) @@ -207,17 +207,17 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { betweenInside(LOOP_RANGE, RPAR, FOR).spaces(0) val TYPE_COLON_ELEMENTS = TokenSet.create(PROPERTY, FUN, VALUE_PARAMETER, DESTRUCTURING_DECLARATION_ENTRY, FUNCTION_LITERAL) - beforeInside(COLON, TYPE_COLON_ELEMENTS) { spaceIf(jetSettings.SPACE_BEFORE_TYPE_COLON) } - afterInside(COLON, TYPE_COLON_ELEMENTS) { spaceIf(jetSettings.SPACE_AFTER_TYPE_COLON) } + beforeInside(COLON, TYPE_COLON_ELEMENTS) { spaceIf(kotlinSettings.SPACE_BEFORE_TYPE_COLON) } + afterInside(COLON, TYPE_COLON_ELEMENTS) { spaceIf(kotlinSettings.SPACE_AFTER_TYPE_COLON) } val EXTEND_COLON_ELEMENTS = TokenSet.create(TYPE_CONSTRAINT, CLASS, OBJECT_DECLARATION, TYPE_PARAMETER, ENUM_ENTRY, SECONDARY_CONSTRUCTOR) - beforeInside(COLON, EXTEND_COLON_ELEMENTS) { spaceIf(jetSettings.SPACE_BEFORE_EXTEND_COLON) } - afterInside(COLON, EXTEND_COLON_ELEMENTS) { spaceIf(jetSettings.SPACE_AFTER_EXTEND_COLON) } + beforeInside(COLON, EXTEND_COLON_ELEMENTS) { spaceIf(kotlinSettings.SPACE_BEFORE_EXTEND_COLON) } + afterInside(COLON, EXTEND_COLON_ELEMENTS) { spaceIf(kotlinSettings.SPACE_AFTER_EXTEND_COLON) } - beforeInside(ARROW, FUNCTION_LITERAL).spaceIf(jetSettings.SPACE_BEFORE_LAMBDA_ARROW) + beforeInside(ARROW, FUNCTION_LITERAL).spaceIf(kotlinSettings.SPACE_BEFORE_LAMBDA_ARROW) - aroundInside(ARROW, FUNCTION_TYPE).spaceIf(jetSettings.SPACE_AROUND_FUNCTION_TYPE_ARROW) + aroundInside(ARROW, FUNCTION_TYPE).spaceIf(kotlinSettings.SPACE_AROUND_FUNCTION_TYPE_ARROW) between(VALUE_ARGUMENT_LIST, LAMBDA_ARGUMENT).spaces(1) betweenInside(REFERENCE_EXPRESSION, LAMBDA_ARGUMENT, CALL_EXPRESSION).spaces(1) @@ -254,14 +254,14 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { } } - ruleForKeywordOnNewLine(jetCommonSettings.ELSE_ON_NEW_LINE, keyword = ELSE_KEYWORD, parent = IF) { keywordParent, block -> + ruleForKeywordOnNewLine(kotlinCommonSettings.ELSE_ON_NEW_LINE, keyword = ELSE_KEYWORD, parent = IF) { keywordParent, block -> block.treeParent?.elementType == THEN && block.treeParent?.treeParent == keywordParent } - ruleForKeywordOnNewLine(jetCommonSettings.WHILE_ON_NEW_LINE, keyword = WHILE_KEYWORD, parent = DO_WHILE) { keywordParent, block -> + ruleForKeywordOnNewLine(kotlinCommonSettings.WHILE_ON_NEW_LINE, keyword = WHILE_KEYWORD, parent = DO_WHILE) { keywordParent, block -> block.treeParent?.elementType == BODY && block.treeParent?.treeParent == keywordParent } - ruleForKeywordOnNewLine(jetCommonSettings.CATCH_ON_NEW_LINE, keyword = CATCH, parent = TRY) - ruleForKeywordOnNewLine(jetCommonSettings.FINALLY_ON_NEW_LINE, keyword = FINALLY, parent = TRY) + ruleForKeywordOnNewLine(kotlinCommonSettings.CATCH_ON_NEW_LINE, keyword = CATCH, parent = TRY) + ruleForKeywordOnNewLine(kotlinCommonSettings.FINALLY_ON_NEW_LINE, keyword = FINALLY, parent = TRY) fun spacingForLeftBrace(block: ASTNode?, blockType: IElementType = BLOCK): Spacing? { @@ -270,8 +270,8 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { if (leftBrace != null) { val previousLeaf = FormatterUtil.getPreviousNonWhitespaceLeaf(leftBrace) val isAfterEolComment = previousLeaf != null && (previousLeaf.elementType == EOL_COMMENT) - val keepLineBreaks = jetSettings.LBRACE_ON_NEXT_LINE || isAfterEolComment - val minimumLF = if (jetSettings.LBRACE_ON_NEXT_LINE) 1 else 0 + val keepLineBreaks = kotlinSettings.LBRACE_ON_NEXT_LINE || isAfterEolComment + val minimumLF = if (kotlinSettings.LBRACE_ON_NEXT_LINE) 1 else 0 return Spacing.createSpacing(1, 1, minimumLF, keepLineBreaks, 0) } } @@ -312,7 +312,7 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { spacingForLeftBrace(block = parent.node, blockType = WHEN) } - val spacesInSimpleFunction = if (jetSettings.INSERT_WHITESPACES_IN_SIMPLE_ONE_LINE_METHOD) 1 else 0 + val spacesInSimpleFunction = if (kotlinSettings.INSERT_WHITESPACES_IN_SIMPLE_ONE_LINE_METHOD) 1 else 0 inPosition(parent = FUNCTION_LITERAL, left = LBRACE, right = BLOCK) @@ -360,7 +360,7 @@ fun createSpacingBuilder(settings: CodeStyleSettings): KotlinSpacingBuilder { between(RPAR, BODY).spaces(1) // if when entry has block, spacing after arrow should be set by lbrace rule - aroundInside(ARROW, WHEN_ENTRY).spaceIf(jetSettings.SPACE_AROUND_WHEN_ARROW) + aroundInside(ARROW, WHEN_ENTRY).spaceIf(kotlinSettings.SPACE_AROUND_WHEN_ARROW) after(EOL_COMMENT).lineBreakInCode() }