consolidate calltargetnode so they can all safe navigate and dry it up

Author: enebo

src/main/java/org/jruby/prism/builder/IRBuilderPrism.java

@@ -375,8 +375,8 @@ private Operand buildArray(ArrayNode node) {
     protected void buildAssignment(Node node, Operand rhsVal) {
         if (node == null) return; // case of 'a, = something'
 
-        if (node instanceof CallTargetNode) {
-            buildAttrAssignAssignment(((CallTargetNode) node).receiver, ((CallTargetNode) node).name, Node.EMPTY_ARRAY, rhsVal);
+        if (node instanceof CallTargetNode call) {
+            buildCallTarget(call, build(call.receiver), rhsVal);
         } else if (node instanceof IndexTargetNode) {
             Node[] arguments = ((IndexTargetNode) node).arguments == null ? Node.EMPTY_ARRAY : ((IndexTargetNode) node).arguments.arguments;
             buildAttrAssignAssignment(((IndexTargetNode) node).receiver, symbol("[]="), arguments, rhsVal);
@@ -417,6 +417,16 @@ protected void buildAssignment(Node node, Operand rhsVal) {
         }
     }
 
+    private void buildCallTarget(CallTargetNode call, Operand receiver, Operand rhsVal) {
+        CallType callType = call.isIgnoreVisibility() ? CallType.FUNCTIONAL : CallType.NORMAL;
+        if (call.isSafeNavigation()) {
+            if_not(receiver, nil(),
+                    () -> _call(temp(), callType, receiver, call.name, rhsVal));
+        } else {
+            _call(temp(), callType, receiver, call.name, rhsVal);
+        }
+    }
+
     @Override
     protected Operand[] buildAttrAssignCallArgs(Node argsNode, Operand[] rhs, boolean containsAssignment) {
         Operand[] args = buildCallArgs(argsNode, new int[] { 0 });
@@ -1561,16 +1571,7 @@ protected void buildAssignment(Map<Node, Operand> reads, List<Tuple<Node, Result
             var rhs = assign.b.getResult();
 
             switch (node) {
-                case CallTargetNode call -> {
-                    CallType callType = call.isIgnoreVisibility() ? CallType.FUNCTIONAL : CallType.NORMAL;
-                    var receiver = reads.get(call.receiver);
-                    if (call.isSafeNavigation()) {
-                        if_not(receiver, nil(),
-                                () -> _call(temp(), callType, receiver, call.name, rhs));
-                    } else {
-                        _call(temp(), callType, receiver, call.name, rhs);
-                    }
-                }
+                case CallTargetNode call -> buildCallTarget(call, reads.get(call.receiver), rhs);
                 case IndexTargetNode index -> {
                     // FIXME: we determine self.foo[] by requiring receiver to be `self` in AttrAssignInstr but we could
                     //  use isIgnoreVisibility() that the parser provides.  We have no code path to do this though in AttrAssignInstr.
@@ -2182,15 +2183,9 @@ public void receivePreArg(Node node, Variable keywords, int argIndex) {
             Variable v = temp();
             addInstr(new ReceivePreReqdArgInstr(v, keywords, argIndex));
             addInstr(new PutGlobalVarInstr(target.name, v));
-        } else if (node instanceof CallTargetNode target) {
+        } else if (node instanceof CallTargetNode call) {
             var v = addResultInstr(new ReceivePreReqdArgInstr(temp(), keywords, argIndex));
-            if (target.isSafeNavigation()) {
-                var receiver = build(target.receiver);
-                if_not(receiver, nil(),
-                        () -> call(temp(), receiver, target.name, v));
-            } else {
-                call(temp(), build(target.receiver), target.name, v);
-            }
+            buildCallTarget(call, build(call.receiver), v);
         } else if (node instanceof IndexTargetNode target) {
             var v = addResultInstr(new ReceivePreReqdArgInstr(temp(), keywords, argIndex));
             if (target.isSafeNavigation()) {