jruby · Feb 27, 2016 · Feb 27, 2016 · Feb 27, 2016 · Feb 27, 2016 · Feb 27, 2016
diff --git a/truffle/src/main/java/org/jruby/truffle/core/CoreLibrary.java b/truffle/src/main/java/org/jruby/truffle/core/CoreLibrary.java
@@ -935,6 +935,11 @@ public DynamicObject argumentError(String message, Node currentNode) {
         return argumentError(message, currentNode, null);
     }
 
+    @TruffleBoundary
+    public DynamicObject argumentErrorUnknownKeyword(Object name, Node currentNode) {
+        return argumentError("unknown keyword: " + name, currentNode, null);
+    }
+
     public DynamicObject argumentError(String message, Node currentNode, Throwable javaThrowable) {
         CompilerAsserts.neverPartOfCompilation();
         return ExceptionNodes.createRubyException(argumentErrorClass, StringOperations.createString(context, StringOperations.encodeRope(message, UTF8Encoding.INSTANCE)), context.getCallStack().getBacktrace(currentNode, javaThrowable));
@@ -950,13 +955,13 @@ public DynamicObject argumentErrorInvalidRadix(int radix, Node currentNode) {
         return argumentError(String.format("invalid radix %d", radix), currentNode);
     }
 
+    @TruffleBoundary
     public DynamicObject argumentErrorMissingKeyword(String name, Node currentNode) {
-        CompilerAsserts.neverPartOfCompilation();
         return argumentError(String.format("missing keyword: %s", name), currentNode);
     }
 
+    @TruffleBoundary
     public DynamicObject argumentError(int passed, int required, Node currentNode) {
-        CompilerAsserts.neverPartOfCompilation();
         return argumentError(String.format("wrong number of arguments (%d for %d)", passed, required), currentNode);
     }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/CoreMethodNodeManager.java b/truffle/src/main/java/org/jruby/truffle/core/CoreMethodNodeManager.java
@@ -29,7 +29,7 @@
 import org.jruby.truffle.language.RubyNode;
 import org.jruby.truffle.language.RubyRootNode;
 import org.jruby.truffle.language.arguments.CheckArityNode;
-import org.jruby.truffle.language.arguments.MissingArgumentBehaviour;
+import org.jruby.truffle.language.arguments.MissingArgumentBehavior;
 import org.jruby.truffle.language.arguments.ReadBlockNode;
 import org.jruby.truffle.language.arguments.ReadCallerFrameNode;
 import org.jruby.truffle.language.arguments.ReadPreArgumentNode;
@@ -189,7 +189,7 @@ private static RubyRootNode makeGenericMethod(RubyContext context, MethodDetails
         }
 
         for (int n = 0; n < arity.getPreRequired() + arity.getOptional(); n++) {
-            RubyNode readArgumentNode = new ReadPreArgumentNode(context, sourceSection, n, MissingArgumentBehaviour.UNDEFINED);
+            RubyNode readArgumentNode = new ReadPreArgumentNode(context, sourceSection, n, MissingArgumentBehavior.UNDEFINED);
 
             if (ArrayUtils.contains(method.lowerFixnumParameters(), n)) {
                 readArgumentNode = FixnumLowerNodeGen.create(context, sourceSection, readArgumentNode);
@@ -231,7 +231,7 @@ private static RubyRootNode makeGenericMethod(RubyContext context, MethodDetails
             AmbiguousOptionalArgumentChecker.verifyNoAmbiguousOptionalArguments(methodDetails);
         }
 
-        final RubyNode checkArity = CheckArityNode.create(context, sourceSection, arity);
+        final RubyNode checkArity = new CheckArityNode(context, sourceSection, arity);
         RubyNode sequence = Translator.sequence(context, sourceSection, Arrays.asList(checkArity, methodNode));
 
         if (method.returnsEnumeratorIfNoBlock()) {

diff --git a/...truffle/language/arguments/IsNilNode.java → ...ava/org/jruby/truffle/core/IsNilNode.java b/...truffle/language/arguments/IsNilNode.java → ...ava/org/jruby/truffle/core/IsNilNode.java
@@ -7,7 +7,7 @@
  * GNU General Public License version 2
  * GNU Lesser General Public License version 2.1
  */
-package org.jruby.truffle.language.arguments;
+package org.jruby.truffle.core;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;

diff --git a/...ge/arguments/IsRubiniusUndefinedNode.java → ...truffle/core/IsRubiniusUndefinedNode.java b/...ge/arguments/IsRubiniusUndefinedNode.java → ...truffle/core/IsRubiniusUndefinedNode.java
@@ -7,7 +7,7 @@
  * GNU General Public License version 2
  * GNU Lesser General Public License version 2.1
  */
-package org.jruby.truffle.language.arguments;
+package org.jruby.truffle.core;
 
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.source.SourceSection;

diff --git a/truffle/src/main/java/org/jruby/truffle/core/LoadRequiredLibrariesNode.java b/truffle/src/main/java/org/jruby/truffle/core/LoadRequiredLibrariesNode.java
@@ -34,7 +34,7 @@ public LoadRequiredLibrariesNode(RubyContext context, SourceSection sourceSectio
 
     @Override
     public Object execute(VirtualFrame frame) {
-        Object self = RubyArguments.getSelf(frame.getArguments());
+        Object self = RubyArguments.getSelf(frame);
 
         for (String requiredLibrary : getRequiredLibraries()) {
             requireNode.call(frame, self, "require", null, createString(StringOperations.encodeRope(requiredLibrary, UTF8Encoding.INSTANCE)));

diff --git a/truffle/src/main/java/org/jruby/truffle/core/ReturnEnumeratorIfNoBlockNode.java b/truffle/src/main/java/org/jruby/truffle/core/ReturnEnumeratorIfNoBlockNode.java
@@ -34,16 +34,16 @@ public ReturnEnumeratorIfNoBlockNode(String methodName, RubyNode method) {
 
     @Override
     public Object execute(VirtualFrame frame) {
-        final DynamicObject block = RubyArguments.getBlock(frame.getArguments());
+        final DynamicObject block = RubyArguments.getBlock(frame);
 
         if (noBlockProfile.profile(block == null)) {
             if (toEnumNode == null) {
                 CompilerDirectives.transferToInterpreter();
                 toEnumNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
             }
 
-            final Object[] arguments = ArrayUtils.unshift(RubyArguments.getArguments(frame.getArguments()), getSymbol(methodName));
-            return toEnumNode.call(frame, RubyArguments.getSelf(frame.getArguments()), "to_enum", null, arguments);
+            final Object[] arguments = ArrayUtils.unshift(RubyArguments.getArguments(frame), getSymbol(methodName));
+            return toEnumNode.call(frame, RubyArguments.getSelf(frame), "to_enum", null, arguments);
 
         } else {
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/array/ArrayNodes.java b/truffle/src/main/java/org/jruby/truffle/core/array/ArrayNodes.java
@@ -69,7 +69,7 @@
 import org.jruby.truffle.language.RubyGuards;
 import org.jruby.truffle.language.RubyNode;
 import org.jruby.truffle.language.RubyRootNode;
-import org.jruby.truffle.language.arguments.MissingArgumentBehaviour;
+import org.jruby.truffle.language.arguments.MissingArgumentBehavior;
 import org.jruby.truffle.language.arguments.ReadPreArgumentNode;
 import org.jruby.truffle.language.arguments.RubyArguments;
 import org.jruby.truffle.language.control.RaiseException;
@@ -436,7 +436,7 @@ public Object fallback(VirtualFrame frame, DynamicObject array, DynamicObject ar
                 fallbackNode = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
             }
 
-            InternalMethod method = RubyArguments.getMethod(frame.getArguments());
+            InternalMethod method = RubyArguments.getMethod(frame);
             return fallbackNode.call(frame, array, "element_reference_fallback", null,
                     createString(StringOperations.encodeRope(method.getName(), UTF8Encoding.INSTANCE)), args);
         }
@@ -1899,7 +1899,7 @@ public Object insert(VirtualFrame frame, DynamicObject array, int idx, int value
 
         @Specialization
         public Object insertBoxed(VirtualFrame frame, DynamicObject array, Object idxObject, Object unusedValue, Object[] unusedRest) {
-            final Object[] values = RubyArguments.getArguments(frame.getArguments(), 1);
+            final Object[] values = RubyArguments.getArguments(frame, 1);
             final int idx = toInt(frame, idxObject);
 
             CompilerDirectives.transferToInterpreter();
@@ -2166,7 +2166,7 @@ public Object max(VirtualFrame frame, DynamicObject array, NotProvided blockNotP
 
             final Memo<Object> maximum = new Memo<>();
 
-            final InternalMethod method = RubyArguments.getMethod(frame.getArguments());
+            final InternalMethod method = RubyArguments.getMethod(frame);
             final VirtualFrame maximumClosureFrame = Truffle.getRuntime().createVirtualFrame(
                     RubyArguments.pack(null, null, method, DeclarationContext.BLOCK, null, array, null, new Object[]{}), maxBlock.getFrameDescriptor());
             maximumClosureFrame.setObject(maxBlock.getFrameSlot(), maximum);
@@ -2245,7 +2245,7 @@ public MaxBlock(RubyContext context) {
 
             callTarget = Truffle.getRuntime().createCallTarget(new RubyRootNode(context, sourceSection, null, sharedMethodInfo, ArrayNodesFactory.MaxBlockNodeFactory.create(context, sourceSection, new RubyNode[]{
                                         new ReadDeclarationVariableNode(context, sourceSection, LocalVariableType.FRAME_LOCAL, 1, frameSlot),
-                                        new ReadPreArgumentNode(context, sourceSection, 0, MissingArgumentBehaviour.RUNTIME_ERROR)
+                                        new ReadPreArgumentNode(context, sourceSection, 0, MissingArgumentBehavior.RUNTIME_ERROR)
                                 }), false));
         }
 
@@ -2284,7 +2284,7 @@ public Object min(VirtualFrame frame, DynamicObject array, NotProvided blockNotP
 
             final Memo<Object> minimum = new Memo<>();
 
-            final InternalMethod method = RubyArguments.getMethod(frame.getArguments());
+            final InternalMethod method = RubyArguments.getMethod(frame);
             final VirtualFrame minimumClosureFrame = Truffle.getRuntime().createVirtualFrame(
                     RubyArguments.pack(null, null, method, DeclarationContext.BLOCK, null, array, null, new Object[]{}), minBlock.getFrameDescriptor());
             minimumClosureFrame.setObject(minBlock.getFrameSlot(), minimum);
@@ -2363,7 +2363,7 @@ public MinBlock(RubyContext context) {
 
             callTarget = Truffle.getRuntime().createCallTarget(new RubyRootNode(context, sourceSection, null, sharedMethodInfo, ArrayNodesFactory.MinBlockNodeFactory.create(context, sourceSection, new RubyNode[]{
                                         new ReadDeclarationVariableNode(context, sourceSection, LocalVariableType.FRAME_LOCAL, 1, frameSlot),
-                                        new ReadPreArgumentNode(context, sourceSection, 0, MissingArgumentBehaviour.RUNTIME_ERROR)
+                                        new ReadPreArgumentNode(context, sourceSection, 0, MissingArgumentBehavior.RUNTIME_ERROR)
                                 }), false));
         }
 
@@ -2915,15 +2915,15 @@ public DynamicObject pushNullEmptySingleIntegerLong(DynamicObject array, long va
 
         @Specialization(guards = "isNullArray(array)")
         public DynamicObject pushNullEmptyObjects(VirtualFrame frame, DynamicObject array, Object unusedValue, Object[] unusedRest) {
-            final Object[] values = RubyArguments.getArguments(frame.getArguments());
+            final Object[] values = RubyArguments.getArguments(frame);
             setStoreAndSize(array, values, values.length);
             return array;
         }
 
         @Specialization(guards = { "!isNullArray(array)", "isEmptyArray(array)" })
         public DynamicObject pushEmptySingleIntegerFixnum(VirtualFrame frame, DynamicObject array, Object unusedValue, Object[] unusedRest) {
             // TODO CS 20-Apr-15 in reality might be better reusing any current storage, but won't worry about that for now
-            final Object[] values = RubyArguments.getArguments(frame.getArguments());
+            final Object[] values = RubyArguments.getArguments(frame);
             setStoreAndSize(array, values, values.length);
             return array;
         }
@@ -2967,7 +2967,7 @@ public DynamicObject pushIntegerFixnumSingleOther(DynamicObject array, Object va
 
         @Specialization(guards = { "isIntArray(array)", "wasProvided(value)", "rest.length != 0" })
         public DynamicObject pushIntegerFixnum(VirtualFrame frame, DynamicObject array, Object value, Object[] rest) {
-            final Object[] values = RubyArguments.getArguments(frame.getArguments());
+            final Object[] values = RubyArguments.getArguments(frame);
 
             final int oldSize = getSize(array);
             final int newSize = oldSize + values.length;
@@ -3031,14 +3031,14 @@ public DynamicObject pushFloat(VirtualFrame frame, DynamicObject array, Object u
                 throw new UnsupportedOperationException();
             }
 
-            final Object[] values = RubyArguments.getArguments(frame.getArguments());
+            final Object[] values = RubyArguments.getArguments(frame);
             setStoreAndSize(array, values, values.length);
             return array;
         }
 
         @Specialization(guards = "isObjectArray(array)")
         public DynamicObject pushObject(VirtualFrame frame, DynamicObject array, Object unusedValue, Object[] unusedRest) {
-            final Object[] values = RubyArguments.getArguments(frame.getArguments());
+            final Object[] values = RubyArguments.getArguments(frame);
 
             final int oldSize = getSize(array);
             final int newSize = oldSize + values.length;
@@ -4293,7 +4293,7 @@ private Object zipRuby(VirtualFrame frame, DynamicObject array, DynamicObject bl
                 zipInternalCall = insert(DispatchHeadNodeFactory.createMethodCall(getContext()));
             }
 
-            final Object[] others = RubyArguments.getArguments(frame.getArguments());
+            final Object[] others = RubyArguments.getArguments(frame);
 
             return zipInternalCall.call(frame, array, "zip_internal", block, others);
         }

diff --git a/truffle/src/main/java/org/jruby/truffle/core/binding/BindingNodes.java b/truffle/src/main/java/org/jruby/truffle/core/binding/BindingNodes.java
@@ -98,7 +98,7 @@ public static FrameSlotAndDepth findFrameSlotOrNull(DynamicObject binding, Dynam
                 return new FrameSlotAndDepth(frameSlot, depth);
             }
 
-            frame = RubyArguments.getDeclarationFrame(frame.getArguments());
+            frame = RubyArguments.getDeclarationFrame(frame);
             depth++;
         }
         return null;
@@ -321,7 +321,7 @@ public static DynamicObject listLocalVariables(RubyContext context, Frame frame)
                     }
                 }
 
-                frame = RubyArguments.getDeclarationFrame(frame.getArguments());
+                frame = RubyArguments.getDeclarationFrame(frame);
             }
             final int size = names.size();
             return ArrayHelpers.createArray(context, names.toArray(new Object[size]), size);

diff --git a/truffle/src/main/java/org/jruby/truffle/core/cast/TaintResultNode.java b/truffle/src/main/java/org/jruby/truffle/core/cast/TaintResultNode.java
@@ -77,13 +77,13 @@ public Object execute(VirtualFrame frame) {
 
         if (result != nil()) {
             if (taintFromSelf) {
-                maybeTaint((DynamicObject) RubyArguments.getSelf(frame.getArguments()), result);
+                maybeTaint((DynamicObject) RubyArguments.getSelf(frame), result);
             }
 
             // It's possible the taintFromParameter value was misconfigured by the user, but the far more likely
             // scenario is that the argument at that position is a NotProvided argument, which doesn't take up
             // a space in the frame.
-            if (taintFromParameter < RubyArguments.getArgumentsCount(frame.getArguments())) {
+            if (taintFromParameter < RubyArguments.getArgumentsCount(frame)) {
                 final Object argument = RubyArguments.getArgument(frame.getArguments(), taintFromParameter);
 
                 if (argument instanceof DynamicObject) {

diff --git a/truffle/src/main/java/org/jruby/truffle/core/hash/HashNodes.java b/truffle/src/main/java/org/jruby/truffle/core/hash/HashNodes.java
@@ -605,7 +605,7 @@ public Object each(VirtualFrame frame, DynamicObject hash, NotProvided block) {
                 toEnumNode = insert(DispatchHeadNodeFactory.createMethodCallOnSelf(getContext()));
             }
 
-            InternalMethod method = RubyArguments.getMethod(frame.getArguments());
+            InternalMethod method = RubyArguments.getMethod(frame);
             return toEnumNode.call(frame, hash, "to_enum", null, getSymbol(method.getName()));
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/kernel/KernelNodes.java b/truffle/src/main/java/org/jruby/truffle/core/kernel/KernelNodes.java
@@ -581,7 +581,7 @@ public Object evalNoBindingCached(
             final DynamicObject callerBinding = getCallerBinding(frame);
 
             final MaterializedFrame parentFrame = Layouts.BINDING.getFrame(callerBinding);
-            final Object callerSelf = RubyArguments.getSelf(frame.getArguments());
+            final Object callerSelf = RubyArguments.getSelf(frame);
 
             final InternalMethod method = new InternalMethod(
                     cachedRootNode.getRootNode().getSharedMethodInfo(),
@@ -600,7 +600,7 @@ public Object evalNoBindingUncached(VirtualFrame frame, DynamicObject source, No
                                             NotProvided filename, NotProvided lineNumber) {
             final DynamicObject binding = getCallerBinding(frame);
             final MaterializedFrame topFrame = Layouts.BINDING.getFrame(binding);
-            RubyArguments.setSelf(topFrame.getArguments(), RubyArguments.getSelf(frame.getArguments()));
+            RubyArguments.setSelf(topFrame.getArguments(), RubyArguments.getSelf(frame));
             return doEval(source, binding, "(eval)", true);
         }
 
@@ -1321,9 +1321,9 @@ public CallMethodMissingWithStaticName(RubyContext context, SourceSection source
 
             @Override
             public Object execute(VirtualFrame frame) {
-                final Object[] originalUserArguments = RubyArguments.getArguments(frame.getArguments());
+                final Object[] originalUserArguments = RubyArguments.getArguments(frame);
                 final Object[] newUserArguments = ArrayUtils.unshift(originalUserArguments, methodName);
-                return methodMissing.call(frame, RubyArguments.getSelf(frame.getArguments()), "method_missing", RubyArguments.getBlock(frame.getArguments()), newUserArguments);
+                return methodMissing.call(frame, RubyArguments.getSelf(frame), "method_missing", RubyArguments.getBlock(frame), newUserArguments);
             }
         }
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/kernel/TraceManager.java b/truffle/src/main/java/org/jruby/truffle/core/kernel/TraceManager.java
@@ -239,9 +239,9 @@ private void callSetTraceFunc(Node node, MaterializedFrame frame) {
                 return;
             }
 
-            final Object self = RubyArguments.getSelf(frame.getArguments());
+            final Object self = RubyArguments.getSelf(frame);
             final Object classname = context.getCoreLibrary().getLogicalClass(self);
-            final Object id = context.getSymbolTable().getSymbol(RubyArguments.getMethod(frame.getArguments()).getName());
+            final Object id = context.getSymbolTable().getSymbol(RubyArguments.getMethod(frame).getName());
 
             final DynamicObject binding = Layouts.BINDING.createBinding(context.getCoreLibrary().getBindingFactory(), Truffle.getRuntime().getCallerFrame().getFrame(FrameInstance.FrameAccess.MATERIALIZE, true).materialize());
 

diff --git a/truffle/src/main/java/org/jruby/truffle/core/module/ModuleNodes.java b/truffle/src/main/java/org/jruby/truffle/core/module/ModuleNodes.java
@@ -66,7 +66,7 @@
 import org.jruby.truffle.language.RubyNode;
 import org.jruby.truffle.language.RubyRootNode;
 import org.jruby.truffle.language.arguments.CheckArityNode;
-import org.jruby.truffle.language.arguments.MissingArgumentBehaviour;
+import org.jruby.truffle.language.arguments.MissingArgumentBehavior;
 import org.jruby.truffle.language.arguments.ReadPreArgumentNode;
 import org.jruby.truffle.language.arguments.RubyArguments;
 import org.jruby.truffle.language.constants.ReadConstantNode;
@@ -421,15 +421,15 @@ public DynamicObject generateAccessor(VirtualFrame frame, DynamicObject module,
             final String accessorName = isGetter ? name : name + "=";
             final String indicativeName = name + "(attr_" + (isGetter ? "reader" : "writer") + ")";
 
-            final RubyNode checkArity = CheckArityNode.create(getContext(), sourceSection, arity);
+            final RubyNode checkArity = new CheckArityNode(getContext(), sourceSection, arity);
             final SharedMethodInfo sharedMethodInfo = new SharedMethodInfo(sourceSection, LexicalScope.NONE, arity, indicativeName, false, null, false, false, false);
 
             final SelfNode self = new SelfNode(getContext(), sourceSection);
             final RubyNode accessInstanceVariable;
             if (isGetter) {
                 accessInstanceVariable = new ReadInstanceVariableNode(getContext(), sourceSection, ivar, self);
             } else {
-                ReadPreArgumentNode readArgument = new ReadPreArgumentNode(getContext(), sourceSection, 0, MissingArgumentBehaviour.RUNTIME_ERROR);
+                ReadPreArgumentNode readArgument = new ReadPreArgumentNode(getContext(), sourceSection, 0, MissingArgumentBehavior.RUNTIME_ERROR);
                 accessInstanceVariable = new WriteInstanceVariableNode(getContext(), sourceSection, ivar, self, readArgument);
             }
             final RubyNode sequence = Translator.sequence(getContext(), sourceSection, Arrays.asList(checkArity, accessInstanceVariable));

diff --git a/truffle/src/main/java/org/jruby/truffle/core/regexp/RegexpNodes.java b/truffle/src/main/java/org/jruby/truffle/core/regexp/RegexpNodes.java
@@ -218,7 +218,7 @@ private static void setLocalVariable(Frame frame, String name, Object value) {
                 break;
             }
 
-            frame = RubyArguments.getDeclarationFrame(frame.getArguments());
+            frame = RubyArguments.getDeclarationFrame(frame);
         }
     }