jruby · Feb 15, 2015 · Feb 15, 2015 · Feb 20, 2015 · Feb 20, 2015 · Feb 27, 2015
diff --git a/core/src/main/java/org/jruby/ast/ArgsNode.java b/core/src/main/java/org/jruby/ast/ArgsNode.java
@@ -154,6 +154,18 @@ protected Arity calculateArity() {
     public boolean hasKwargs() {
         return hasKwargs;
     }
+
+    public int countKeywords() {
+        if (hasKwargs) {
+            if (keywords == null) {
+                // Rest keyword argument
+                return 0;
+            }
+            return keywords.size();
+        } else {
+            return 0;
+        }
+    }
 
     protected boolean hasMasgnArgs() {
         if (preCount > 0) for (Node node : pre.childNodes()) {
@@ -254,6 +266,10 @@ public KeywordRestArgNode getKeyRest() {
         return keyRest;
     }
 
+    public boolean hasKeyRest() {
+        return keyRest != null;
+    }
+
     public void checkArgCount(Ruby runtime, int argsLength) {
         Arity.checkArgumentCount(runtime, argsLength, requiredArgsCount, maxArgsCount, hasKwargs);
     }

diff --git a/truffle/src/main/java/org/jruby/truffle/TruffleBridgeImpl.java b/truffle/src/main/java/org/jruby/truffle/TruffleBridgeImpl.java
@@ -164,7 +164,7 @@ public void init() {
 
     @Override
     public Object execute(final Object self, final org.jruby.ast.RootNode rootNode) {
-	return execute(TranslatorDriver.ParserContext.TOP_LEVEL, self, null, rootNode);
+        return execute(TranslatorDriver.ParserContext.TOP_LEVEL, self, null, rootNode);
     }
 
     public Object execute(final TranslatorDriver.ParserContext parserContext, final Object self, final MaterializedFrame parentFrame, final org.jruby.ast.RootNode rootNode) {

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/RubyCallNode.java
@@ -13,28 +13,40 @@
 import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.ExplodeLoop;
+import com.oracle.truffle.api.nodes.NodeUtil;
 import com.oracle.truffle.api.source.SourceSection;
 import com.oracle.truffle.api.utilities.BranchProfile;
 import org.jruby.truffle.nodes.cast.BooleanCastNode;
 import org.jruby.truffle.nodes.cast.BooleanCastNodeFactory;
 import org.jruby.truffle.nodes.cast.ProcOrNullNode;
 import org.jruby.truffle.nodes.cast.ProcOrNullNodeFactory;
 import org.jruby.truffle.nodes.dispatch.*;
+import org.jruby.truffle.nodes.literal.HashLiteralNode;
+import org.jruby.truffle.nodes.literal.ObjectLiteralNode;
+import org.jruby.truffle.nodes.methods.MarkerNode;
+import org.jruby.truffle.nodes.methods.arguments.OptionalKeywordArgMissingNode;
+import org.jruby.truffle.nodes.methods.arguments.UnknownArgumentErrorNode;
 import org.jruby.truffle.runtime.ModuleOperations;
 import org.jruby.truffle.runtime.RubyArguments;
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.core.RubyArray;
 import org.jruby.truffle.runtime.core.RubyProc;
+import org.jruby.truffle.runtime.core.RubySymbol;
 import org.jruby.truffle.runtime.methods.InternalMethod;
 import org.jruby.truffle.runtime.util.ArrayUtils;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class RubyCallNode extends RubyNode {
 
     private final String methodName;
 
     @Child private RubyNode receiver;
     @Child private ProcOrNullNode block;
     @Children private final RubyNode[] arguments;
+    @Children private final RubyNode[] keywordOptimizedArguments;
+    @CompilerDirectives.CompilationFinal private int keywordOptimizedArgumentsLength;
 
     private final boolean isSplatted;
     private final boolean isVCall;
@@ -54,6 +66,8 @@ public class RubyCallNode extends RubyNode {
 
     private final boolean ignoreVisibility;
 
+    @CompilerDirectives.CompilationFinal private boolean cannotOptimize;
+
     public RubyCallNode(RubyContext context, SourceSection section, String methodName, RubyNode receiver, RubyNode block, boolean isSplatted, RubyNode... arguments) {
         this(context, section, methodName, receiver, block, isSplatted, false, false, arguments);
     }
@@ -84,12 +98,53 @@ public RubyCallNode(RubyContext context, SourceSection section, String methodNam
         respondToMissingCast = BooleanCastNodeFactory.create(context, section, null);
 
         this.ignoreVisibility = ignoreVisibility;
+
+        /*
+         * TODO CS 19-Mar-15 we currently can't swap an @Children array out
+         * so we just allocate a lot up-front. In a future version of Truffle
+         * @Children might not need to be final, which would fix this.
+         */
+        keywordOptimizedArguments = new RubyNode[arguments.length + 32];
     }
 
     @Override
     public Object execute(VirtualFrame frame) {
         final Object receiverObject = receiver.execute(frame);
-        final Object[] argumentsObjects = executeArguments(frame);
+
+        final Object[] argumentsObjects;
+
+        if (dispatchHead.getFirstDispatchNode().couldOptimizeKeywordArguments() && !cannotOptimize) {
+            final CachedBoxedDispatchNode dispatchNode = (CachedBoxedDispatchNode) dispatchHead.getFirstDispatchNode();
+
+            if (keywordOptimizedArguments[0] == null) {
+                CompilerDirectives.transferToInterpreter();
+
+                System.err.println("optimizing for keyword arguments!");
+
+                final RubyNode[] optimized = expandedArgumentNodes(dispatchNode.getMethod(), arguments, isSplatted);
+
+                if (optimized == null || optimized.length > keywordOptimizedArguments.length) {
+                    System.err.println("couldn't optimize :(");
+                    cannotOptimize = true;
+                } else {
+                    keywordOptimizedArgumentsLength = optimized.length;
+
+                    for (int n = 0; n < keywordOptimizedArgumentsLength; n++) {
+                        keywordOptimizedArguments[n] = insert(NodeUtil.cloneNode(optimized[n]));
+                    }
+                }
+            }
+
+            if (dispatchNode.guard(methodName, receiverObject) && dispatchNode.getUnmodifiedAssumption().isValid()) {
+                argumentsObjects = executeKeywordOptimizedArguments(frame);
+            } else {
+                argumentsObjects = executeArguments(frame);
+            }
+
+        } else {
+            argumentsObjects = executeArguments(frame);
+        }
+
         final RubyProc blockObject = executeBlock(frame);
 
         return dispatchHead.call(frame, receiverObject, methodName, blockObject, argumentsObjects);
@@ -118,6 +173,21 @@ private Object[] executeArguments(VirtualFrame frame) {
         }
     }
 
+    @ExplodeLoop
+    private Object[] executeKeywordOptimizedArguments(VirtualFrame frame) {
+        final Object[] argumentsObjects = new Object[keywordOptimizedArgumentsLength];
+
+        for (int i = 0; i < keywordOptimizedArgumentsLength; i++) {
+            argumentsObjects[i] = keywordOptimizedArguments[i].execute(frame);
+        }
+
+        if (isSplatted) {
+            return splat(argumentsObjects[0]);
+        } else {
+            return argumentsObjects;
+        }
+    }
+
     private Object[] splat(Object argument) {
         // TODO(CS): what happens if isn't just one argument, or it isn't an Array?
 
@@ -165,6 +235,118 @@ private Object[] splat(Object argument) {
         throw new UnsupportedOperationException();
     }
 
+    public RubyNode[] expandedArgumentNodes(InternalMethod method, RubyNode[] argumentNodes, boolean isSplatted) {
+        final RubyNode[] result;
+
+        boolean shouldExpand = true;
+        if (method == null
+                || method.getSharedMethodInfo().getArity().getKeywordArguments() == null) {
+            // no keyword arguments in method definition
+            shouldExpand = false;
+        } else if (argumentNodes.length != 0
+                && !(argumentNodes[argumentNodes.length - 1] instanceof HashLiteralNode)) {
+            // last argument is not a Hash that could be expanded
+            shouldExpand = false;
+        } else if (method.getSharedMethodInfo().getArity() == null
+                || method.getSharedMethodInfo().getArity().getRequired() >= argumentNodes.length) {
+            shouldExpand = false;
+        } else if (isSplatted
+                || method.getSharedMethodInfo().getArity().allowsMore()) {
+            // TODO: make optimization work if splat arguments are involed
+            // the problem is that Markers and keyword args are used when
+            // reading splatted args
+            shouldExpand = false;
+        }
+
+        if (shouldExpand) {
+            List<String> kwargs = method.getSharedMethodInfo().getArity().getKeywordArguments();
+
+            int countArgNodes = argumentNodes.length + kwargs.size() + 1;
+            if (argumentNodes.length == 0) {
+                countArgNodes++;
+            }
+
+            result = new RubyNode[countArgNodes];
+            int i;
+
+            for (i = 0; i < argumentNodes.length - 1; ++i) {
+                result[i] = argumentNodes[i];
+            }
+
+            int firstMarker = i++;
+            result[firstMarker] = new MarkerNode(getContext(), null);
+
+            HashLiteralNode hashNode;
+            if (argumentNodes.length > 0) {
+                hashNode = (HashLiteralNode) argumentNodes[argumentNodes.length - 1];
+            } else {
+                hashNode = HashLiteralNode.create(getContext(), null,
+                        new RubyNode[0]);
+            }
+
+            List<String> restKeywordLabels = new ArrayList<>();
+            for (int j = 0; j < hashNode.size(); j++) {
+                Object key = hashNode.getKey(j);
+                boolean keyIsSymbol = key instanceof ObjectLiteralNode &&
+                        ((ObjectLiteralNode) key).getObject() instanceof RubySymbol;
+
+                if (!keyIsSymbol) {
+                    // cannot optimize case where keyword label is dynamic (not a fixed RubySymbol)
+                    cannotOptimize = true;
+                    return null;
+                }
+
+                final String label = ((ObjectLiteralNode) hashNode.getKey(j)).getObject().toString();
+                restKeywordLabels.add(label);
+            }
+
+            for (String kwarg : kwargs) {
+                result[i] = new OptionalKeywordArgMissingNode(getContext(), null);
+                for (int j = 0; j < hashNode.size(); j++) {
+                    final String label = ((ObjectLiteralNode) hashNode.getKey(j)).getObject().toString();
+
+                    if (label.equals(kwarg)) {
+                        result[i] = hashNode.getValue(j);
+                        restKeywordLabels.remove(label);
+                        break;
+                    }
+                }
+                i++;
+            }
+            result[i++] = new MarkerNode(getContext(), null);
+
+            if (restKeywordLabels.size() > 0
+                    && !method.getSharedMethodInfo().getArity().hasKeyRest()) {
+                result[firstMarker] = new UnknownArgumentErrorNode(getContext(), null, restKeywordLabels.get(0));
+            } else if (restKeywordLabels.size() > 0) {
+                i = 0;
+                RubyNode[] keyValues = new RubyNode[2 * restKeywordLabels
+                        .size()];
+
+                for (String label : restKeywordLabels) {
+                    for (int j = 0; j < hashNode.size(); j++) {
+                        final String argLabel = ((ObjectLiteralNode) hashNode.getKey(j)).getObject().toString();
+
+                        if (argLabel.equals(label)) {
+                            keyValues[i++] = hashNode.getKey(j);
+                            keyValues[i++] = hashNode.getValue(j);
+                        }
+                    }
+                }
+
+                HashLiteralNode restHash = HashLiteralNode.create(getContext(), null, keyValues);
+                result[firstMarker] = restHash;
+            }
+
+        }
+        else {
+            cannotOptimize = true;
+            result = null;
+        }
+
+        return result;
+    }
+
     @Override
     public Object isDefined(VirtualFrame frame) {
         notDesignedForCompilation();

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/CoreMethodNodeManager.java
@@ -138,7 +138,7 @@ private static RubyRootNode makeGenericMethod(RubyContext context, MethodDetails
             optional = methodDetails.getMethodAnnotation().optional();
         }
 
-        final Arity arity = new Arity(required,  optional, methodDetails.getMethodAnnotation().argumentsAsArray(), false);
+        final Arity arity = new Arity(required,  optional, methodDetails.getMethodAnnotation().argumentsAsArray(), false, false, 0);
 
         final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(sourceSection, null, arity, methodDetails.getIndicativeName(), false, null, true);
 

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/IONodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/IONodes.java
@@ -13,7 +13,6 @@
 import com.oracle.truffle.api.dsl.CreateCast;
 import com.oracle.truffle.api.dsl.NodeChild;
 import com.oracle.truffle.api.dsl.Specialization;
-import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;
 
 import org.jcodings.specific.ASCIIEncoding;
@@ -24,7 +23,6 @@
 import org.jruby.truffle.runtime.control.RaiseException;
 import org.jruby.truffle.runtime.core.RubyArray;
 import org.jruby.truffle.runtime.core.RubyFile;
-import org.jruby.truffle.runtime.core.RubyProc;
 import org.jruby.truffle.runtime.core.RubyString;
 import org.jruby.truffle.runtime.subsystems.ThreadManager;
 import org.jruby.util.ByteList;

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java b/truffle/src/main/java/org/jruby/truffle/nodes/core/ModuleNodes.java
@@ -399,7 +399,7 @@ public RubyNilClass attrReader(RubyModule module, Object[] args) {
         public static void attrReader(Node currentNode, RubyContext context, SourceSection sourceSection, RubyModule module, String name) {
             CompilerDirectives.transferToInterpreter();
 
-            final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, new Arity(0, 0, false, false));
+            final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, new Arity(0, 0, false, false, false, 0));
 
             final SelfNode self = new SelfNode(context, sourceSection);
             final ReadInstanceVariableNode readInstanceVariable = new ReadInstanceVariableNode(context, sourceSection, "@" + name, self, false);
@@ -451,7 +451,7 @@ public RubyNilClass attrWriter(RubyModule module, Object[] args) {
         public static void attrWriter(Node currentNode, RubyContext context, SourceSection sourceSection, RubyModule module, String name) {
             CompilerDirectives.transferToInterpreter();
 
-            final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, new Arity(1, 0, false, false));
+            final CheckArityNode checkArity = new CheckArityNode(context, sourceSection, new Arity(1, 0, false, false, false, 0));
 
             final SelfNode self = new SelfNode(context, sourceSection);
             final ReadPreArgumentNode readArgument = new ReadPreArgumentNode(context, sourceSection, 0, MissingArgumentBehaviour.RUNTIME_ERROR);

diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/CachedBoxedDispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/CachedBoxedDispatchNode.java
@@ -93,7 +93,7 @@ public CachedBoxedDispatchNode(
     }
 
     @Override
-    protected boolean guard(Object methodName, Object receiver) {
+    public boolean guard(Object methodName, Object receiver) {
         return guardName(methodName) &&
                 (receiver instanceof RubyBasicObject) &&
                 ((RubyBasicObject) receiver).getMetaClass() == expectedClass;
@@ -173,4 +173,15 @@ public String toString() {
                 method == null ? "null" : method.toString());
     }
 
+    public boolean couldOptimizeKeywordArguments() {
+        return method.getSharedMethodInfo().getArity().getKeywordArguments() != null && next instanceof UnresolvedDispatchNode;
+    }
+
+    public InternalMethod getMethod() {
+        return method;
+    }
+
+    public Assumption getUnmodifiedAssumption() {
+        return unmodifiedAssumption;
+    }
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/CachedDispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/CachedDispatchNode.java
@@ -13,6 +13,7 @@
 import org.jruby.truffle.runtime.RubyContext;
 import org.jruby.truffle.runtime.core.RubyString;
 import org.jruby.truffle.runtime.core.RubySymbol;
+import org.jruby.truffle.runtime.methods.InternalMethod;
 
 public abstract class CachedDispatchNode extends DispatchNode {
 
@@ -89,5 +90,4 @@ protected RubySymbol getCachedNameAsSymbol() {
     public boolean isIndirect() {
         return indirect;
     }
-
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/DispatchNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/dispatch/DispatchNode.java
@@ -152,4 +152,8 @@ public DispatchAction getDispatchAction() {
         return dispatchAction;
     }
 
+    public boolean couldOptimizeKeywordArguments() {
+        return false;
+    }
+
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/literal/HashLiteralNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/literal/HashLiteralNode.java
@@ -41,6 +41,18 @@ protected HashLiteralNode(RubyContext context, SourceSection sourceSection, Ruby
         freezeNode = DispatchHeadNodeFactory.createMethodCall(context);
     }
 
+    public int size() {
+        return keyValues.length / 2;
+    }
+
+    public RubyNode getKey(int index) {
+        return keyValues[2 * index];
+    }
+
+    public RubyNode getValue(int index) {
+        return keyValues[2 * index + 1];
+    }
+
     public static HashLiteralNode create(RubyContext context, SourceSection sourceSection, RubyNode[] keyValues) {
         if (keyValues.length == 0) {
             return new EmptyHashLiteralNode(context, sourceSection);