stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8297118: Change IncompatibleClassChangeError to MatchException for exhaustive switch statements and switch expressions

Browse Source 
Reviewed-by: vromero
This commit is contained in:
Jan Lahoda 2022-12-01 10:51:57 +00:00
parent cd776093c7
commit b60cce6f3b
4 changed files with 225 additions and 6 deletions
src/jdk.compiler/share/classes/com/sun/tools/javac/comp
Lower.java
test/langtools/tools/javac/patterns
EnumTypeChanges.javaEnumTypeChangesNonPreview.javaMatchExceptionTest.java

19
src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Lower.java

@ -54,6 +54,7 @@ import static com.sun.tools.javac.code.Flags.BLOCK;
import static com.sun.tools.javac.code.Scope.LookupKind.NON_RECURSIVE;
import static com.sun.tools.javac.code.TypeTag.*;
import static com.sun.tools.javac.code.Kinds.Kind.*;
import com.sun.tools.javac.code.Source.Feature;
import static com.sun.tools.javac.jvm.ByteCodes.*;
import com.sun.tools.javac.tree.JCTree.JCBreak;
import com.sun.tools.javac.tree.JCTree.JCCase;
@ -100,6 +101,7 @@ public class Lower extends TreeTranslator {
private final boolean disableProtectedAccessors; // experimental
private final PkgInfo pkginfoOpt;
private final boolean optimizeOuterThis;
private final boolean useMatchException;
protected Lower(Context context) {
context.put(lowerKey, this);
@ -126,6 +128,10 @@ public class Lower extends TreeTranslator {
target.optimizeOuterThis() ||
options.getBoolean("optimizeOuterThis", false);
disableProtectedAccessors = options.isSet("disableProtectedAccessors");
Source source = Source.instance(context);
Preview preview = Preview.instance(context);
useMatchException = Feature.PATTERN_SWITCH.allowedInSource(source) &&
(preview.isEnabled() || !preview.isPreview(Feature.PATTERN_SWITCH));
}
/** The currently enclosing class.
@ -3624,21 +3630,24 @@ public class Lower extends TreeTranslator {
}
public void visitSwitch(JCSwitch tree) {
boolean matchException = tree.patternSwitch && !tree.wasEnumSelector;
List<JCCase> cases = tree.patternSwitch ? addDefaultIfNeeded(matchException, tree.cases)
List<JCCase> cases = tree.patternSwitch ? addDefaultIfNeeded(tree.patternSwitch,
tree.wasEnumSelector,
tree.cases)
: tree.cases;
handleSwitch(tree, tree.selector, cases);
}
@Override
public void visitSwitchExpression(JCSwitchExpression tree) {
boolean matchException = tree.patternSwitch && !tree.wasEnumSelector;
List<JCCase> cases = addDefaultIfNeeded(matchException, tree.cases);
List<JCCase> cases = addDefaultIfNeeded(tree.patternSwitch, tree.wasEnumSelector, tree.cases);
handleSwitch(tree, tree.selector, cases);
}
private List<JCCase> addDefaultIfNeeded(boolean matchException, List<JCCase> cases) {
private List<JCCase> addDefaultIfNeeded(boolean patternSwitch, boolean wasEnumSelector,
List<JCCase> cases) {
if (cases.stream().flatMap(c -> c.labels.stream()).noneMatch(p -> p.hasTag(Tag.DEFAULTCASELABEL))) {
boolean matchException = useMatchException;
matchException |= patternSwitch && !wasEnumSelector;
Type exception = matchException ? syms.matchExceptionType
: syms.incompatibleClassChangeErrorType;
List<JCExpression> params = matchException ? List.of(makeNull(), makeNull())

2
test/langtools/tools/javac/patterns/EnumTypeChanges.java

@ -56,7 +56,7 @@ public class EnumTypeChanges {
try {
c.apply(EnumTypeChangesEnum.valueOf("C"));
throw new AssertionError();
} catch (IncompatibleClassChangeError e) {
} catch (MatchException e) {
//expected
}
}

66
test/langtools/tools/javac/patterns/EnumTypeChangesNonPreview.java Normal file

@ -0,0 +1,66 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8297118
* @summary Verify pattern switches work properly when the set of enum constant changes.
* @compile EnumTypeChangesNonPreview.java
* @compile EnumTypeChanges2.java
* @run main EnumTypeChangesNonPreview
* @run main/othervm --enable-preview EnumTypeChangesNonPreview
*/
import java.util.function.Function;
public class EnumTypeChangesNonPreview {
public static void main(String... args) throws Exception {
new EnumTypeChangesNonPreview().run();
}
void run() throws Exception {
doRunExhaustive(this::expressionEnumExhaustive);
}
void doRunExhaustive(Function<EnumTypeChangesEnum, String> c) throws Exception {
try {
c.apply(EnumTypeChangesEnum.valueOf("C"));
throw new AssertionError();
} catch (IncompatibleClassChangeError e) {
//expected
}
}
String expressionEnumExhaustive(EnumTypeChangesEnum e) {
return switch (e) {
case A -> "A";
case B -> "B";
};
}
}
enum EnumTypeChangesEnum {
A,
B;
}

144
test/langtools/tools/javac/patterns/MatchExceptionTest.java Normal file

@ -0,0 +1,144 @@
/*
* Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8297118
* @summary Verify javac uses MatchException or IncompatibleClassChangeError for exhaustive switches
* @library /tools/lib
* @modules jdk.compiler/com.sun.tools.javac.api
* jdk.compiler/com.sun.tools.javac.main
* jdk.jdeps/com.sun.tools.classfile
* @build toolbox.ToolBox toolbox.JavacTask
* @run main/othervm --enable-preview MatchExceptionTest
*/
import java.nio.file.Path;
import com.sun.tools.classfile.ClassFile;
import com.sun.tools.classfile.ConstantPool;
import com.sun.tools.classfile.ConstantPool.CONSTANT_Class_info;
import com.sun.tools.classfile.ConstantPool.CPInfo;
import java.util.Arrays;
import toolbox.JavacTask;
import toolbox.TestRunner;
import toolbox.ToolBox;
public class MatchExceptionTest extends TestRunner {
private static final String JAVA_VERSION = System.getProperty("java.specification.version");
private static final String TEST_METHOD = "test";
ToolBox tb;
ClassFile cf;
public MatchExceptionTest() {
super(System.err);
tb = new ToolBox();
}
public static void main(String[] args) throws Exception {
MatchExceptionTest t = new MatchExceptionTest();
t.runTests();
}
@Test
public void testNestedPatternVariablesBytecode() throws Exception {
String codeStatement = """
class Test {
void test(E e) {
switch (e) {
case null -> {}
case S -> {}
};
}
enum E { S; }
}""";
String codeExpression = """
class Test {
int test(E e) {
return switch (e) {
case S -> 0;
};
}
enum E { S; }
}""";
record Setup(boolean hasMatchException, String... options) {
public String toString() {
return "Setup[hasMatchException=" + hasMatchException +
", options=" + Arrays.toString(options) + "]";
}
}
Setup[] variants = new Setup[] {
new Setup(false, "-source", "20"),
new Setup(false, "-source", JAVA_VERSION),
new Setup(true, "-source", JAVA_VERSION, "--enable-preview"),
};
record Source(String source, boolean needsPreview) {}
Source[] sources = new Source[] {
new Source(codeStatement, true),
new Source(codeExpression, false),
};
Path curPath = Path.of(".");
for (Source source : sources) {
for (Setup variant : variants) {
if (source.needsPreview &&
!Arrays.asList(variant.options).contains("--enable-preview")) {
continue;
}
new JavacTask(tb)
.options(variant.options)
.sources(source.source)
.outdir(curPath)
.run();
cf = ClassFile.read(curPath.resolve("Test.class"));
boolean incompatibleClassChangeErrror = false;
boolean matchException = false;
for (CPInfo entry : cf.constant_pool.entries()) {
if (entry.getTag() == ConstantPool.CONSTANT_Class) {
CONSTANT_Class_info clazz = (CONSTANT_Class_info) entry;
incompatibleClassChangeErrror |=
"java/lang/IncompatibleClassChangeError".equals(clazz.getName());
matchException |= "java/lang/MatchException".equals(clazz.getName());
}
}
if (variant.hasMatchException) {
assertTrue("Expected MatchException (" + variant + ")", matchException);
assertTrue("Did not expect IncompatibleClassChangeError (" + variant + ")",
!incompatibleClassChangeErrror);
} else {
assertTrue("Did not expect MatchException (" + variant + ")", !matchException);
assertTrue("Expected IncompatibleClassChangeError (" + variant + ")",
incompatibleClassChangeErrror);
}
}
}
}
void assertTrue(String message, boolean b) {
if (!b) {
throw new AssertionError(message);
}
}
}