JRUBY-4180: [1.8.7] Blocks should be able to receive block arguments …

…(interpreted-mode only + some internals)

src/org/jruby/RubyProc.java

@@ -200,6 +200,10 @@ public IRubyObject binding() {
     }
 
     @JRubyMethod(name = {"call", "[]"}, rest = true, frame = true, compat = CompatVersion.RUBY1_8)
+    public IRubyObject call(ThreadContext context, IRubyObject[] args, Block block) {
+        return call(context, args, null, block);
+    }
+
     public IRubyObject call(ThreadContext context, IRubyObject[] args) {
         return call(context, args, null, Block.NULL_BLOCK);
     }

src/org/jruby/ast/BlockArg18Node.java

@@ -0,0 +1,53 @@
+package org.jruby.ast;
+
+import java.util.List;
+import org.jruby.ast.visitor.NodeVisitor;
+import org.jruby.lexer.yacc.ISourcePosition;
+
+/**
+ * Similiar to BlockArg, but with idiosyncracies that 1.8.7 allows:
+ *
+ * proc { |a,&b| }
+ * proc { |a,&FOO| }
+ * proc { |a,b.c| }
+ * proc { |a,b[0]| }
+ *
+ */
+public class BlockArg18Node extends Node {
+    private Node normalBlockArgs;
+    private Node blockArgAssignee;
+
+    public BlockArg18Node(ISourcePosition position, Node blockArgAssignee,
+            Node normalBlockArgs) {
+        super(position);
+
+        assert blockArgAssignee != null : "Must be a value to assign too";
+
+        this.blockArgAssignee = blockArgAssignee;
+        this.normalBlockArgs = normalBlockArgs;
+    }
+
+    public Node getArgs() {
+        return normalBlockArgs;
+    }
+
+    public Node getBlockArg() {
+        return blockArgAssignee;
+    }
+
+    @Override
+    public Object accept(NodeVisitor visitor) {
+        return visitor.visitBlockArg18Node(this);
+    }
+
+    @Override
+    public List<Node> childNodes() {
+        return createList(normalBlockArgs, blockArgAssignee);
+    }
+
+    @Override
+    public NodeType getNodeType() {
+        return NodeType.BLOCKARG18NODE;
+    }
+
+}

src/org/jruby/ast/BlockArgNode.java

