diff --git a/java/java-impl/src/com/intellij/codeInsight/intention/impl/SplitSwitchBranchWithSeveralCaseValuesAction.java b/java/java-impl/src/com/intellij/codeInsight/intention/impl/SplitSwitchBranchWithSeveralCaseValuesAction.java index ccf10e6475ce..444adceb0267 100644 --- a/java/java-impl/src/com/intellij/codeInsight/intention/impl/SplitSwitchBranchWithSeveralCaseValuesAction.java +++ b/java/java-impl/src/com/intellij/codeInsight/intention/impl/SplitSwitchBranchWithSeveralCaseValuesAction.java @@ -10,12 +10,14 @@ import com.intellij.psi.codeStyle.CodeStyleManager; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.ObjectUtils; -import com.siyeh.ig.psiutils.CommentTracker; import org.jetbrains.annotations.Contract; import org.jetbrains.annotations.Nls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import java.util.ArrayList; +import java.util.List; + import static com.intellij.psi.util.PsiTreeUtil.getNextSiblingOfType; import static com.intellij.psi.util.PsiTreeUtil.getPrevSiblingOfType; import static com.intellij.util.ObjectUtils.notNull; @@ -26,30 +28,39 @@ import static com.siyeh.ig.psiutils.ControlFlowUtils.statementMayCompleteNormall */ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBaseIntentionAction { + @Nls(capitalization = Nls.Capitalization.Sentence) + @NotNull + @Override + public String getFamilyName() { + return CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.family"); + } + @Override public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) { - PsiSwitchLabelStatementBase statement = findLabelStatement(editor, element); - // traditional syntax "case 1: case 2: some code" - if (statement instanceof PsiSwitchLabelStatement) { - if (getPrevSiblingOfType(statement, PsiStatement.class) instanceof PsiSwitchLabelStatement || - getNextSiblingOfType(statement, PsiStatement.class) instanceof PsiSwitchLabelStatement) { - - PsiStatement lastSiblingLabel = findLastSiblingLabel(statement); - PsiStatement lastStatement = findLastStatementInBranch(lastSiblingLabel); - if (lastStatement != null && (!statementMayCompleteNormally(lastStatement) || - getNextSiblingOfType(lastStatement, PsiSwitchLabelStatement.class) == null)) { - setText(CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.label.text")); + PsiSwitchLabelStatementBase labelStatement = findLabelStatement(editor, element); + if (labelStatement instanceof PsiSwitchLabelStatement) { + if (isMultiValueCase(labelStatement)) { + // mixed syntax "case 1, 2: some code" + if (isAvailableForLabel(labelStatement)) { + setText(CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.split.text")); + return true; + } + } + else if (hasSiblingLabel(labelStatement)) { + // traditional syntax "case 1: case 2: some code" + PsiSwitchLabelStatement lastSiblingLabel = findLastSiblingLabel(labelStatement, false); + if (isAvailableForLabel(lastSiblingLabel)) { + setText(CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.copy.text")); return true; } } } - // enhanced syntax "case 1, 2 -> some code" - else if (statement instanceof PsiSwitchLabeledRuleStatement) { - PsiExpressionList caseValues = statement.getCaseValues(); - if (caseValues != null && caseValues.getExpressionCount() > 1) { - PsiStatement body = ((PsiSwitchLabeledRuleStatement)statement).getBody(); + else if (labelStatement instanceof PsiSwitchLabeledRuleStatement) { + // enhanced syntax "case 1, 2 -> some code" + if (isMultiValueCase(labelStatement)) { + PsiStatement body = ((PsiSwitchLabeledRuleStatement)labelStatement).getBody(); if (body != null && element.getTextOffset() < body.getTextOffset()) { - setText(CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.rule.text")); + setText(CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.split.text")); return true; } } @@ -57,6 +68,22 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase return false; } + private static boolean isAvailableForLabel(@Nullable PsiSwitchLabelStatementBase label) { + PsiStatement lastStatement = findLastStatementInBranch(label); + return lastStatement != null && (!statementMayCompleteNormally(lastStatement) || + getNextSiblingOfType(lastStatement, PsiSwitchLabelStatement.class) == null); + } + + private static boolean isMultiValueCase(@NotNull PsiSwitchLabelStatementBase label) { + PsiExpressionList caseValues = label.getCaseValues(); + return caseValues != null && caseValues.getExpressionCount() > 1; + } + + private static boolean hasSiblingLabel(@Nullable PsiSwitchLabelStatementBase label) { + return getPrevSiblingOfType(label, PsiStatement.class) instanceof PsiSwitchLabelStatement || + getNextSiblingOfType(label, PsiStatement.class) instanceof PsiSwitchLabelStatement; + } + /** * Handle the case where the caret is at the right side of the element we're interested in */ @@ -78,14 +105,29 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase PsiElement result = null; if (statement instanceof PsiSwitchLabelStatement) { PsiSwitchLabelStatement labelStatement = (PsiSwitchLabelStatement)statement; - PsiSwitchLabelStatement lastSibling = getLastSiblingLabel(labelStatement); - if (lastSibling != null) { - result = moveAfter(labelStatement, lastSibling); + PsiExpressionList caseValues = labelStatement.getCaseValues(); + if (caseValues != null && caseValues.getExpressionCount() > 1) { + PsiExpression caseValue = findCaseValue(element, caseValues, editor); + Branch branch = Branch.fromLabel(labelStatement); + if (branch != null) { + if (isInList(caseValue, caseValues)) { + result = moveLabelValueAfter(labelStatement, caseValue); + } + else { + result = splitLabelValues(labelStatement); + } + } } else { - PsiStatement previousSibling = getPrevSiblingOfType(statement, PsiStatement.class); - if (previousSibling instanceof PsiSwitchLabelStatement) { - result = copyTo(labelStatement, (PsiSwitchLabelStatement)previousSibling); + PsiSwitchLabelStatement lastSiblingLabel = findLastSiblingLabel(labelStatement, true); + if (lastSiblingLabel != null) { + result = moveLabelAfter(labelStatement, lastSiblingLabel); + } + else { + PsiStatement previousSibling = getPrevSiblingOfType(statement, PsiStatement.class); + if (previousSibling instanceof PsiSwitchLabelStatement) { + result = copyLabelTo(labelStatement, (PsiSwitchLabelStatement)previousSibling); + } } } } @@ -93,17 +135,12 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase PsiSwitchLabeledRuleStatement labeledRule = (PsiSwitchLabeledRuleStatement)statement; PsiExpressionList caseValues = labeledRule.getCaseValues(); if (caseValues != null) { - PsiExpression caseValue = PsiTreeUtil.getNonStrictParentOfType(element, PsiExpression.class); - if (!isInList(caseValue, caseValues)) { - PsiElement previousElement = getPreviousElement(editor, element); - caseValue = PsiTreeUtil.getNonStrictParentOfType(previousElement, PsiExpression.class); - } - + PsiExpression caseValue = findCaseValue(element, caseValues, editor); if (isInList(caseValue, caseValues)) { - result = moveAfter(caseValue, labeledRule); + result = moveRuleAfter(caseValue, labeledRule); } else { - result = splitAll(caseValues, labeledRule); + result = splitRule(caseValues, labeledRule); } } } @@ -112,6 +149,18 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase } } + private static PsiExpression findCaseValue(@NotNull PsiElement element, @NotNull PsiExpressionList caseValues, @NotNull Editor editor) { + PsiExpression caseValue = PsiTreeUtil.getNonStrictParentOfType(element, PsiExpression.class); + if (!isInList(caseValue, caseValues)) { + PsiElement previousElement = getPreviousElement(editor, element); + caseValue = PsiTreeUtil.getNonStrictParentOfType(previousElement, PsiExpression.class); + } + while (caseValue != null && caseValue.getParent() instanceof PsiExpression) { + caseValue = (PsiExpression)caseValue.getParent(); + } + return caseValue; + } + @Contract("null,_ -> false") private static boolean isInList(@Nullable PsiExpression caseValue, @NotNull PsiExpressionList caseValues) { return caseValue != null && PsiTreeUtil.isAncestor(caseValues, caseValue, true); @@ -130,25 +179,7 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase return ObjectUtils.tryCast(statement, PsiSwitchLabelStatementBase.class); } - @Nls(capitalization = Nls.Capitalization.Sentence) - @NotNull - @Override - public String getFamilyName() { - return CodeInsightBundle.message("intention.split.switch.branch.with.several.case.values.family"); - } - - @Nullable - private static PsiSwitchLabelStatement getLastSiblingLabel(@NotNull PsiSwitchLabelStatement original) { - PsiSwitchLabelStatement result = null; - for (PsiStatement next = getNextSiblingOfType(original, PsiStatement.class); - next instanceof PsiSwitchLabelStatement; - next = getNextSiblingOfType(next, PsiStatement.class)) { - result = (PsiSwitchLabelStatement)next; - } - return result; - } - - private static PsiElement moveAfter(@NotNull PsiSwitchLabelStatement labelToMove, @NotNull PsiSwitchLabelStatement anchor) { + private static PsiElement moveLabelAfter(@NotNull PsiSwitchLabelStatement labelToMove, @NotNull PsiSwitchLabelStatement anchor) { Branch branch = Branch.fromLabel(anchor); if (branch == null) { return null; @@ -156,43 +187,74 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase return branch.moveAfter(labelToMove); } - private static PsiElement copyTo(@NotNull PsiSwitchLabelStatement labelToCopyFrom, @NotNull PsiSwitchLabelStatement anchor) { + private static PsiElement copyLabelTo(@NotNull PsiSwitchLabelStatement labelToCopyFrom, @NotNull PsiSwitchLabelStatement anchor) { Branch branch = Branch.fromLabel(labelToCopyFrom); if (branch == null) return null; return branch.copyTo(anchor); } - private static PsiSwitchLabeledRuleStatement moveAfter(@NotNull PsiExpression caseValue, - @NotNull PsiSwitchLabeledRuleStatement labeledRule) { - CommentTracker tracker = new CommentTracker(); + @Nullable + private static PsiElement moveLabelValueAfter(@NotNull PsiSwitchLabelStatement labelStatement, @NotNull PsiExpression caseValue) { + Branch branch = Branch.fromLabel(labelStatement); + if (branch == null) { + return null; + } + PsiSwitchLabelStatement newLabel = branch.addLabelAfter(caseValue); + caseValue.delete(); + return branch.copyTo(newLabel); + } + + @Nullable + private static PsiElement splitLabelValues(@NotNull PsiSwitchLabelStatement labelStatement) { + Branch branch = Branch.fromLabel(labelStatement); + if (branch == null) { + return null; + } + + List newLabels = new ArrayList<>(); + PsiExpression[] expressions = notNull(labelStatement.getCaseValues()).getExpressions(); + for (int i = expressions.length - 1; i >= 1; i--) { + PsiExpression caseValue = expressions[i]; + PsiSwitchLabelStatement newLabel = branch.addLabelAfter(caseValue); + newLabels.add(newLabel); + caseValue.delete(); + } + + for (PsiSwitchLabelStatement newLabel : newLabels) { + branch.copyTo(newLabel); + } + return !newLabels.isEmpty() ? newLabels.get(0) : null; + } + + private static PsiSwitchLabeledRuleStatement moveRuleAfter(@NotNull PsiExpression caseValue, + @NotNull PsiSwitchLabeledRuleStatement labeledRule) { Project project = labeledRule.getProject(); PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); - PsiSwitchBlock tempSwitch = - (PsiSwitchBlock)factory.createStatementFromText("switch(1){case " + tracker.text(caseValue) + "->{}}", caseValue); - PsiCodeBlock tempBody = notNull(tempSwitch.getBody()); + PsiSwitchLabeledRuleStatement newRule = (PsiSwitchLabeledRuleStatement)factory.createStatementFromText("case 1->{}", null); - PsiSwitchLabeledRuleStatement newRule = (PsiSwitchLabeledRuleStatement)tempBody.getStatements()[0]; + notNull(newRule.getCaseValues()).getExpressions()[0].replace(caseValue); newRule = (PsiSwitchLabeledRuleStatement)labeledRule.getParent().addAfter(newRule, labeledRule); newRule = (PsiSwitchLabeledRuleStatement)CodeStyleManager.getInstance(project).reformat(newRule); notNull(newRule.getBody()).replace(notNull(labeledRule.getBody())); - tracker.deleteAndRestoreComments(caseValue); + caseValue.delete(); return newRule; } - private static PsiSwitchLabeledRuleStatement splitAll(@NotNull PsiExpressionList caseValues, - @NotNull PsiSwitchLabeledRuleStatement labeledRule) { + private static PsiSwitchLabeledRuleStatement splitRule(@NotNull PsiExpressionList caseValues, + @NotNull PsiSwitchLabeledRuleStatement labeledRule) { PsiExpression[] expressions = caseValues.getExpressions(); PsiSwitchLabeledRuleStatement anchor = labeledRule; for (int i = 1; i < expressions.length; i++) { - anchor = moveAfter(expressions[i], anchor); + anchor = moveRuleAfter(expressions[i], anchor); } return anchor; } + @Contract("null -> null") @Nullable static PsiStatement findLastStatementInBranch(@Nullable PsiElement label) { PsiStatement lastStatement = null; @@ -205,12 +267,13 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase } @Nullable - static PsiStatement findLastSiblingLabel(@Nullable PsiStatement statement) { - PsiStatement lastSiblingLabel = null; - for (PsiStatement next = statement; next instanceof PsiSwitchLabelStatement; next = getNextSiblingOfType(next, PsiStatement.class)) { - lastSiblingLabel = next; + private static PsiSwitchLabelStatement findLastSiblingLabel(@Nullable PsiStatement statement, boolean strict) { + PsiSwitchLabelStatement result = null; + PsiStatement start = strict ? getNextSiblingOfType(statement, PsiStatement.class) : statement; + for (PsiStatement next = start; next instanceof PsiSwitchLabelStatement; next = getNextSiblingOfType(next, PsiStatement.class)) { + result = (PsiSwitchLabelStatement)next; } - return lastSiblingLabel; + return result; } private static class Branch { @@ -289,13 +352,25 @@ public class SplitSwitchBranchWithSeveralCaseValuesAction extends PsiElementBase return labelCopy; } - PsiElement copyTo(@NotNull PsiSwitchLabelStatement anchor) { + PsiSwitchLabelStatement copyTo(@NotNull PsiSwitchLabelStatement anchor) { myCodeBlock.addRangeAfter(myFirstElement, myLastStatement, anchor); addBreakIfNeeded(anchor); return anchor; } + @NotNull + PsiSwitchLabelStatement addLabelAfter(@NotNull PsiExpression caseValue) { + Project project = myCodeBlock.getProject(); + PsiElementFactory factory = JavaPsiFacade.getElementFactory(project); + PsiSwitchLabelStatement newLabel = (PsiSwitchLabelStatement)factory.createStatementFromText("case 1:", null); + notNull(newLabel.getCaseValues()).getExpressions()[0].replace(caseValue); + + newLabel = (PsiSwitchLabelStatement)myCodeBlock.addAfter(newLabel, myLastStatement); + newLabel = (PsiSwitchLabelStatement)CodeStyleManager.getInstance(project).reformat(newLabel); + return newLabel; + } + private void addBreakIfNeeded(@Nullable PsiElement label) { PsiStatement lastStatementInBranch = findLastStatementInBranch(label); diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterFirstValueInRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterFirstValueInRule.java index c5abfdc2a50b..35aed90bc7ca 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterFirstValueInRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterFirstValueInRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterLastValueInRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterLastValueInRule.java index 3b880a2f6994..3223a79e1e55 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterLastValueInRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterLastValueInRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterManyValuesRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterManyValuesRule.java index df32cf6b4ebd..3bf551823d6e 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterManyValuesRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterManyValuesRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabel.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabel.java new file mode 100644 index 000000000000..6236a9e89670 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabel.java @@ -0,0 +1,18 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1: + System.out.println("hello"); + break; + case 2: + System.out.println("hello"); + break; + case 3: + System.out.println("hello"); + break; + case 4: + System.out.println("bye"); + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirst.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirst.java new file mode 100644 index 000000000000..1344d1948edc --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirst.java @@ -0,0 +1,13 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 2: + System.out.println("hello"); + break; + case 1: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirstWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirstWithComments.java new file mode 100644 index 000000000000..c4e94c97f06b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelFirstWithComments.java @@ -0,0 +1,17 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + // 1 + case /*2*/ /*3*/2: // 4 + // 5 + System.out.println("hello"); + break; + case 1: + // 5 + System.out.println("hello"); + break; + /*6*/ + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLast.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLast.java new file mode 100644 index 000000000000..afa9e0e9a86d --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLast.java @@ -0,0 +1,13 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1: + System.out.println("hello"); + break; + case 2: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLastWithExpression.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLastWithExpression.java new file mode 100644 index 000000000000..01102261c608 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelLastWithExpression.java @@ -0,0 +1,13 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1: + System.out.println("hello"); + break; + case 1 + 1: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelWithComments.java new file mode 100644 index 000000000000..72acba281c5b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterMultiValueLabelWithComments.java @@ -0,0 +1,23 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + // 1 + case /*2*/1 /*3*/ /*4*/: //5 + // 6 + System.out.println("hello"); + break; + case 2: + // 6 + System.out.println("hello"); + break; + case 3: + // 6 + System.out.println("hello"); + break; + // 7 + case 4: + System.out.println("bye"); + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRule.java index 3b880a2f6994..3223a79e1e55 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleInExpression.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleInExpression.java index 078f05c9f9a7..fc7313489699 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleInExpression.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleInExpression.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = switch (n) { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithComments.java index f5bae2c86318..827fffcdbc1b 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithComments.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithComments.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithExpressionFirst.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithExpressionFirst.java new file mode 100644 index 000000000000..b5695d00f549 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/afterRuleWithExpressionFirst.java @@ -0,0 +1,10 @@ +// "Split values of 'switch' branch" "true" +class C { + void foo(int n) { + String s = ""; + switch (n) { + case 3 -> s = "x"; + case 1 + 1 -> s = "x"; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeDefaultRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeDefaultRule.java index e8f1b53e7239..d1c8f669acb4 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeDefaultRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeDefaultRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "false" +// "Split values of 'switch' branch" "false" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeFirstValueInRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeFirstValueInRule.java index 9f2358b369b7..f070b1f26f5f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeFirstValueInRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeFirstValueInRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeLastValueInRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeLastValueInRule.java index fc231d506b44..9414d0326118 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeLastValueInRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeLastValueInRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeManyValuesRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeManyValuesRule.java index cefd06eaa12c..2a59663560da 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeManyValuesRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeManyValuesRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabel.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabel.java new file mode 100644 index 000000000000..5ba56c069a14 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabel.java @@ -0,0 +1,12 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1, 2, 3: + System.out.println("hello"); + break; + case 4: + System.out.println("bye"); + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirst.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirst.java new file mode 100644 index 000000000000..c65ad5a74bab --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirst.java @@ -0,0 +1,10 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1, 2: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirstWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirstWithComments.java new file mode 100644 index 000000000000..13606752f21b --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelFirstWithComments.java @@ -0,0 +1,13 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + // 1 + case /*2*/1, /*3*/2: // 4 + // 5 + System.out.println("hello"); + break; + /*6*/ + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLast.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLast.java new file mode 100644 index 000000000000..228427865352 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLast.java @@ -0,0 +1,10 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1, 2: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLastWithExpression.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLastWithExpression.java new file mode 100644 index 000000000000..8b65d2aeace0 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelLastWithExpression.java @@ -0,0 +1,10 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + case 1, 1+1: + System.out.println("hello"); + break; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelWithComments.java new file mode 100644 index 000000000000..12cb1c5c13bb --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeMultiValueLabelWithComments.java @@ -0,0 +1,15 @@ +// "Split values of 'switch' branch" "true" +class C { + void test(int i) { + switch (i) { + // 1 + case /*2*/1, /*3*/2, /*4*/3: //5 + // 6 + System.out.println("hello"); + break; + // 7 + case 4: + System.out.println("bye"); + } + } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRule.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRule.java index c556ecd6787d..7cb3772a21e3 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRule.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRule.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleInExpression.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleInExpression.java index ee2e50127002..2d907a7610f0 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleInExpression.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleInExpression.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = switch (n) { diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithComments.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithComments.java index f9ab7872faee..a73e25f3d9ef 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithComments.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithComments.java @@ -1,4 +1,4 @@ -// "Split values of 'switch' rule" "true" +// "Split values of 'switch' branch" "true" class C { void foo(int n) { String s = ""; diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithExpressionFirst.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithExpressionFirst.java new file mode 100644 index 000000000000..c2ce37507a8a --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues/beforeRuleWithExpressionFirst.java @@ -0,0 +1,9 @@ +// "Split values of 'switch' branch" "true" +class C { + void foo(int n) { + String s = ""; + switch (n) { + case 1 + 1, 3 -> s = "x"; + } + } +} \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/SplitSwitchBranchWithSeveralCaseValuesTest.java b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/SplitSwitchBranchWithSeveralCaseValuesTest.java index ca4fcfb48427..08761a3bd940 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/SplitSwitchBranchWithSeveralCaseValuesTest.java +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/intention/SplitSwitchBranchWithSeveralCaseValuesTest.java @@ -2,6 +2,10 @@ package com.intellij.java.codeInsight.intention; import com.intellij.codeInsight.daemon.quickFix.LightQuickFixParameterizedTestCase; +import com.intellij.testFramework.LightProjectDescriptor; +import org.jetbrains.annotations.NotNull; + +import static com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase.JAVA_12; public class SplitSwitchBranchWithSeveralCaseValuesTest extends LightQuickFixParameterizedTestCase { @@ -10,6 +14,12 @@ public class SplitSwitchBranchWithSeveralCaseValuesTest extends LightQuickFixPar return "/codeInsight/daemonCodeAnalyzer/quickFix/splitSwitchBranchWithSeveralCaseValues"; } + @NotNull + @Override + protected LightProjectDescriptor getProjectDescriptor() { + return JAVA_12; + } + @Override protected boolean shouldBeAvailableAfterExecution() { return false; diff --git a/platform/platform-resources-en/src/messages/CodeInsightBundle.properties b/platform/platform-resources-en/src/messages/CodeInsightBundle.properties index 75e2768aca01..cff6ec7132dc 100644 --- a/platform/platform-resources-en/src/messages/CodeInsightBundle.properties +++ b/platform/platform-resources-en/src/messages/CodeInsightBundle.properties @@ -242,8 +242,8 @@ intention.break.string.on.line.breaks.text=Break string on '\\n' intention.unwrap.else.branch=Unwrap 'else' branch intention.unwrap.else.branch.changes.semantics=Unwrap 'else' branch (changes semantics) intention.split.switch.branch.with.several.case.values.family=Split switch branch with several case values into individual 'switch' branches -intention.split.switch.branch.with.several.case.values.label.text=Copy 'switch' branch -intention.split.switch.branch.with.several.case.values.rule.text=Split values of 'switch' rule +intention.split.switch.branch.with.several.case.values.copy.text=Copy 'switch' branch +intention.split.switch.branch.with.several.case.values.split.text=Split values of 'switch' branch intention.create.test=Create Test intention.create.test.dialog.testing.library=Testing &library: