jruby · Jan 3, 2016 · Jan 3, 2016
diff --git a/spec/truffle/tags/language/send_tags.txt b/spec/truffle/tags/language/send_tags.txt
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ArrayIsAtLeastAsLargeAsNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/arguments/ArrayIsAtLeastAsLargeAsNode.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2016 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 1.0
+ * GNU General Public License version 2
+ * GNU Lesser General Public License version 2.1
+ */
+package org.jruby.truffle.nodes.arguments;
+
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.object.DynamicObject;
+import com.oracle.truffle.api.source.SourceSection;
+import org.jruby.truffle.nodes.RubyNode;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.layouts.Layouts;
+
+public class ArrayIsAtLeastAsLargeAsNode extends RubyNode {
+
+    @Child private RubyNode child;
+
+    private final int requiredSize;
+
+    public ArrayIsAtLeastAsLargeAsNode(RubyContext context, SourceSection sourceSection, RubyNode child, int requiredSize) {
+        super(context, sourceSection);
+        this.child = child;
+        this.requiredSize = requiredSize;
+    }
+
+    @Override
+    public boolean executeBoolean(VirtualFrame frame) {
+        return Layouts.ARRAY.getSize((DynamicObject) child.execute(frame)) >= requiredSize;
+    }
+
+    @Override
+    public Object execute(VirtualFrame frame) {
+        return executeBoolean(frame);
+    }
+
+}
diff --git a/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java
@@ -19,6 +19,7 @@
 import org.joni.NameEntry;
 import org.joni.Regex;
 import org.joni.Syntax;
+import org.jruby.ast.StarNode;
 import org.jruby.ast.visitor.NodeVisitor;
 import org.jruby.common.IRubyWarnings;
 import org.jruby.lexer.yacc.InvalidSourcePosition;
@@ -2776,6 +2777,11 @@ public RubyNode visitBackRefNode(org.jruby.ast.BackRefNode node) {
         return addNewlineIfNeeded(node, ret);
     }
 
+    @Override
+    public RubyNode visitStarNode(org.jruby.ast.StarNode star) {
+        return nilNode(translate(star.getPosition()));
+    }
+
     protected RubyNode initFlipFlopStates(SourceSection sourceSection) {
         final RubyNode[] initNodes = new RubyNode[environment.getFlipFlopStates().size()];
 

diff --git a/truffle/src/main/java/org/jruby/truffle/translator/LoadArgumentsTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/LoadArgumentsTranslator.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2015 Oracle and/or its affiliates. All rights reserved. This
+ * Copyright (c) 2014, 2016 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:
  *
@@ -339,34 +339,74 @@ public RubyNode visitMultipleAsgnNode(MultipleAsgnNode node) {
             childNodes = node.childNodes().get(0).childNodes();
         }
 
-        final List<RubyNode> notNilSequence = new ArrayList<>();
+        // The load to use when the array is not nil and the length is smaller than the number of required arguments
+
+        final List<RubyNode> notNilSmallerSequence = new ArrayList<>();
+
+        if (node.getPre() != null) {
+            index = 0;
+            for (org.jruby.ast.Node child : node.getPre().children()) {
+                notNilSmallerSequence.add(child.accept(this));
+                index++;
+            }
+        }
+
+        if (node.getRest() != null) {
+            index = node.getPreCount();
+            indexFromEnd = -node.getPostCount();
+            notNilSmallerSequence.add(node.getRest().accept(this));
+            indexFromEnd = 1;
+        }
+
+        if (node.getPost() != null) {
+            org.jruby.ast.Node[] children = node.getPost().children();
+            index = node.getPreCount();
+            for (int i = 0; i < children.length; i++) {
+                notNilSmallerSequence.add(children[i].accept(this));
+                index++;
+            }
+        }
+
+        final RubyNode notNilSmaller = SequenceNode.sequence(context, sourceSection, notNilSmallerSequence);
+
+        if (notNilSmaller == null) {
+            throw new UnsupportedOperationException();
+        }
+
+        // The load to use when the array is not nil and at least as large as the number of required arguments
+
+        final List<RubyNode> notNilAtLeastAsLargeSequence = new ArrayList<>();
 
         if (node.getPre() != null) {
             index = 0;
             for (org.jruby.ast.Node child : node.getPre().children()) {
-                notNilSequence.add(child.accept(this));
+                notNilAtLeastAsLargeSequence.add(child.accept(this));
                 index++;
             }
         }
 
         if (node.getRest() != null) {
             index = node.getPreCount();
             indexFromEnd = -node.getPostCount();
-            notNilSequence.add(node.getRest().accept(this));
+            notNilAtLeastAsLargeSequence.add(node.getRest().accept(this));
             indexFromEnd = 1;
         }
 
         if (node.getPost() != null) {
             org.jruby.ast.Node[] children = node.getPost().children();
             index = -1;
             for (int i = children.length - 1; i >= 0; i--) {
-                notNilSequence.add(children[i].accept(this));
+                notNilAtLeastAsLargeSequence.add(children[i].accept(this));
                 required++;
                 index--;
             }
         }
 
-        final RubyNode notNil = SequenceNode.sequence(context, sourceSection, notNilSequence);
+        final RubyNode notNilAtLeastAsLarge = SequenceNode.sequence(context, sourceSection, notNilAtLeastAsLargeSequence);
+
+        if (notNilAtLeastAsLarge == null) {
+            throw new UnsupportedOperationException();
+        }
 
         popArraySlot(arraySlot);
 
@@ -417,7 +457,10 @@ public RubyNode visitMultipleAsgnNode(MultipleAsgnNode node) {
                 new IfNode(context, sourceSection,
                         new IsNilNode(context, sourceSection, new ReadLocalVariableNode(context, sourceSection, arraySlot)),
                         nil,
-                        notNil == null ? nilNode(sourceSection) : notNil));
+                        new IfNode(context, sourceSection,
+                                new ArrayIsAtLeastAsLargeAsNode(context, sourceSection, new ReadLocalVariableNode(context, sourceSection, arraySlot), node.getPreCount() + node.getPostCount()),
+                                notNilAtLeastAsLarge,
+                                notNilSmaller)));
     }
 
     @Override