[GR-29207] Handle all cases of multiple assignment with a single node

PullRequest: truffleruby/2418

Author: eregon

ci.jsonnet

@@ -301,7 +301,7 @@ local part_definitions = {
 
     test_unit_tck: {
       # Run unittests first before cleaning, they need a full non-cleaned build
-      run+: jt(["test", "unit"]) +
+      run+: jt(["test", "unit", "--verbose"]) +
             jt(["test", "tck"])
     },
 

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

@@ -60,7 +60,7 @@ protected RubyArray cachedCreateArray(Object store, int size) {
     }
 
     @Override
-    public abstract Object execute(VirtualFrame frame);
+    public abstract RubyArray execute(VirtualFrame frame);
 
     @ExplodeLoop
     @Override
@@ -100,7 +100,7 @@ public EmptyArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
         }
 
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             return cachedCreateArray(ArrayStoreLibrary.INITIAL_STORE, 0);
         }
 
@@ -114,7 +114,7 @@ public FloatArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
 
         @ExplodeLoop
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             final double[] executedValues = new double[values.length];
 
             for (int n = 0; n < values.length; n++) {
@@ -151,7 +151,7 @@ public IntegerArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
 
         @ExplodeLoop
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             final int[] executedValues = new int[values.length];
 
             for (int n = 0; n < values.length; n++) {
@@ -188,7 +188,7 @@ public LongArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
 
         @ExplodeLoop
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             final long[] executedValues = new long[values.length];
 
             for (int n = 0; n < values.length; n++) {
@@ -225,7 +225,7 @@ public ObjectArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
 
         @ExplodeLoop
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             final Object[] executedValues = new Object[values.length];
 
             for (int n = 0; n < values.length; n++) {
@@ -244,7 +244,7 @@ public UninitialisedArrayLiteralNode(RubyLanguage language, RubyNode[] values) {
         }
 
         @Override
-        public Object execute(VirtualFrame frame) {
+        public RubyArray execute(VirtualFrame frame) {
             CompilerDirectives.transferToInterpreterAndInvalidate();
 
             final Object[] executedValues = new Object[values.length];

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

@@ -32,8 +32,10 @@ public ArraySliceNode(int from, int to) {
         this.to = to;
     }
 
+    public abstract RubyArray execute(RubyArray array);
+
     @Specialization
-    protected RubyArray readInBounds(RubyArray array,
+    protected RubyArray readSlice(RubyArray array,
             @Cached ArrayCopyOnWriteNode cowNode,
             @Cached ConditionProfile emptyArray) {
         final int length = array.size + to - from;

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

@@ -219,6 +219,12 @@ public static Object[] unshift(Object[] array, Object element) {
         return newArray;
     }
 
+    public static Object[] append(Object[] array, Object element) {
+        final Object[] newArray = grow(array, array.length + 1);
+        newArray[array.length] = element;
+        return newArray;
+    }
+
     public static int memcmp(final byte[] first, final int firstStart, final byte[] second, final int secondStart,
             int size) {
         assert firstStart + size <= first.length;

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.array;
+
+import com.oracle.truffle.api.nodes.NodeInterface;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+
+public interface AssignableNode extends NodeInterface {
+
+    static final AssignableNode[] EMPTY_ARRAY = new AssignableNode[0];
+
+    /** This should null out the valueNode field, as that node should not be executed */
+    AssignableNode toAssignableNode();
+
+    /** Execute the node and assign the given value */
+    void assign(VirtualFrame frame, Object value);
+
+}

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

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.array;
+
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.nodes.ExplodeLoop;
+import org.truffleruby.RubyContext;
+import org.truffleruby.RubyLanguage;
+import org.truffleruby.core.array.ArrayIndexNodes.ReadNormalizedNode;
+import org.truffleruby.core.cast.SplatCastNode;
+import org.truffleruby.language.RubyContextSourceNode;
+import org.truffleruby.language.RubyNode;
+
+import com.oracle.truffle.api.profiles.ConditionProfile;
+
+public class MultipleAssignmentNode extends RubyContextSourceNode implements AssignableNode {
+
+    @Child RubyNode rhsNode;
+    @Child SplatCastNode splatCastNode;
+
+    @Children final AssignableNode[] preNodes;
+    @Child AssignableNode restNode;
+    @Children final AssignableNode[] postNodes;
+
+    @Child ReadNormalizedNode arrayReadNormalizedNode;
+    @Child ArraySliceNode arraySliceNode;
+
+    private final ConditionProfile enoughElementsForAllPost;
+
+    public MultipleAssignmentNode(
+            AssignableNode[] preNodes,
+            AssignableNode restNode,
+            AssignableNode[] postNodes,
+            SplatCastNode splatCastNode,
+            RubyNode rhsNode) {
+        this.preNodes = preNodes;
+        this.restNode = restNode;
+        this.postNodes = postNodes;
+        this.splatCastNode = splatCastNode;
+        this.rhsNode = rhsNode;
+        this.enoughElementsForAllPost = postNodes.length == 0 ? null : ConditionProfile.create();
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        final Object rhs = rhsNode.execute(frame);
+        assign(frame, rhs);
+        return rhs;
+    }
+
+    @ExplodeLoop
+    @Override
+    public void assign(VirtualFrame frame, Object rhs) {
+        final RubyArray array = (RubyArray) splatCastNode.execute(rhs);
+
+        for (int i = 0; i < preNodes.length; i++) {
+            preNodes[i].assign(frame, read(array, i));
+        }
+
+        if (restNode != null) {
+            restNode.assign(frame, readSlice(array));
+        }
+
+        if (postNodes.length > 0) {
+            final int size = array.size;
+            for (int i = 0; i < postNodes.length; i++) {
+                // a, b, *, c, d = ary
+                final int index;
+                if (enoughElementsForAllPost.profile(size >= preNodes.length + postNodes.length)) {
+                    index = size - postNodes.length + i; // post take size-2, size-1 (size >= 4)
+                } else {
+                    index = preNodes.length + i; // post take pre, pre+1, some of them (the tail) will read nil
+                }
+                postNodes[i].assign(frame, read(array, index));
+            }
+        }
+    }
+
+    @Override
+    public Object isDefined(VirtualFrame frame, RubyLanguage language, RubyContext context) {
+        return language.coreStrings.ASSIGNMENT.createInstance(context);
+    }
+
+    private Object read(RubyArray array, int i) {
+        if (arrayReadNormalizedNode == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            arrayReadNormalizedNode = insert(ReadNormalizedNode.create());
+        }
+
+        return arrayReadNormalizedNode.executeRead(array, i);
+    }
+
+    private Object readSlice(RubyArray array) {
+        if (arraySliceNode == null) {
+            CompilerDirectives.transferToInterpreterAndInvalidate();
+            arraySliceNode = insert(ArraySliceNodeGen.create(preNodes.length, -postNodes.length, null));
+        }
+
+        return arraySliceNode.execute(array);
+    }
+
+    @Override
+    public AssignableNode toAssignableNode() {
+        this.rhsNode = null;
+        return this;
+    }
+}

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

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved. This
+ * code is released under a tri EPL/GPL/LGPL license. You can use it,
+ * redistribute it and/or modify it under the terms of the:
+ *
+ * Eclipse Public License version 2.0, or
+ * GNU General Public License version 2, or
+ * GNU Lesser General Public License version 2.1.
+ */
+package org.truffleruby.core.array;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import org.truffleruby.language.RubyBaseNode;
+
+/** An AssignableNode to represent the * in <code>* = 1, 2</code> */
+public class NoopAssignableNode extends RubyBaseNode implements AssignableNode {
+    @Override
+    public void assign(VirtualFrame frame, Object value) {
+        // The RHS is executed now, nothing else to do
+    }
+
+    @Override
+    public AssignableNode toAssignableNode() {
+        return this;
+    }
+}

src/main/java/org/truffleruby/core/cast/ArrayCastNode.java

@@ -25,12 +25,8 @@
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.profiles.BranchProfile;
 
-
-/*
- * TODO(CS): could probably unify this with SplatCastNode with some final configuration getContext().getOptions().
- */
-
-/** See also org.truffleruby.core.array.ArrayConvertNode */
+// TODO(CS): could probably unify this with SplatCastNode with some final configuration getContext().getOptions().
+/** See also {@link org.truffleruby.core.array.ArrayConvertNode} */
 @NodeChild(value = "child", type = RubyNode.class)
 public abstract class ArrayCastNode extends RubyContextSourceNode {
 

src/main/java/org/truffleruby/core/cast/SplatCastNode.java

@@ -57,6 +57,8 @@ public void doNotCopy() {
 
     public abstract RubyNode getChild();
 
+    public abstract Object execute(Object value);
+
     @Specialization
     protected Object splatNil(Nil nil) {
         switch (nilBehavior) {

src/main/java/org/truffleruby/core/regexp/RegexpNodes.java

@@ -1,14 +1,5 @@
 /*
- * Copyright (c) 2016, 2020 Oracle and/or its affiliates. All rights reserved. This
- * code is released under a tri EPL/GPL/LGPL license. You can use it,
- * redistribute it and/or modify it under the terms of the:
- *
- * Eclipse Public License version 2.0, or
- * GNU General Public License version 2, or
- * GNU Lesser General Public License version 2.1.
- */
-/*
- * Copyright (c) 2013, 2015, 2016 Oracle and/or its affiliates. All rights reserved. This
+ * Copyright (c) 2013, 2020 Oracle and/or its affiliates. All rights reserved. This
  * code is released under a tri EPL/GPL/LGPL license. You can use it,
  * redistribute it and/or modify it under the terms of the:
  *