Special-case one object arg case of invocation.

Many method invocations where no extra parameters look like this, such
as almost all grammar rule invocations.

Author: jnthn

src/vm/jvm/QAST/Compiler.nqp

@@ -3295,7 +3295,7 @@ class QAST::CompilerJAST {
             if $node.custom_args {
                 $*JMETH.add_argument('__args', "[$TYPE_OBJ");
             }
-            elsif !self.try_setup_args_expectation($*JMETH, $block) {
+            elsif !self.try_setup_args_expectation($*JMETH, $block, $il) {
                 # Analyze parameters to get count of required/optional and make sure
                 # all is in order.
                 my int $pos_required := 0;
@@ -3642,19 +3642,49 @@ class QAST::CompilerJAST {
 
     my $ARG_EXP_USE_BINDER := 0;
     my $ARG_EXP_NO_ARGS    := 1;
-    method try_setup_args_expectation($jmeth, $block) {
+    my $ARG_EXP_OBJ        := 2;
+    method try_setup_args_expectation($jmeth, $block, $il) {
         # Needing an args array forces the binder.
         if $*NEED_ARGS_ARRAY {
             return $ARG_EXP_USE_BINDER;
         }
 
         # Otherwise, go by arity, then look at particular cases.
-        my $num_params := $block.params;
+        my int $num_params := +$block.params;
         if $num_params == 0 {
             # Easy; just don't add any extra args in.
             $jmeth.args_expectation($ARG_EXP_NO_ARGS);
             return $ARG_EXP_NO_ARGS;
         }
+        elsif $num_params == 1 {
+            # Look for one required positional case. Methods with no params
+            # beyond the invocant are always this.
+            my $param := $block.params[0];
+            if !$param.named && !$param.slurpy && !$param.default {
+                if nqp::objprimspec($param.returns) == 0 {
+                    $jmeth.add_argument('__arg_0', $TYPE_SMO);
+                    $il.append(JAST::Instruction.new( :op('aload'), '__arg_0' ));
+                    if $param.scope eq 'local' {
+                        $il.append(JAST::Instruction.new( :op('astore'), $param.name ));
+                    }
+                    else {
+                        $il.append(JAST::Instruction.new( :op('aload'), 'cf' ));
+                        $il.append(JAST::PushIndex.new( :value($block.lexical_idx($param.name)) ));
+                        $il.append(JAST::Instruction.new( :op('invokestatic'), $TYPE_OPS,
+                            'bindlex_o', $TYPE_SMO, $TYPE_SMO, $TYPE_CF, 'Integer' ));
+                        $il.append($POP);
+                    }
+                    $jmeth.args_expectation($ARG_EXP_OBJ);
+                    return $ARG_EXP_OBJ;
+                }
+                else {
+                    return $ARG_EXP_USE_BINDER;
+                }
+            }
+            else {
+                return $ARG_EXP_USE_BINDER;
+            }
+        }
         else {
             return $ARG_EXP_USE_BINDER;
         }

src/vm/jvm/runtime/org/perl6/nqp/runtime/ArgsExpectation.java

@@ -1,5 +1,7 @@
 package org.perl6.nqp.runtime;
 
+import org.perl6.nqp.sixmodel.*;
+
 /* Argument expectations are used to indicate what, exactly, a block we are
  * invoking expects. The default is that it wants the args in an Object[] and
  * will use the binder to process them specially. We special-case various of
@@ -9,6 +11,7 @@
 public class ArgsExpectation {
     public static final short USE_BINDER = 0;
     public static final short NO_ARGS    = 1;
+    public static final short OBJ        = 2;
 
     public static void invokeByExpectation(ThreadContext tc, CodeRef cr,
             CallSiteDescriptor csd, Object[] args) throws Throwable {
@@ -19,14 +22,56 @@ public static void invokeByExpectation(ThreadContext tc, CodeRef cr,
         case ArgsExpectation.NO_ARGS:
             if (csd.argFlags.length != 0) {
                 // Probable error, but consider flattening.
-                csd = csd.explodeFlattening(tc.curFrame, args);
+                if (csd.hasFlattening)
+                    csd = csd.explodeFlattening(tc.curFrame, args);
                 if (csd.argFlags.length != 0)
                     ExceptionHandling.dieInternal(tc,
                         "Wrong number of arguments passed; expected 0..0, but got " +
                         csd.numPositionals);
             }
             cr.staticInfo.mh.invokeExact(tc, cr, csd);
             break;
+        case ArgsExpectation.OBJ:
+            if (csd.argFlags.length == 1 && csd.argFlags[0] == CallSiteDescriptor.ARG_OBJ) {
+                /* Simple, common case. */
+                cr.staticInfo.mh.invokeExact(tc, cr, csd, (SixModelObject)args[0]);
+            }
+            else {
+                /* Flatten if needed. */
+                if (csd.hasFlattening) {
+                    csd = csd.explodeFlattening(tc.curFrame, args);
+                    args = tc.flatArgs;
+                }
+                if (csd.argFlags.length == 1) {
+                    switch (csd.argFlags[0]) {
+                    case CallSiteDescriptor.ARG_OBJ:
+                        cr.staticInfo.mh.invokeExact(tc, cr, csd, (SixModelObject)args[0]);
+                        break;
+                    case CallSiteDescriptor.ARG_INT:
+                        cr.staticInfo.mh.invokeExact(tc, cr, csd, Ops.box_i(
+                            (long)args[0], cr.staticInfo.compUnit.hllConfig.intBoxType, tc));
+                        break;
+                    case CallSiteDescriptor.ARG_NUM:
+                        cr.staticInfo.mh.invokeExact(tc, cr, csd, Ops.box_n(
+                            (double)args[0], cr.staticInfo.compUnit.hllConfig.numBoxType, tc));
+                        break;
+                    case CallSiteDescriptor.ARG_STR:
+                        cr.staticInfo.mh.invokeExact(tc, cr, csd, Ops.box_s(
+                            (String)args[0], cr.staticInfo.compUnit.hllConfig.strBoxType, tc));
+                        break;
+                    default:
+                        ExceptionHandling.dieInternal(tc,
+                            "Wrong number of arguments passed; expected 1..1, but got " +
+                            csd.numPositionals);
+                    }
+                }
+                else {
+                    ExceptionHandling.dieInternal(tc,
+                        "Wrong number of arguments passed; expected 1..1, but got " +
+                        csd.numPositionals);
+                }
+            }
+            break;
         default:
             ExceptionHandling.dieInternal(tc, "Unknown Argument Expectation in invoke");
         }

src/vm/jvm/runtime/org/perl6/nqp/runtime/IndyBootstrap.java

@@ -408,7 +408,7 @@ public static void methcallResolve_noa(Lookup caller, MutableCallSite cs, String
 
         /* Make the call directly for this initial call. */
         try {
-            cr.staticInfo.mh.invokeExact(tc, cr, csd, args);
+            ArgsExpectation.invokeByExpectation(tc, cr, csd, args);
         }
         catch (ControlException e) {
             throw e;
@@ -482,7 +482,7 @@ public static void indmethcallInvoker_noa(MutableCallSite cs, int csIdx,
 
         /* Make the call. */
         try {
-            cr.staticInfo.mh.invokeExact(tc, cr, csd, args);
+            ArgsExpectation.invokeByExpectation(tc, cr, csd, args);
         }
         catch (ControlException e) {
             throw e;

src/vm/jvm/runtime/org/perl6/nqp/runtime/StaticCodeInfo.java

@@ -184,6 +184,9 @@ else if (t.parameterCount() >= 4 && (t.parameterType(3) == ResumeStatus.Frame.cl
             case ArgsExpectation.NO_ARGS:
                 /* Nothing to insert. */
                 break;
+            case ArgsExpectation.OBJ:
+                mhResume = MethodHandles.insertArguments(mhResume, 1, (SixModelObject)null);
+                break;
             default:
                 throw new RuntimeException("Unhandled ArgsExpectation in StaticCodeInfo");
             }