fix spread call wrapping for dgm helper and implement missing post/pr…

…efix code part for indy

src/main/org/codehaus/groovy/classgen/asm/InvocationWriter.java

@@ -29,11 +29,11 @@
 
 public class InvocationWriter {
     // method invocation
-    protected static final MethodCallerMultiAdapter invokeMethodOnCurrent = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethodOnCurrent", true, false);
-    protected static final MethodCallerMultiAdapter invokeMethodOnSuper = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethodOnSuper", true, false);
-    protected static final MethodCallerMultiAdapter invokeMethod = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethod", true, false);
-    protected static final MethodCallerMultiAdapter invokeStaticMethod = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeStaticMethod", true, true);
-    protected static final MethodCaller invokeClosureMethod = MethodCaller.newStatic(ScriptBytecodeAdapter.class, "invokeClosure");
+    public static final MethodCallerMultiAdapter invokeMethodOnCurrent = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethodOnCurrent", true, false);
+    public static final MethodCallerMultiAdapter invokeMethodOnSuper = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethodOnSuper", true, false);
+    public static final MethodCallerMultiAdapter invokeMethod = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeMethod", true, false);
+    public static final MethodCallerMultiAdapter invokeStaticMethod = MethodCallerMultiAdapter.newStatic(ScriptBytecodeAdapter.class, "invokeStaticMethod", true, true);
+    public static final MethodCaller invokeClosureMethod = MethodCaller.newStatic(ScriptBytecodeAdapter.class, "invokeClosure");
 
     private WriterController controller;
 

src/main/org/codehaus/groovy/classgen/asm/WriterController.java

@@ -36,18 +36,21 @@
 
 public class WriterController {
 
-    private static Constructor indyWriter, indyCallSiteWriter;
+    private static Constructor indyWriter, indyCallSiteWriter, indyBinHelper;
     static {
         try {
             ClassLoader cl = WriterController.class.getClassLoader();
             Class indyClass = cl.loadClass("org.codehaus.groovy.classgen.asm.indy.InvokeDynamicWriter");
             indyWriter = indyClass.getConstructor(WriterController.class);
             indyClass = cl.loadClass("org.codehaus.groovy.classgen.asm.indy.IndyCallSiteWriter");
             indyCallSiteWriter = indyClass.getConstructor(WriterController.class);
+            indyClass = cl.loadClass("org.codehaus.groovy.classgen.asm.indy.IndyBinHelper");
+            indyBinHelper = indyClass.getConstructor(WriterController.class);
         } catch (Exception e) {
             indyWriter = null;
             indyCallSiteWriter = null;
-        }        
+            indyBinHelper = null;
+        }
     }
     private AsmClassGenerator acg;
     private MethodVisitor methodVisitor;
@@ -99,15 +102,16 @@ public void init(AsmClassGenerator asmClassGenerator, GeneratorContext gcon, Cla
             try {
                 this.invocationWriter = (InvocationWriter) indyWriter.newInstance(this);
                 this.callSiteWriter = (CallSiteWriter) indyCallSiteWriter.newInstance(this);
+                this.binaryExpHelper = (BinaryExpressionHelper) indyBinHelper.newInstance(this);
             } catch (Exception e) {
                 throw new GroovyRuntimeException("Cannot use invokedynamic, indy module was excluded from this build.");
             }
         } else {
             this.callSiteWriter = new CallSiteWriter(this);
             this.invocationWriter = new InvocationWriter(this);
+            this.binaryExpHelper = new BinaryExpressionHelper(this);
         }
 
-        this.binaryExpHelper = new BinaryExpressionHelper(this);
         this.unaryExpressionHelper = new UnaryExpressionHelper(this);
         if (optimizeForInt) {
             this.fastPathBinaryExpHelper = new BinaryExpressionMultiTypeDispatcher(this);

src/main/org/codehaus/groovy/classgen/asm/indy/IndyBinHelper.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2003-2012 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.codehaus.groovy.classgen.asm.indy;
+
+import org.codehaus.groovy.ast.expr.ConstantExpression;
+import org.codehaus.groovy.ast.expr.EmptyExpression;
+import org.codehaus.groovy.ast.expr.Expression;
+import org.codehaus.groovy.ast.expr.MethodCallExpression;
+import org.codehaus.groovy.classgen.asm.BinaryExpressionHelper;
+import org.codehaus.groovy.classgen.asm.InvocationWriter;
+import org.codehaus.groovy.classgen.asm.WriterController;
+
+public class IndyBinHelper extends BinaryExpressionHelper {
+
+    public IndyBinHelper(WriterController wc) {
+        super(wc);
+    }
+
+    @Override
+    protected void writePostOrPrefixMethod(int op, String method, Expression expression, Expression orig) {
+        getController().getInvocationWriter().makeCall(
+                orig, EmptyExpression.INSTANCE, 
+                new ConstantExpression(method), 
+                MethodCallExpression.NO_ARGUMENTS, 
+                InvocationWriter.invokeMethod, 
+                false, false, false);
+    }
+}

src/main/org/codehaus/groovy/vmplugin/v7/Selector.java

@@ -52,7 +52,7 @@
 import static org.codehaus.groovy.vmplugin.v7.IndyInterface.*;
 
 public abstract class Selector {
-    public Object[] args;
+    public Object[] args, originalArguments;
     public MetaMethod method;
     public MethodType targetType,currentType;
     public String name;
@@ -62,6 +62,7 @@ public abstract class Selector {
     public Class sender;
     public boolean isVargs;
     public boolean safeNavigation, safeNavigationOrig, spread, genericInvoker;
+    public boolean skipSpreadCollector;
     public boolean thisCall;
     public Class selectionBase;
     public boolean catchException = true;
@@ -243,6 +244,7 @@ public MethodSelector(MutableCallSite callSite, Class sender, String methodName,
             this.callType = callType;
             this.targetType = callSite.type();
             this.name = methodName;
+            this.originalArguments = arguments;
             this.args = spread(arguments, spreadCall);
             this.callSite = callSite;
             this.sender = sender;
@@ -374,9 +376,11 @@ public void setHandleForMetaMethod() {
                 handle = META_METHOD_INVOKER;
                 handle = handle.bindTo(method);
                 if (LOG_ENABLED) LOG.info("bound method name to META_METHOD_INVOKER");
-                if (method.getNativeParameterTypes().length==1 && 
-                        args.length==1) 
-                {
+
+                if (
+                        method.getNativeParameterTypes().length==1 && 
+                        args.length==1 
+                ) {
                     // the method expects a parameter but we don't provide an 
                     // argument for that. So we give in a Object[], containing 
                     // a null value
@@ -386,7 +390,7 @@ public void setHandleForMetaMethod() {
                     // another one for the vargs call
                     handle = MethodHandles.insertArguments(handle, 1, new Object[]{new Object[]{null}});
                     if (LOG_ENABLED) LOG.info("null argument expansion");
-                } else if (method.isVargsMethod()) {
+                } else if (method.isVargsMethod() && !spread) {
                     // the method expects the arguments as Object[] in a Object[]
                     handle = handle.asCollector(Object[].class, 1);
                     handle = handle.asCollector(Object[].class, targetType.parameterCount()-1);
@@ -397,6 +401,10 @@ public void setHandleForMetaMethod() {
                     handle = handle.asCollector(Object[].class, targetType.parameterCount()-1);
                     currentType = MethodType.methodType(method.getReturnType(), method.getNativeParameterTypes());
                     currentType = currentType.insertParameterTypes(0, method.getDeclaringClass().getTheClass());
+                    if (spread) {
+                        args = originalArguments;
+                        skipSpreadCollector = true;
+                    }
                     if (LOG_ENABLED) LOG.info("normal dgm helper wrapping");
                 }
             }
@@ -561,7 +569,7 @@ public void correctNullReceiver() {
         }
 
         public void correctSpreading() {
-            if (!spread || useMetaClass) return;
+            if (!spread || useMetaClass || skipSpreadCollector) return;
             handle = handle.asSpreader(Object[].class, args.length-1);
         }