Update for new J.Case API

See:
 - openrewrite/rewrite#4661

Author: knutwannheden

.run/RemotingServer.run.xml

@@ -3,9 +3,9 @@
     <option name="ALTERNATIVE_JRE_PATH" value="17" />
     <option name="ALTERNATIVE_JRE_PATH_ENABLED" value="true" />
     <option name="MAIN_CLASS_NAME" value="org.openrewrite.remote.java.RemotingServer" />
-    <module name="rewrite-python.rewrite-test-engine-remote.main" />
+    <module name="rewrite-python.rewrite-python-remote.test" />
     <method v="2">
       <option name="Make" enabled="true" />
     </method>
   </configuration>
-</component>
+</component>

rewrite-python-remote/src/main/java/org/openrewrite/python/remote/PythonReceiver.java

@@ -567,9 +567,10 @@ public J.Case visitCase(J.Case case_, ReceiverContext ctx) {
             case_ = case_.withPrefix(ctx.receiveNonNullNode(case_.getPrefix(), PythonReceiver::receiveSpace));
             case_ = case_.withMarkers(ctx.receiveNonNullNode(case_.getMarkers(), ctx::receiveMarkers));
             case_ = case_.withType(ctx.receiveNonNullValue(case_.getType(), J.Case.Type.class));
-            case_ = case_.getPadding().withExpressions(ctx.receiveNonNullNode(case_.getPadding().getExpressions(), PythonReceiver::receiveContainer));
+            case_ = case_.getPadding().withCaseLabels(ctx.receiveNonNullNode(case_.getPadding().getCaseLabels(), PythonReceiver::receiveContainer));
             case_ = case_.getPadding().withStatements(ctx.receiveNonNullNode(case_.getPadding().getStatements(), PythonReceiver::receiveContainer));
             case_ = case_.getPadding().withBody(ctx.receiveNode(case_.getPadding().getBody(), PythonReceiver::receiveRightPaddedTree));
+            case_ = case_.withGuard(ctx.receiveNode(case_.getGuard(), ctx::receiveTree));
             return case_;
         }
 
@@ -1783,7 +1784,8 @@ private static J.Case createJCase(ReceiverContext ctx) {
                     ctx.receiveNonNullValue(null, J.Case.Type.class),
                     ctx.receiveNonNullNode(null, PythonReceiver::receiveContainer),
                     ctx.receiveNonNullNode(null, PythonReceiver::receiveContainer),
-                    ctx.receiveNode(null, PythonReceiver::receiveRightPaddedTree)
+                    ctx.receiveNode(null, PythonReceiver::receiveRightPaddedTree),
+                    ctx.receiveNode(null, ctx::receiveTree)
             );
         }
 

rewrite-python-remote/src/main/java/org/openrewrite/python/remote/PythonSender.java

@@ -549,9 +549,10 @@ public J.Case visitCase(J.Case case_, SenderContext ctx) {
             ctx.sendNode(case_, J.Case::getPrefix, PythonSender::sendSpace);
             ctx.sendNode(case_, J.Case::getMarkers, ctx::sendMarkers);
             ctx.sendValue(case_, J.Case::getType);
-            ctx.sendNode(case_, e -> e.getPadding().getExpressions(), PythonSender::sendContainer);
+            ctx.sendNode(case_, e -> e.getPadding().getCaseLabels(), PythonSender::sendContainer);
             ctx.sendNode(case_, e -> e.getPadding().getStatements(), PythonSender::sendContainer);
             ctx.sendNode(case_, e -> e.getPadding().getBody(), PythonSender::sendRightPadded);
+            ctx.sendNode(case_, J.Case::getGuard, ctx::sendTree);
             return case_;
         }
 

rewrite-python-remote/src/main/java/org/openrewrite/python/remote/PythonValidator.java

@@ -362,9 +362,10 @@ public J.Break visitBreak(J.Break break_, P p) {
 
     @Override
     public J.Case visitCase(J.Case case_, P p) {
-        visitAndValidate(case_.getExpressions(), Expression.class, p);
+        visitAndValidate(case_.getCaseLabels(), J.class, p);
         visitAndValidate(case_.getStatements(), Statement.class, p);
         visitAndValidate(case_.getBody(), J.class, p);
+        visitAndValidate(case_.getGuard(), Expression.class, p);
         return case_;
     }
 

…nrewrite/csharp/remote/package-info.java …nrewrite/python/remote/package-info.javarewrite-test-engine-remote/src/main/java/org/openrewrite/csharp/remote/package-info.java renamed to rewrite-test-engine-remote/src/main/java/org/openrewrite/python/remote/package-info.java rewrite-test-engine-remote/src/main/java/org/openrewrite/csharp/remote/package-info.java renamed to rewrite-test-engine-remote/src/main/java/org/openrewrite/python/remote/package-info.java

@@ -15,7 +15,7 @@
  */
 @NullMarked
 @NonNullFields
-package org.openrewrite.remote.csharp;
+package org.openrewrite.python.remote;
 
 import org.jspecify.annotations.NullMarked;
 import org.openrewrite.internal.lang.NonNullFields;

rewrite/rewrite/java/remote/receiver.py

@@ -124,9 +124,10 @@ def visit_case(self, case: Case, ctx: ReceiverContext) -> J:
             case = case.with_prefix(ctx.receive_node(case.prefix, JavaReceiver.receive_space))
             case = case.with_markers(ctx.receive_node(case.markers, ctx.receive_markers))
             case = case.with_type(ctx.receive_value(case.type, Case.Type))
-            case = case.padding.with_expressions(ctx.receive_node(case.padding.expressions, JavaReceiver.receive_container))
+            case = case.padding.with_case_labels(ctx.receive_node(case.padding.case_labels, JavaReceiver.receive_container))
             case = case.padding.with_statements(ctx.receive_node(case.padding.statements, JavaReceiver.receive_container))
             case = case.padding.with_body(ctx.receive_node(case.padding.body, JavaReceiver.receive_right_padded_tree))
+            case = case.with_guard(ctx.receive_node(case.guard, ctx.receive_tree))
             return case
 
         def visit_class_declaration(self, class_declaration: ClassDeclaration, ctx: ReceiverContext) -> J:
@@ -760,7 +761,8 @@ def create(self, type: str, ctx: ReceiverContext) -> Tree:
                     ctx.receive_value(None, Case.Type),
                     ctx.receive_node(None, JavaReceiver.receive_container),
                     ctx.receive_node(None, JavaReceiver.receive_container),
-                    ctx.receive_node(None, JavaReceiver.receive_right_padded_tree)
+                    ctx.receive_node(None, JavaReceiver.receive_right_padded_tree),
+                    ctx.receive_node(None, ctx.receive_tree)
                 )
 
             if type in ["rewrite.java.tree.ClassDeclaration", "org.openrewrite.java.tree.J$ClassDeclaration"]:

