8269802: javac fails to compile nested pattern matching switches

lahodaj · lahodaj · commit 815e4af35d29 · 2021-07-07T06:24:58.000Z
8269808: javac generates class with invalid stack map

Reviewed-by: mcimadamore
diff --git a/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TransPatterns.java b/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/TransPatterns.java
@@ -386,6 +386,7 @@ private void handleSwitch(JCTree tree,
                     hasNullCase = true;
                 }
             }
+            selector = translate(selector);
             statements.append(make.at(tree.pos).VarDef(temp, !hasNullCase ? attr.makeNullCheck(selector)
                                                                           : selector));
             VarSymbol index = new VarSymbol(Flags.SYNTHETIC,
@@ -469,6 +470,8 @@ private void handleSwitch(JCTree tree,
                         currentValue = prevCurrentValue;
                         bindingContext.pop();
                     }
+                } else {
+                    c.stats = translate(c.stats);
                 }
                 if (enumSwitch) {
                     var labels = c.labels;
diff --git a/test/langtools/tools/javac/patterns/Switches.java b/test/langtools/tools/javac/patterns/Switches.java
@@ -22,12 +22,13 @@
  */
 
 import java.util.Objects;
+import java.util.function.BiFunction;
 import java.util.function.Consumer;
 import java.util.function.Function;
 
 /*
  * @test
- * @bug 8262891 8268333 8268896
+ * @bug 8262891 8268333 8268896 8269802 8269808
  * @summary Check behavior of pattern switches.
  * @compile --enable-preview -source ${jdk.version} Switches.java
  * @run main/othervm --enable-preview Switches
@@ -66,6 +67,11 @@ void run() {
         npeTest(this::npeTestExpression);
         exhaustiveStatementSane("");
         exhaustiveStatementSane(null);
+        switchNestingTest(this::switchNestingStatementStatement);
+        switchNestingTest(this::switchNestingStatementExpression);
+        switchNestingTest(this::switchNestingExpressionStatement);
+        switchNestingTest(this::switchNestingExpressionExpression);
+        switchNestingTest(this::switchNestingIfSwitch);
     }
 
     void run(Function<Object, Integer> mapper) {
@@ -119,6 +125,13 @@ void npeTest(Consumer<I> testCase) {
         }
     }
 
+    void switchNestingTest(BiFunction<Object, Object, String> testCase) {
+        assertEquals("string, string", testCase.apply("", ""));
+        assertEquals("string, other", testCase.apply("", 1));
+        assertEquals("other, string", testCase.apply(1, ""));
+        assertEquals("other, other", testCase.apply(1, 1));
+    }
+
     int typeTestPatternSwitchTest(Object o) {
         switch (o) {
             case String s: return Integer.parseInt(s.toString());
@@ -366,6 +379,113 @@ void exhaustiveStatementSane(Object o) {
         }
     }
 
+    String switchNestingStatementStatement(Object o1, Object o2) {
+        switch (o1) {
+            case String s1 -> {
+                switch (o2) {
+                    case String s2 -> {
+                        return "string, string";
+                    }
+                    default -> {
+                        return "string, other";
+                    }
+                }
+            }
+            default -> {
+                switch (o2) {
+                    case String s2 -> {
+                        return "other, string";
+                    }
+                    default -> {
+                        return "other, other";
+                    }
+                }
+            }
+        }
+    }
+
+    String switchNestingStatementExpression(Object o1, Object o2) {
+        switch (o1) {
+            case String s1 -> {
+                return switch (o2) {
+                    case String s2 -> "string, string";
+                    default -> "string, other";
+                };
+            }
+            default -> {
+                return switch (o2) {
+                    case String s2 -> "other, string";
+                    default -> "other, other";
+                };
+            }
+        }
+    }
+
+    String switchNestingExpressionStatement(Object o1, Object o2) {
+        return switch (o1) {
+            case String s1 -> {
+                switch (o2) {
+                    case String s2 -> {
+                        yield "string, string";
+                    }
+                    default -> {
+                        yield "string, other";
+                    }
+                }
+            }
+            default -> {
+                switch (o2) {
+                    case String s2 -> {
+                        yield "other, string";
+                    }
+                    default -> {
+                        yield "other, other";
+                    }
+                }
+            }
+        };
+    }
+
+    String switchNestingExpressionExpression(Object o1, Object o2) {
+        return switch (o1) {
+            case String s1 ->
+                switch (o2) {
+                    case String s2 -> "string, string";
+                    default -> "string, other";
+                };
+            default ->
+                switch (o2) {
+                    case String s2 -> "other, string";
+                    default -> "other, other";
+                };
+        };
+    }
+
+    String switchNestingIfSwitch(Object o1, Object o2) {
+        BiFunction<Object, Object, String> f = (n1, n2) -> {
+            if (o1 instanceof CharSequence cs) {
+                return switch (cs) {
+                    case String s1 ->
+                        switch (o2) {
+                            case String s2 -> "string, string";
+                            default -> "string, other";
+                        };
+                    default ->
+                        switch (o2) {
+                            case String s2 -> "other, string";
+                            default -> "other, other";
+                        };
+                };
+            } else {
+                return switch (o2) {
+                            case String s2 -> "other, string";
+                            default -> "other, other";
+                        };
+            }
+        };
+        return f.apply(o1, o2);
+    }
+
     //verify that for cases like:
     //case ConstantClassClash ->
     //ConstantClassClash is interpreted as a field, not as a class

Original file line number	Diff line number	Diff line change
`@@ -386,6 +386,7 @@ private void handleSwitch(JCTree tree,`
`386`	`386`	`hasNullCase = true;`
`387`	`387`	`}`
`388`	`388`	`}`
	`389`	`+ selector = translate(selector);`
`389`	`390`	`statements.append(make.at(tree.pos).VarDef(temp, !hasNullCase ? attr.makeNullCheck(selector)`
`390`	`391`	`: selector));`
`391`	`392`	`VarSymbol index = new VarSymbol(Flags.SYNTHETIC,`
`@@ -469,6 +470,8 @@ private void handleSwitch(JCTree tree,`
`469`	`470`	`currentValue = prevCurrentValue;`
`470`	`471`	`bindingContext.pop();`
`471`	`472`	`}`
	`473`	`+ } else {`
	`474`	`+ c.stats = translate(c.stats);`
`472`	`475`	`}`
`473`	`476`	`if (enumSwitch) {`
`474`	`477`	`var labels = c.labels;`