@@ -38,7 +38,7 @@
 import org.jruby.lexer.yacc.ISourcePosition;
 
 /**
- *	An explicit block argument (&my_block).
+ *	An explicit block argument (&my_block) in parameter list.
  */
 public class BlockArgNode extends Node implements INameNode {
     private final int count;

src/org/jruby/ast/BlockPassNode.java

@@ -41,14 +41,19 @@
 import org.jruby.runtime.builtin.IRubyObject;
 
 /**
- * Block passed explicitly as an argument in a method call.
- * A block passing argument in a method call (last argument prefixed by an ampersand).
+ * Explicit block argument (on caller side):
+ *   foobar(1, 2, &foo)
+ *   foobar(1, 2, &lhs_which_returns_something_block/proc_like)
+ *
+ * bodyNode is any expression which can return something which is ultimately
+ * coercible to a proc.
  */
 public class BlockPassNode extends Node {
     private final Node bodyNode;
 
     /** Used by the arg_blk_pass and new_call, new_fcall and new_super
-     * methods in ParserSupport to temporary save the args node.
+     * methods in ParserSupport to temporary save the args node.  This should
+     * not be used directly by compiler or interpreter.
      */
     private Node argsNode;
 

src/org/jruby/ast/ForNode.java

@@ -60,7 +60,7 @@ public ForNode(ISourcePosition position, Node varNode, Node bodyNode, Node iterN
         // 'For's are implemented as blocks in evaluation, but they have no scope so we
         // just deal with this lack of scope throughout its lifespan.  We should probably
         // change the way this works to get rid of multiple null checks.
-        super(position, varNode, null, bodyNode);
+        super(position, varNode, null, null, bodyNode);
 
         assert iterNode != null : "iterNode is not null";
 

src/org/jruby/ast/IterNode.java

@@ -51,16 +51,24 @@
 public class IterNode extends Node {
     private final Node varNode;
     private final Node bodyNode;
+    private final Node blockVarNode; // This is only for 1.8 blocks
 
     // What static scoping relationship exists when it comes into being.
     private StaticScope scope;
     private BlockBody blockBody;
 
-    public IterNode(ISourcePosition position, Node varNode, StaticScope scope, Node bodyNode) {
+    public IterNode(ISourcePosition position, Node args, BlockPassNode iter, StaticScope scope, Node body) {
         super(position);
-        this.varNode = varNode;
+
+        if (args instanceof BlockArg18Node) {
+            this.varNode = ((BlockArg18Node) args).getArgs();
+            this.blockVarNode = ((BlockArg18Node) args).getBlockArg();
+        } else {
+            this.varNode = args;
+            this.blockVarNode = null;
+        }
         this.scope = scope;
-        this.bodyNode = bodyNode;
+        this.bodyNode = body;
         NodeType argsNodeId = BlockBody.getArgumentTypeWackyHack(this);
         this.blockBody = InterpretedBlock.newBlockBody(this, Arity.procArityOf(varNode), BlockBody.asArgumentType(argsNodeId));
     }
@@ -69,6 +77,7 @@ public IterNode(ISourcePosition position, ArgsNode args, Node body, StaticScope
         super(position);
 
         this.varNode = args;
+        this.blockVarNode = null; // This is only for 1.8 blocks
         this.bodyNode = body;
         this.scope = scope;
         this.blockBody = new Interpreted19Block(this);
@@ -85,6 +94,10 @@ public NodeType getNodeType() {
     public Object accept(NodeVisitor iVisitor) {
         return iVisitor.visitIterNode(this);
     }
+
+    public Node getBlockVarNode() {
+        return blockVarNode;
+    }
 
     public StaticScope getScope() {
         return scope;
@@ -111,7 +124,7 @@ public BlockBody getBlockBody() {
     }
 
     public List<Node> childNodes() {
-        return Node.createList(varNode, bodyNode);
+        return Node.createList(varNode, blockVarNode, bodyNode);
     }
 
     @Override

src/org/jruby/ast/MultipleAsgnNode.java

@@ -39,7 +39,6 @@
 import org.jruby.ast.visitor.NodeVisitor;
 import org.jruby.evaluator.ASTInterpreter;
 import org.jruby.evaluator.AssignmentVisitor;
-import org.jruby.javasupport.util.RuntimeHelpers;
 import org.jruby.lexer.yacc.ISourcePosition;
 import org.jruby.runtime.Arity;
 import org.jruby.runtime.Block;

src/org/jruby/ast/NodeType.java

@@ -45,7 +45,7 @@ public enum NodeType {
     TRUENODE, UNDEFNODE, UNTILNODE, VALIASNODE, VCALLNODE, WHENNODE, WHILENODE, XSTRNODE, YIELDNODE,
     ZARRAYNODE, ZEROARGNODE, ZSUPERNODE, COMMENTNODE, ROOTNODE, ATTRASSIGNNODE, ARGSPUSHNODE,
     OPTARGNODE, ARGAUXILIARYNODE, LAMBDANODE, MULTIPLEASGN19NODE, RESTARG, ENCODINGNODE,
-    LITERALNODE;
+    LITERALNODE, BLOCKARG18NODE;
 
 
     /**

src/org/jruby/ast/PostExeNode.java

@@ -44,7 +44,7 @@
  */
 public class PostExeNode extends IterNode {
     public PostExeNode(ISourcePosition position, Node body) {
-        super(position, null, null, body);
+        super(position, null, null, null, body);
     }
 
     public NodeType getNodeType() {

src/org/jruby/ast/PreExeNode.java

@@ -43,9 +43,10 @@
  */
 public class PreExeNode extends IterNode {
     public PreExeNode(ISourcePosition position, StaticScope scope, Node body) {
-        super(position, null, scope, body);
+        super(position, null, null, scope, body);
     }
 
+    @Override
     public NodeType getNodeType() {
         return NodeType.PREEXENODE;
     }

src/org/jruby/ast/visitor/NodeVisitor.java

@@ -42,6 +42,7 @@
 import org.jruby.ast.BeginNode;
 import org.jruby.ast.BignumNode;
 import org.jruby.ast.BlockArgNode;
+import org.jruby.ast.BlockArg18Node;
 import org.jruby.ast.BlockNode;
 import org.jruby.ast.BlockPassNode;
 import org.jruby.ast.BreakNode;
@@ -150,6 +151,7 @@ public interface NodeVisitor {
     public Object visitBeginNode(BeginNode iVisited);
     public Object visitBignumNode(BignumNode iVisited);
     public Object visitBlockArgNode(BlockArgNode iVisited);
+    public Object visitBlockArg18Node(BlockArg18Node iVisited);
     public Object visitBlockNode(BlockNode iVisited);
     public Object visitBlockPassNode(BlockPassNode iVisited);
     public Object visitBreakNode(BreakNode iVisited);