rewrite/rewrite/java/remote/sender.py

@@ -118,9 +118,10 @@ def visit_case(self, case: Case, ctx: SenderContext) -> J:
             ctx.send_node(case, attrgetter('_prefix'), JavaSender.send_space)
             ctx.send_node(case, attrgetter('_markers'), ctx.send_markers)
             ctx.send_value(case, attrgetter('_type'))
-            ctx.send_node(case, attrgetter('_expressions'), JavaSender.send_container)
+            ctx.send_node(case, attrgetter('_case_labels'), JavaSender.send_container)
             ctx.send_node(case, attrgetter('_statements'), JavaSender.send_container)
             ctx.send_node(case, attrgetter('_body'), JavaSender.send_right_padded)
+            ctx.send_node(case, attrgetter('_guard'), ctx.send_tree)
             return case
 
         def visit_class_declaration(self, class_declaration: ClassDeclaration, ctx: SenderContext) -> J:

rewrite/rewrite/java/tree.py

@@ -810,14 +810,14 @@ def with_markers(self, markers: Markers) -> Case:
     def with_type(self, type: Type) -> Case:
         return self if type is self._type else replace(self, _type=type)
 
-    _expressions: JContainer[Expression]
+    _case_labels: JContainer[J]
 
     @property
-    def expressions(self) -> List[Expression]:
-        return self._expressions.elements
+    def case_labels(self) -> List[J]:
+        return self._case_labels.elements
 
-    def with_expressions(self, expressions: List[Expression]) -> Case:
-        return self.padding.with_expressions(JContainer.with_elements(self._expressions, expressions))
+    def with_case_labels(self, case_labels: List[J]) -> Case:
+        return self.padding.with_case_labels(JContainer.with_elements(self._case_labels, case_labels))
 
     _statements: JContainer[Statement]
 
@@ -837,6 +837,15 @@ def body(self) -> Optional[J]:
     def with_body(self, body: Optional[J]) -> Case:
         return self.padding.with_body(JRightPadded.with_element(self._body, body))
 
+    _guard: Optional[Expression]
+
+    @property
+    def guard(self) -> Optional[Expression]:
+        return self._guard
+
+    def with_guard(self, guard: Optional[Expression]) -> Case:
+        return self if guard is self._guard else replace(self, _guard=guard)
+
     class Type(Enum):
         Statement = 0
         Rule = 1
@@ -846,11 +855,11 @@ class PaddingHelper:
         _t: Case
 
         @property
-        def expressions(self) -> JContainer[Expression]:
-            return self._t._expressions
+        def case_labels(self) -> JContainer[J]:
+            return self._t._case_labels
 
-        def with_expressions(self, expressions: JContainer[Expression]) -> Case:
-            return self._t if self._t._expressions is expressions else replace(self._t, _expressions=expressions)
+        def with_case_labels(self, case_labels: JContainer[J]) -> Case:
+            return self._t if self._t._case_labels is case_labels else replace(self._t, _case_labels=case_labels)
 
         @property
         def statements(self) -> JContainer[Statement]:

rewrite/rewrite/java/visitor.py

@@ -144,9 +144,10 @@ def visit_case(self, case: Case, p: P) -> J:
             return temp_statement
         case = cast(Case, temp_statement)
         case = case.with_markers(self.visit_markers(case.markers, p))
-        case = case.padding.with_expressions(self.visit_container(case.padding.expressions, JContainer.Location.CASE_EXPRESSION, p))
+        case = case.padding.with_case_labels(self.visit_container(case.padding.case_labels, JContainer.Location.CASE_CASE_LABELS, p))
         case = case.padding.with_statements(self.visit_container(case.padding.statements, JContainer.Location.CASE, p))
         case = case.padding.with_body(self.visit_right_padded(case.padding.body, JRightPadded.Location.CASE_BODY, p))
+        case = case.with_guard(self.visit_and_cast(case.guard, Expression, p))
         return case
 
     def visit_class_declaration(self, class_declaration: ClassDeclaration, p: P) -> J:

rewrite/rewrite/python/_parser_visitor.py

@@ -865,7 +865,8 @@ def visit_match_case(self, node):
                 Markers.EMPTY
             ),
             JContainer.empty(),
-            self.__pad_right(self.__convert_block(node.body), Space.EMPTY)
+            self.__pad_right(self.__convert_block(node.body), Space.EMPTY),
+            None
         )
 
     def visit_MatchValue(self, node):