Attempting to fix codegen for rule switch cases.

Author: lahodaj

java/java.source.base/src/org/netbeans/modules/java/source/save/CasualDiff.java

@@ -2184,6 +2184,15 @@ protected int diffCase(JCCase oldT, JCCase newT, int[] bounds) {
             int[] bodyBounds = getBounds(oldT.getBody());
             copyTo(localPointer, bodyBounds[0]);
             localPointer = diffTree(oldT.getBody(), newT.getBody(), bodyBounds);
+            if (oldT.getBody().getKind() != Kind.BLOCK) {
+                tokenSequence.move(localPointer);
+                moveToSrcRelevant(tokenSequence, Direction.FORWARD);
+                if (tokenSequence.token().id() == JavaTokenId.SEMICOLON && newT.getBody().getKind() == Kind.BLOCK) {
+                    localPointer = tokenSequence.offset() + tokenSequence.token().length();
+                }
+            } else if (newT.getBody().getKind() != Kind.BLOCK && newT.getBody().getKind() != Kind.THROW) {
+                printer.print(";");
+            }
             printer.undent(old);
         } else {
             PositionEstimator est = EstimatorFactory.statements(

java/java.source.base/test/unit/src/org/netbeans/api/java/source/gen/SwitchExpressionTest.java

@@ -246,4 +246,117 @@ public Void visitYield(YieldTree node, Void p) {
 
     }
 
+    public void testAnythingToBlock() throws Exception {
+        String code = """
+                      package test; 
+                      public class Test {
+                           private void test(int p) {
+                               var v = switch (p) {
+                                   case 1 -> p = 0;
+                                   default -> throw IllegalStateException();
+                               }
+                           }
+                      }
+                      """;
+        String golden = """
+                        package test; 
+                        public class Test {
+                             private void test(int p) {
+                                 var v = switch (p) {
+                                     case 1 -> {
+                                     }
+                                     default -> {
+                                     }
+                                 }
+                             }
+                        }
+                        """;
+
+        prepareTest("Test", code);
+
+
+        JavaSource js = getJavaSource();
+        assertNotNull(js);
+
+        Task<WorkingCopy> task = new Task<WorkingCopy>() {
+
+            public void run(WorkingCopy workingCopy) throws IOException {
+                workingCopy.toPhase(JavaSource.Phase.RESOLVED);
+
+                TreeMaker make = workingCopy.getTreeMaker();
+
+                new TreePathScanner<>() {
+                    @Override
+                    public Object visitCase(CaseTree node, Object p) {
+                        workingCopy.rewrite(node, make.CasePatterns(node.getLabels(), make.Block(List.of(), false)));
+                        return super.visitCase(node, p);
+                    }
+                }.scan(workingCopy.getCompilationUnit(), null);
+            }
+
+        };
+
+        js.runModificationTask(task).commit();
+        String res = TestUtilities.copyFileToString(getTestFile());
+        //System.err.println(res);
+        assertEquals(golden, res);
+
+    }
+
+    public void testBlockToAnything() throws Exception {
+        String code = """
+                      package test; 
+                      public class Test {
+                           private void test(int p) {
+                               var v = switch (p) {
+                                   case 1 -> {}
+                                   default -> { throw IllegalStateException(); }
+                               }
+                           }
+                      }
+                      """;
+        String golden = """
+                        package test; 
+                        public class Test {
+                             private void test(int p) {
+                                 var v = switch (p) {
+                                     case 1 -> 0;
+                                     default -> throw IllegalStateException();
+                                 }
+                             }
+                        }
+                        """;
+
+        prepareTest("Test", code);
+
+
+        JavaSource js = getJavaSource();
+        assertNotNull(js);
+
+        Task<WorkingCopy> task = new Task<WorkingCopy>() {
+
+            public void run(WorkingCopy workingCopy) throws IOException {
+                workingCopy.toPhase(JavaSource.Phase.RESOLVED);
+
+                TreeMaker make = workingCopy.getTreeMaker();
+
+                new TreePathScanner<>() {
+                    @Override
+                    public Object visitCase(CaseTree node, Object p) {
+                        BlockTree bt = (BlockTree) node.getBody();
+                        Tree newBody = bt.getStatements().isEmpty() ? make.Literal(0)
+                                                                    : bt.getStatements().get(0);
+                        workingCopy.rewrite(node, make.CasePatterns(node.getLabels(), newBody));
+                        return super.visitCase(node, p);
+                    }
+                }.scan(workingCopy.getCompilationUnit(), null);
+            }
+
+        };
+
+        js.runModificationTask(task).commit();
+        String res = TestUtilities.copyFileToString(getTestFile());
+        //System.err.println(res);
+        assertEquals(golden, res);
+    }
 }