diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java index 7f2ce845a476..0d8d399dec52 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightUtil.java @@ -28,6 +28,7 @@ import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; +import com.intellij.psi.impl.PsiImplUtil; import com.intellij.psi.impl.source.resolve.JavaResolveUtil; import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession; import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil; @@ -509,6 +510,15 @@ public class HighlightUtil extends HighlightUtilBase { return highlightInfo; } + @Nullable + static HighlightInfo checkReturnOutsideOfSwitchExpr(@NotNull PsiStatement statement) { + if (PsiImplUtil.findEnclosingSwitchOrLoop(statement) instanceof PsiSwitchExpression) { + String message = JavaErrorMessages.message("return.outside.switch.expr"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); + } + + return null; + } @Nullable static HighlightInfo checkReturnStatementType(@NotNull PsiReturnStatement statement) { @@ -760,37 +770,66 @@ public class HighlightUtil extends HighlightUtilBase { } @Nullable - static HighlightInfo checkBreakOutsideLoop(@NotNull PsiBreakStatement statement) { - if (statement.getLabelIdentifier() == null) { - if (new PsiMatcherImpl(statement).ancestor(EnclosingLoopOrSwitchMatcherExpression.INSTANCE).getElement() == null) { - String description = JavaErrorMessages.message("break.outside.switch.or.loop"); - return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(description).create(); - } - } - else { - // todo labeled + static HighlightInfo checkBreakOutsideSwitchOrLoop(@NotNull PsiBreakStatement statement) { + PsiElement enclosing = PsiImplUtil.findEnclosingSwitchOrLoop(statement); + if (enclosing == null) { + String message = JavaErrorMessages.message("break.outside.switch.or.loop"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); } + return null; } + @Nullable + static HighlightInfo checkValueBreakExpression(@NotNull PsiBreakStatement statement, @Nullable PsiExpression expression) { + PsiElement enclosing = PsiImplUtil.findEnclosingSwitchOrLoop(statement); + if (enclosing instanceof PsiSwitchExpression) { + if (expression == null) { + String message = JavaErrorMessages.message("value.break.missing"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); + } + if (PsiTreeUtil.isAncestor(statement.findExitedElement(), enclosing, true)) { + String message = JavaErrorMessages.message("break.outside.switch.expr"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); + } + } + else if (expression != null && (!PsiImplUtil.isPlainReference(expression) || ((PsiReferenceExpression)expression).resolve() instanceof PsiVariable)) { + String message = JavaErrorMessages.message("value.break.unexpected"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); + } + + return null; + } @Nullable static HighlightInfo checkContinueOutsideLoop(@NotNull PsiContinueStatement statement) { - if (statement.getLabelIdentifier() == null) { - if (new PsiMatcherImpl(statement).ancestor(EnclosingLoopMatcherExpression.INSTANCE).getElement() == null) { - String description = JavaErrorMessages.message("continue.outside.loop"); - return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(description).create(); - } + if (PsiImplUtil.findEnclosingLoop(statement) == null) { + String message = JavaErrorMessages.message("continue.outside.loop"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); } - else { - PsiStatement exitedStatement = statement.findContinuedStatement(); - if (exitedStatement == null) return null; - if (!(exitedStatement instanceof PsiForStatement) && !(exitedStatement instanceof PsiWhileStatement) && - !(exitedStatement instanceof PsiDoWhileStatement) && !(exitedStatement instanceof PsiForeachStatement)) { - String description = JavaErrorMessages.message("not.loop.label", statement.getLabelIdentifier().getText()); - return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(description).create(); + + return null; + } + + @Nullable + static HighlightInfo checkContinueTarget(@NotNull PsiContinueStatement statement, @NotNull PsiIdentifier label, @NotNull LanguageLevel level) { + PsiStatement continuedStatement = statement.findContinuedStatement(); + if (continuedStatement == null) { + String message = JavaErrorMessages.message("unresolved.label", label.getText()); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(label).descriptionAndTooltip(message).create(); + } + if (!(continuedStatement instanceof PsiLoopStatement)) { + String message = JavaErrorMessages.message("not.loop.label", label.getText()); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); + } + if (level.isAtLeast(LanguageLevel.JDK_12_PREVIEW)) { + PsiElement enclosing = PsiImplUtil.findEnclosingSwitchOrLoop(statement); + if (enclosing instanceof PsiSwitchExpression && PsiTreeUtil.isAncestor(continuedStatement, enclosing, true)) { + String message = JavaErrorMessages.message("continue.outside.switch.expr"); + return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(statement).descriptionAndTooltip(message).create(); } } + return null; } @@ -1812,8 +1851,7 @@ public class HighlightUtil extends HighlightUtilBase { if (resolved == null || resolved instanceof PsiVariable) return null; PsiElement parent = expression.getParent(); - // String.class or String() are both correct - if (parent instanceof PsiReferenceExpression || parent instanceof PsiMethodCallExpression) return null; + if (parent instanceof PsiReferenceExpression || parent instanceof PsiMethodCallExpression || parent instanceof PsiBreakStatement) return null; String description = JavaErrorMessages.message("expression.expected"); HighlightInfo info = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(expression).descriptionAndTooltip(description).create(); @@ -2705,20 +2743,6 @@ public class HighlightUtil extends HighlightUtilBase { return checkMustBeThrowable(type, context, false); } - - @Nullable - static HighlightInfo checkLabelDefined(@Nullable PsiIdentifier labelIdentifier, @Nullable PsiStatement exitedStatement) { - if (labelIdentifier == null) return null; - String label = labelIdentifier.getText(); - if (label == null) return null; - if (exitedStatement == null) { - String message = JavaErrorMessages.message("unresolved.label", label); - return HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR).range(labelIdentifier).descriptionAndTooltip(message).create(); - } - return null; - } - - @Nullable static HighlightInfo checkReference(@NotNull PsiJavaCodeReferenceElement ref, @NotNull JavaResolveResult result, @@ -2761,6 +2785,9 @@ public class HighlightUtil extends HighlightUtilBase { String t2 = format(ObjectUtils.notNull(results[1].getElement())); description = JavaErrorMessages.message("ambiguous.reference", refName.getText(), t1, t2); } + else if (refParent instanceof PsiBreakStatement && !(PsiImplUtil.findEnclosingSwitchOrLoop(refParent) instanceof PsiSwitchExpression)) { + description = JavaErrorMessages.message("unresolved.label", refName.getText()); + } else { description = JavaErrorMessages.message("cannot.resolve.symbol", refName.getText()); } @@ -2838,6 +2865,7 @@ public class HighlightUtil extends HighlightUtilBase { if (element instanceof PsiClass) return formatClass((PsiClass)element); if (element instanceof PsiMethod) return JavaHighlightUtil.formatMethod((PsiMethod)element); if (element instanceof PsiField) return formatField((PsiField)element); + if (element instanceof PsiLabeledStatement) return ((PsiLabeledStatement)element).getName() + ':'; return ElementDescriptionUtil.getElementDescription(element, HighlightUsagesDescriptionLocation.INSTANCE); } diff --git a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java index d9a5697c093f..3104de13eac6 100644 --- a/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java +++ b/java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightVisitorImpl.java @@ -24,6 +24,7 @@ import com.intellij.openapi.util.TextRange; import com.intellij.pom.java.LanguageLevel; import com.intellij.psi.*; import com.intellij.psi.controlFlow.ControlFlowUtil; +import com.intellij.psi.impl.PsiImplUtil; import com.intellij.psi.impl.source.javadoc.PsiDocMethodOrFieldRef; import com.intellij.psi.impl.source.resolve.JavaResolveUtil; import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil; @@ -398,8 +399,13 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh @Override public void visitBreakStatement(PsiBreakStatement statement) { super.visitBreakStatement(statement); - if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkLabelDefined(statement.getLabelIdentifier(), statement.findExitedStatement())); - if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkBreakOutsideLoop(statement)); + PsiExpression expression = statement.getExpression(); + if (!myHolder.hasErrorResults() && expression == null) { + myHolder.add(HighlightUtil.checkBreakOutsideSwitchOrLoop(statement)); + } + if (!myHolder.hasErrorResults() && myLanguageLevel.isAtLeast(LanguageLevel.JDK_12_PREVIEW)) { + myHolder.add(HighlightUtil.checkValueBreakExpression(statement, expression)); + } } @Override @@ -443,9 +449,10 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh public void visitContinueStatement(PsiContinueStatement statement) { super.visitContinueStatement(statement); if (!myHolder.hasErrorResults()) { - myHolder.add(HighlightUtil.checkLabelDefined(statement.getLabelIdentifier(), statement.findContinuedStatement())); + PsiIdentifier label = statement.getLabelIdentifier(); + myHolder.add(label == null ? HighlightUtil.checkContinueOutsideLoop(statement) + : HighlightUtil.checkContinueTarget(statement, label, myLanguageLevel)); } - if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkContinueOutsideLoop(statement)); } @Override @@ -519,21 +526,21 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh @Override public void visitExpression(PsiExpression expression) { ProgressManager.checkCanceled(); // visitLiteralExpression is invoked very often in array initializers - super.visitExpression(expression); - PsiType type = expression.getType(); - if (myHolder.add(HighlightUtil.checkMustBeBoolean(expression, type))) return; - - if (expression instanceof PsiArrayAccessExpression) { - myHolder.add(HighlightUtil.checkValidArrayAccessExpression((PsiArrayAccessExpression)expression)); - } PsiElement parent = expression.getParent(); - if (parent instanceof PsiNewExpression - && ((PsiNewExpression)parent).getQualifier() != expression - && ((PsiNewExpression)parent).getArrayInitializer() != expression) { - // like in 'new String["s"]' - myHolder.add(HighlightUtil.checkAssignability(PsiType.INT, expression.getType(), expression, expression)); + PsiType type = expression.getType(); + + if (!myHolder.hasErrorResults() && parent instanceof PsiBreakStatement && !PsiImplUtil.isPlainReference(expression)) { + myHolder.add(checkFeature(expression, Feature.SWITCH_EXPRESSION)); + } + if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkMustBeBoolean(expression, type)); + if (!myHolder.hasErrorResults() && expression instanceof PsiArrayAccessExpression) { + myHolder.add(HighlightUtil.checkValidArrayAccessExpression((PsiArrayAccessExpression)expression)); + } + if (!myHolder.hasErrorResults() && parent instanceof PsiNewExpression && + ((PsiNewExpression)parent).getQualifier() != expression && ((PsiNewExpression)parent).getArrayInitializer() != expression) { + myHolder.add(HighlightUtil.checkAssignability(PsiType.INT, expression.getType(), expression, expression)); // like in 'new String["s"]' } if (!myHolder.hasErrorResults()) myHolder.add(HighlightControlFlowUtil.checkCannotWriteToFinal(expression,myFile)); if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkVariableExpected(expression)); @@ -542,15 +549,10 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkAssertOperatorTypes(expression, type)); if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkSynchronizedExpressionType(expression, type, myFile)); if (!myHolder.hasErrorResults()) myHolder.add(HighlightUtil.checkConditionalExpressionBranchTypesMatch(expression, type)); - if (!myHolder.hasErrorResults() - && parent instanceof PsiThrowStatement - && ((PsiThrowStatement)parent).getException() == expression && type != null) { + if (!myHolder.hasErrorResults() && parent instanceof PsiThrowStatement && ((PsiThrowStatement)parent).getException() == expression && type != null) { myHolder.add(HighlightUtil.checkMustBeThrowable(type, expression, true)); } - - if (!myHolder.hasErrorResults()) { - myHolder.add(AnnotationsHighlightUtil.checkConstantExpression(expression)); - } + if (!myHolder.hasErrorResults()) myHolder.add(AnnotationsHighlightUtil.checkConstantExpression(expression)); if (!myHolder.hasErrorResults() && parent instanceof PsiForeachStatement && ((PsiForeachStatement)parent).getIteratedValue() == expression) { myHolder.add(GenericsHighlightUtil.checkForeachExpressionTypeIsIterable(expression)); } @@ -1558,10 +1560,16 @@ public class HighlightVisitorImpl extends JavaElementVisitor implements Highligh @Override public void visitReturnStatement(PsiReturnStatement statement) { - try { - myHolder.add(HighlightUtil.checkReturnStatementType(statement)); + super.visitStatement(statement); + if (!myHolder.hasErrorResults() && myLanguageLevel.isAtLeast(LanguageLevel.JDK_12_PREVIEW)) { + myHolder.add(HighlightUtil.checkReturnOutsideOfSwitchExpr(statement)); + } + if (!myHolder.hasErrorResults()) { + try { + myHolder.add(HighlightUtil.checkReturnStatementType(statement)); + } + catch (IndexNotReadyException ignore) { } } - catch (IndexNotReadyException ignore) { } } @Override diff --git a/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopMatcherExpression.java b/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopMatcherExpression.java deleted file mode 100644 index 189d3bd02a8c..000000000000 --- a/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopMatcherExpression.java +++ /dev/null @@ -1,21 +0,0 @@ -// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -package com.intellij.psi.util; - -import com.intellij.psi.*; - -/** - * @author max - */ -public class EnclosingLoopMatcherExpression implements PsiMatcherExpression { - public static final PsiMatcherExpression INSTANCE = new EnclosingLoopMatcherExpression(); - - @Override - public Boolean match(PsiElement element) { - if (element instanceof PsiForStatement) return Boolean.TRUE; - if (element instanceof PsiForeachStatement) return Boolean.TRUE; - if (element instanceof PsiWhileStatement) return Boolean.TRUE; - if (element instanceof PsiDoWhileStatement) return Boolean.TRUE; - if (element instanceof PsiMethod || element instanceof PsiClassInitializer || element instanceof PsiLambdaExpression) return null; - return Boolean.FALSE; - } -} \ No newline at end of file diff --git a/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopOrSwitchMatcherExpression.java b/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopOrSwitchMatcherExpression.java deleted file mode 100644 index e6ad03660dc9..000000000000 --- a/java/java-analysis-impl/src/com/intellij/psi/util/EnclosingLoopOrSwitchMatcherExpression.java +++ /dev/null @@ -1,17 +0,0 @@ -// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -package com.intellij.psi.util; - -import com.intellij.psi.*; - -/** - * @author max - */ -public class EnclosingLoopOrSwitchMatcherExpression extends EnclosingLoopMatcherExpression { - public static final PsiMatcherExpression INSTANCE = new EnclosingLoopOrSwitchMatcherExpression(); - - @Override - public Boolean match(PsiElement element) { - if (element instanceof PsiSwitchBlock) return Boolean.TRUE; - return super.match(element); - } -} \ No newline at end of file diff --git a/java/java-psi-impl/src/messages/JavaErrorMessages.properties b/java/java-psi-impl/src/messages/JavaErrorMessages.properties index cc985b3b872a..b818ad6c3aea 100644 --- a/java/java-psi-impl/src/messages/JavaErrorMessages.properties +++ b/java/java-psi-impl/src/messages/JavaErrorMessages.properties @@ -223,6 +223,7 @@ unary.operator.not.applicable=Operator ''{0}'' cannot be applied to ''{1}'' return.outside.method=Return outside method return.from.void.method=Cannot return a value from a method with void result type missing.return.value=Missing return value +return.outside.switch.expr=Return outside of enclosing switch expression #{0} - exceptions list (comma separated), {1} - exceptions count in the list, {2} - exception source unhandled.exceptions=Unhandled {1, choice, 0#exception|2#exceptions}: {0} @@ -230,7 +231,11 @@ unhandled.close.exceptions=Unhandled {1, choice, 0#exception|2#exceptions} from variable.already.defined=Variable ''{0}'' is already defined in the scope break.outside.switch.or.loop=Break outside switch or loop +value.break.unexpected=Value break outside switch expression +value.break.missing=Missing break value +break.outside.switch.expr=Break outside of enclosing switch expression continue.outside.loop=Continue outside of loop +continue.outside.switch.expr=Continue outside of enclosing switch expression not.loop.label=Not a loop label: ''{0}'' incompatible.modifiers=Illegal combination of modifiers: ''{0}'' and ''{1}'' modifier.not.allowed=Modifier ''{0}'' not allowed here diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/EnhancedSwitchUnreachable.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/EnhancedSwitchUnreachable.java index 8702dc655179..034238b8db3f 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/EnhancedSwitchUnreachable.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/EnhancedSwitchUnreachable.java @@ -101,8 +101,8 @@ class C { int n; return 2; n = switch(s) { - case "a": n= 1;break; - default: n= 0; + case "a": n = 1; break 1; + default: n = 0; break 0; }; } diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/SwitchExpressions.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/SwitchExpressions.java index c77e80f9436b..c448cad483fb 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/SwitchExpressions.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/SwitchExpressions.java @@ -12,7 +12,7 @@ class SwitchExpressions { System.out.println(switch (new Random().nextInt()) { case 0 -> throw new IllegalStateException("no args"); - case 1: break; + case 1: break "lone"; }); System.out.println( @@ -44,5 +44,18 @@ class SwitchExpressions { case E1 -> 1; case E2 -> 2; }); + + lab: while (true) { + switch (new Random().nextInt()) { + case -1: return; + case -2: continue lab; + default: break lab; + } + System.out.println(switch (new Random().nextInt()) { + case -1: return; + case -2: continue lab; + default: break lab; + }); + } } } \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/ValueBreaks.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/ValueBreaks.java new file mode 100644 index 000000000000..9ceec4f5f5e5 --- /dev/null +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting12/ValueBreaks.java @@ -0,0 +1,39 @@ +class ValueBreaks { + static final int ref = -1; + + void m() { + l1: break l1; + + break; + break wtf; + break 42; + + switch (0) { + case 0: break 42; + case 1: break ref; + case 2: break wtf; + case 3: ref: break ref; + }; + + sink(switch (0) { + case 0 -> { while (true) break 42; } + case 1 -> { while (true) break ref; } + case 2 -> { while (true) break wtf; } + case 3 -> { break ref; } + case 4 -> { break wtf; } + default -> throw new RuntimeException(); + }); + + ref: sink(switch (0) { + default: break ref; + }); + + while (true) { + sink(switch (0) { + default: break; + }); + } + } + + private static void sink(Object o) { } +} \ No newline at end of file diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/UnsupportedFeatures.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/UnsupportedFeatures.java index 8a9106d62f25..0eff76328b75 100644 --- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/UnsupportedFeatures.java +++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/advHighlighting6/UnsupportedFeatures.java @@ -35,6 +35,10 @@ class UnsupportedFeatures { System.out.println(switch (list.size()) { default -> "whoa!"; }); + switch (list.size()) { + case 0: break null; + case 1: break boo; + } } void f(Object this) { } diff --git a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava12HighlightingTest.kt b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava12HighlightingTest.kt index b8c9daf35335..d2ac4d1b8c78 100644 --- a/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava12HighlightingTest.kt +++ b/java/java-tests/testSrc/com/intellij/java/codeInsight/daemon/LightJava12HighlightingTest.kt @@ -10,6 +10,7 @@ class LightJava12HighlightingTest : LightCodeInsightFixtureTestCase() { fun testEnhancedSwitchStatements() = doTest() fun testSwitchExpressions() = doTest() + fun testValueBreaks() = doTest() fun testSwitchNumericPromotion() = doTest() fun testSimpleInferenceCases() = doTest() fun testEnhancedSwitchDefinitelyAssigned() = doTest()