Make a helper method ArrayUtils.getLast generic and use it for translators

Author: andrykonchin

src/main/java/org/truffleruby/core/array/ArrayUtils.java

@@ -242,7 +242,7 @@ public static Object[] append(Object[] array, Object element) {
         return newArray;
     }
 
-    public static Object getLast(Object[] array) {
+    public static <T> T getLast(T[] array) {
         assert array.length >= 1;
         return array[array.length - 1];
     }

src/main/java/org/truffleruby/language/dispatch/RubyCallNode.java

@@ -19,6 +19,7 @@
 import org.truffleruby.core.array.ArrayAppendOneNode;
 import org.truffleruby.core.array.ArrayConcatNode;
 import org.truffleruby.core.array.ArrayLiteralNode;
+import org.truffleruby.core.array.ArrayUtils;
 import org.truffleruby.core.array.AssignableNode;
 import org.truffleruby.core.array.RubyArray;
 import org.truffleruby.core.cast.BooleanCastNode;
@@ -184,7 +185,7 @@ public Object doCall(VirtualFrame frame, Object receiverObject, ArgumentsDescrip
 
         final Object returnValue = dispatch.execute(frame, receiverObject, methodName, rubyArgs, dispatchConfig);
         if (isAttrAssign) {
-            final Object value = rubyArgs[rubyArgs.length - 1];
+            final Object value = ArrayUtils.getLast(rubyArgs);
             assert RubyGuards.assertIsValidRubyValue(value);
             return value;
         } else {
@@ -279,7 +280,7 @@ public RubyNode[] getArguments() {
     }
 
     private RubyNode getLastArgumentNode() {
-        final RubyNode lastArg = RubyNode.unwrapNode(arguments[arguments.length - 1]);
+        final RubyNode lastArg = RubyNode.unwrapNode(ArrayUtils.getLast(arguments));
 
         // BodyTranslator-specific condition
         if (isSplatted && lastArg instanceof ArrayAppendOneNode arrayAppendOneNode) {
@@ -294,13 +295,13 @@ private RubyNode getLastArgumentNode() {
             RubyNode[] elements = arrayConcatNode.getElements();
             assert elements.length > 0;
 
-            RubyNode last = RubyNode.unwrapNode(elements[elements.length - 1]);
+            RubyNode last = RubyNode.unwrapNode(ArrayUtils.getLast(elements));
 
             if (last instanceof ArrayLiteralNode arrayLiteralNode) {
                 RubyNode[] values = arrayLiteralNode.getValues();
                 assert values.length > 0;
 
-                return RubyNode.unwrapNode(values[values.length - 1]);
+                return RubyNode.unwrapNode(ArrayUtils.getLast(values));
             } else {
                 return last;
             }

src/main/java/org/truffleruby/parser/YARPBaseTranslator.java

@@ -17,6 +17,7 @@
 import org.prism.Nodes;
 import org.truffleruby.RubyLanguage;
 import org.truffleruby.core.DummyNode;
+import org.truffleruby.core.array.ArrayUtils;
 import org.truffleruby.core.encoding.RubyEncoding;
 import org.truffleruby.core.encoding.TStringUtils;
 import org.truffleruby.language.RubyContextSourceNode;
@@ -179,7 +180,7 @@ protected static void assignPositionOnly(Nodes.Node yarpNode, RubyNode rubyNode)
     // assign position based on a list of nodes (arguments list, exception classes list in a rescue section, etc)
     protected final void assignPositionOnly(Nodes.Node[] nodes, RubyNode rubyNode) {
         final Nodes.Node first = nodes[0];
-        final Nodes.Node last = nodes[nodes.length - 1];
+        final Nodes.Node last = ArrayUtils.getLast(nodes);
 
         final int length = last.endOffset() - first.startOffset;
         rubyNode.unsafeSetSourceSection(first.startOffset, length);

src/main/java/org/truffleruby/parser/YARPTranslator.java

@@ -771,7 +771,7 @@ private ArgumentsDescriptor getKeywordArgumentsDescriptor(Nodes.Node[] arguments
         }
 
         // consider there are keyword arguments if the last argument is either ... or a Hash
-        Nodes.Node last = arguments[arguments.length - 1];
+        Nodes.Node last = ArrayUtils.getLast(arguments);
 
         // a(...) means there are potentially forwarded keyword arguments
         if (last instanceof Nodes.ForwardingArgumentsNode) {
@@ -2400,7 +2400,7 @@ private static Nodes.StringNode concatStringNodes(Nodes.InterpolatedStringNode n
         }
 
         int start = parts[0].startOffset;
-        var last = parts[parts.length - 1];
+        var last = ArrayUtils.getLast(parts);
         int length = last.endOffset() - start;
         return new Nodes.StringNode(NO_FLAGS, concatenated, start, length);
     }