8314226: Series of colon-style fallthrough switch cases with guards c…

…ompiled incorrectly

Backport-of: 3b0a6d2a6842962218b8cebcd9c0672cb4ee6720

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

@@ -524,6 +524,8 @@ private void handleSwitch(JCTree tree,
             boolean previousCompletesNormally = false;
             boolean hasDefault = false;
 
+            patchCompletingNormallyCases(cases);
+
             for (var c : cases) {
                 List<JCCaseLabel> clearedPatterns = c.labels;
                 boolean hasJoinedNull =
@@ -541,7 +543,8 @@ private void handleSwitch(JCTree tree,
                     validCaseLabelList = clearedPatterns.head.hasTag(Tag.PATTERNCASELABEL);
                 }
 
-                if (validCaseLabelList && !previousCompletesNormally) {
+                if ((validCaseLabelList && !previousCompletesNormally) ||
+                        c.guard != null) {
                     List<JCPatternCaseLabel> labels = clearedPatterns.stream().map(cp -> (JCPatternCaseLabel)cp).collect(List.collector());
                     bindingContext = new BasicBindingContext();
                     VarSymbol prevCurrentValue = currentValue;
@@ -657,6 +660,53 @@ private void handleSwitch(JCTree tree,
             super.visitSwitchExpression((JCSwitchExpression) tree);
         }
     }
+
+    // Duplicates the block statement where needed.
+    // Processes cases in place, e.g.
+    // switch (obj) {
+    //     case Integer _ when ((Integer) obj) > 0:
+    //     case String _  when !((String) obj).isEmpty():
+    //         return 1;
+    //     ...
+    // }
+    // =>
+    // switch (typeSwitch(...)) {
+    //     case 0:
+    //         if (!((Integer)obj) > 0) { ... }
+    //         return 1;
+    //     case 1:
+    //         if (!((String)obj).isEmpty()) { ... }
+    //         return 1;
+    //     ...
+    // }
+    private static void patchCompletingNormallyCases(List<JCCase> cases) {
+        while (cases.nonEmpty()) {
+            var currentCase = cases.head;
+
+            if (currentCase.caseKind == CaseKind.STATEMENT &&
+                currentCase.completesNormally &&
+                cases.tail.nonEmpty() &&
+                cases.tail.head.guard != null) {
+                ListBuffer<JCStatement> newStatements = new ListBuffer<>();
+                List<JCCase> copyFrom = cases;
+
+                while (copyFrom.nonEmpty()) {
+                    newStatements.appendList(copyFrom.head.stats);
+
+                    if (!copyFrom.head.completesNormally) {
+                        break;
+                    }
+
+                    copyFrom = copyFrom.tail;
+                };
+
+                currentCase.stats = newStatements.toList();
+            }
+
+            cases = cases.tail;
+        }
+    }
+
     //where:
         private void fixupContinue(JCTree switchTree, JCCase c, VarSymbol indexVariable, int currentCaseIndex) {
             //inject 'index = currentCaseIndex + 1;` before continue which has the current switch as the target

test/langtools/tools/javac/patterns/T8314226.java

@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2023, 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 8314226
+ * @summary Series of colon-style fallthrough switch cases with guards compiled incorrectly
+ * @enablePreview
+ * @compile T8314226.java
+ * @run main T8314226
+ */
+
+public class T8314226 {
+    int multipleGuardedCases(Object obj) {
+        switch (obj) {
+            case Integer _ when ((Integer) obj) > 0:
+            case String _  when !((String) obj).isEmpty():
+                return 1;
+            default:
+                return -1;
+        }
+    }
+
+    int multipleGuardedCases2a(Object obj) {
+        switch (obj) {
+            case Integer _ when ((Integer) obj) > 0:
+            case Float _   when ((Float) obj) > 0.0f:
+            case String _  when !((String) obj).isEmpty():
+                return 1;
+            default:
+                return -1;
+        }
+    }
+
+    int multipleGuardedCases2b(Object obj) {
+        switch (obj) {
+            case Float _   when ((Float) obj) > 0.0f: // reversing the order
+            case Integer _ when ((Integer) obj) > 0:
+            case String _  when !((String) obj).isEmpty():
+                return 1;
+            default:
+                return -1;
+        }
+    }
+
+    int multipleGuardedCasesMultiplePatterns(Object obj) {
+        switch (obj) {
+            case String _          when !((String) obj).isEmpty():
+            case Integer _, Byte _ when ((Number) obj).intValue() > 0:
+                return 1;
+            default:
+                return -1;
+        }
+    }
+
+    int singleGuardedCase(Object obj) {
+        switch (obj) {
+            case String _ when !((String) obj).isEmpty():
+                return 1;
+            default:
+                return -1;
+        }
+    }
+
+    int multipleCasesWithReturn(Object obj) {
+        switch (obj) {
+            case Integer _ when ((Integer) obj) > 0:
+            case String _ when !((String) obj).isEmpty():
+                return 1;
+            case null:
+                return 2;
+            default:
+                return 3;
+        }
+    }
+
+    int multipleCasesWithEffectNoReturn(Object obj) {
+        int i = 0;
+        switch (obj) {
+            case Integer _ when ((Integer) obj) > 0:
+            case String _ when !((String) obj).isEmpty():
+                i = i + 1;
+            case null:
+                i = i + 10;
+            default:
+                i = i + 100;
+        }
+        return i;
+    }
+
+    int multipleCasesWithLoop(Object obj) {
+        int i = 0;
+        switch (obj) {
+            case Integer _ when ((Integer) obj) > 0:
+            case String _ when !((String) obj).isEmpty():
+                i = i + 1;
+            case null:
+                while (true) {
+                    i = i + 10;
+                    break;
+                }
+            default:
+                i = i + 100;
+        }
+
+        return i;
+    }
+
+    public static void main(String[] args) {
+        new T8314226().run();
+    }
+
+    private void run() {
+        assertEquals(1, multipleGuardedCases(42));
+        assertEquals(1, multipleGuardedCases("test"));
+        assertEquals(-1, multipleGuardedCases(""));
+        assertEquals(1, multipleGuardedCases2a(42.0f));
+        assertEquals(1, multipleGuardedCases2a("test"));
+        assertEquals(-1, multipleGuardedCases2a(""));
+        assertEquals(1, multipleGuardedCases2b(42.0f));
+        assertEquals(1, multipleGuardedCases2b("test"));
+        assertEquals(-1, multipleGuardedCases2b(""));
+        assertEquals(1, multipleGuardedCasesMultiplePatterns((byte) 42));
+        assertEquals(1, multipleGuardedCasesMultiplePatterns("test"));
+        assertEquals(-1, multipleGuardedCasesMultiplePatterns(""));
+        assertEquals(-1, singleGuardedCase(42));
+        assertEquals(1, singleGuardedCase("test"));
+        assertEquals(-1, singleGuardedCase(""));
+        assertEquals(1, multipleCasesWithReturn(42));
+        assertEquals(1, multipleCasesWithReturn("test"));
+        assertEquals(2, multipleCasesWithReturn(null));
+        assertEquals(3, multipleCasesWithReturn(""));
+        assertEquals(111, multipleCasesWithEffectNoReturn(42));
+        assertEquals(111, multipleCasesWithEffectNoReturn("test"));
+        assertEquals(110, multipleCasesWithEffectNoReturn(null));
+        assertEquals(100, multipleCasesWithEffectNoReturn(""));
+        assertEquals(111, multipleCasesWithLoop(42));
+        assertEquals(111, multipleCasesWithLoop("test"));
+        assertEquals(110, multipleCasesWithLoop(null));
+        assertEquals(100, multipleCasesWithLoop(""));
+    }
+
+    void assertEquals(Object expected, Object actual) {
+        if (expected != actual) {
+            throw new AssertionError("Expected: " + expected + ", but got: " + actual);
+        }
+    }
+}