MethodHandle.java.diff

--- jdk_MethodHandle.java       2017-01-14 12:15:24.000000000 +0100
+++ "src\\java\\lang\\invoke\\MethodHandle.java"        2017-01-14 17:09:49.224884600 +0100
@@ -29,6 +29,7 @@
 import java.util.*;

 import static java.lang.invoke.MethodHandleStatics.*;
+import static java.lang.invoke.MethodType.methodType;

 /**
  * A method handle is a typed, directly executable reference to an underlying method,
@@ -623,10 +624,68 @@
      * @see MethodHandles#spreadInvoker
      */
     public Object invokeWithArguments(Object... arguments) throws Throwable {
-        MethodType invocationType = MethodType.genericMethodType(arguments == null ? 0 : arguments.length);
-        return invocationType.invokers().spreadInvoker(0).invokeExact(asType(invocationType), arguments);
+        if(spreaderCache == null)
+            return setupSpreader(arguments);
+        return spreaderCache.invokeBasic(this, arguments);
     }
-
+
+    private @Stable MethodHandle spreaderCache;
+
+    private Object setupSpreader(Object... arguments) throws Throwable {
+        MethodHandle mh;
+
+        if (isVarargsCollector()) {
+            mh = VarargsSupport.MH_invokeVarargs.bindTo(
+                    new VarargsSupport(arguments.length+5));
+        } else {
+            // fast-path for fixed-arity method handles
+            MethodType invocationType = MethodType.genericMethodType(type.parameterCount());
+            mh = invocationType.invokers().spreadInvoker(0);
+        }
+
+        spreaderCache = mh;
+        return mh.invokeExact(this, arguments);
+    }
+
+    // a cache for spreadInvokers, keyed by the argument count
+    private static class VarargsSupport {
+
+        public static final MethodHandle MH_invokeVarargs;
+
+        static {
+            try {
+                MH_invokeVarargs = MethodHandles.Lookup.IMPL_LOOKUP.
+                        findVirtual(VarargsSupport.class, "invokeVarargs",
+                                methodType(Object.class, MethodHandle.class, Object[].class));
+            } catch (Exception ex) {
+                throw new InternalError(ex);
+            }
+        }
+
+        private MethodHandle[] spreaders;
+
+        public VarargsSupport(int initialCapacity) {
+            spreaders = new MethodHandle[initialCapacity];
+        }
+
+        private Object invokeVarargs(MethodHandle mh, Object... arguments)
+                throws Throwable {
+            int n = arguments.length;
+            if (n >= spreaders.length) {
+                MethodHandle[] bigger = new MethodHandle[spreaders.length*2];
+                System.arraycopy(spreaders, 0, bigger, 0, spreaders.length);
+                this.spreaders = bigger;
+            }
+
+            MethodHandle spreadInvoker = spreaders[n];
+            if(spreadInvoker == null) {
+                MethodType invocationType = MethodType.genericMethodType(n);
+                spreadInvoker = spreaders[n] = invocationType.invokers().spreadInvoker(0);
+            }
+            return spreadInvoker.invokeExact(mh, arguments);
+        }
+    }
+
     /**
      * Performs a variable arity invocation, passing the arguments in the given array
      * to the method handle, as if via an inexact {@link #invoke invoke} from a call site