Switch from mixin to static method calls

Author: Vampire

spock-core/src/main/java/org/spockframework/compiler/AstNodeCache.java

@@ -42,6 +42,7 @@ public class AstNodeCache {
   public final ClassNode ErrorRethrower = ClassHelper.makeWithoutCaching(ErrorRethrower.class);
   public final ClassNode Specification = ClassHelper.makeWithoutCaching(Specification.class);
   public final ClassNode SpecInternals = ClassHelper.makeWithoutCaching(SpecInternals.class);
+  public final ClassNode SpecialMethodCallTarget = ClassHelper.makeWithoutCaching(SpecialMethodCallTarget.class);
   public final ClassNode MockController = ClassHelper.makeWithoutCaching(MockController.class);
   public final ClassNode SpecificationContext = ClassHelper.makeWithoutCaching(SpecificationContext.class);
   public final ClassNode DataVariableMultiplication = ClassHelper.makeWithoutCaching(DataVariableMultiplication.class);

spock-core/src/main/java/org/spockframework/compiler/DeepBlockRewriter.java

@@ -289,6 +289,7 @@ private boolean handleOldCall(MethodCallExpression expr) {
       return true;
     }
 
+    expr.setObjectExpression(new ClassExpression(resources.getAstNodeCache().SpecialMethodCallTarget));
     expr.setMethod(new ConstantExpression(expr.getMethodAsString() + "Impl"));
     List<Expression> args = AstUtil.getArgumentList(expr);
     if (args.size() != 1) {

spock-core/src/main/java/org/spockframework/compiler/SpecialMethodCall.java

@@ -45,17 +45,19 @@ public class SpecialMethodCall implements ISpecialMethodCall {
   @Nullable
   private final ClosureExpression closureExpr;
   private final boolean conditionBlock;
+  private final AstNodeCache nodeCache;
 
   public SpecialMethodCall(String methodName, Expression inferredName, Expression inferredType,
       MethodCallExpression methodCallExpr, @Nullable BinaryExpression binaryExpr,
-      @Nullable ClosureExpression closureExpr, boolean conditionBlock) {
+      @Nullable ClosureExpression closureExpr, boolean conditionBlock, AstNodeCache nodeCache) {
     this.methodName = methodName;
     this.inferredName = inferredName;
     this.inferredType = inferredType;
     this.binaryExpr = binaryExpr;
     this.methodCallExpr = methodCallExpr;
     this.closureExpr = closureExpr;
     this.conditionBlock = conditionBlock;
+    this.nodeCache = nodeCache;
   }
 
   @Override
@@ -168,13 +170,15 @@ public ClosureExpression getClosureExpr() {
   @Override
   public void expand() {
     List<Expression> args = new ArrayList<>();
+    args.add(VariableExpression.THIS_EXPRESSION);
     args.add(inferredName);
     args.add(inferredType);
     args.addAll(AstUtil.getArgumentList(methodCallExpr));
 
     ArgumentListExpression argsExpr = new ArgumentListExpression(args);
     AstUtil.copySourcePosition(methodCallExpr.getArguments(), argsExpr);
     methodCallExpr.setArguments(argsExpr);
+    methodCallExpr.setObjectExpression(new ClassExpression(nodeCache.SpecialMethodCallTarget));
     methodCallExpr.setMethod(new ConstantExpression(methodName + "Impl"));
   }
 
@@ -208,7 +212,7 @@ public static SpecialMethodCall parse(MethodCallExpression methodCallExpr, @Null
     }
     wrapCastedConstructorArgs(arguments, nodeCache);
 
-    return new SpecialMethodCall(methodName, inferredName, inferredType, methodCallExpr, binaryExpr, closureExpr, conditionBlock);
+    return new SpecialMethodCall(methodName, inferredName, inferredType, methodCallExpr, binaryExpr, closureExpr, conditionBlock, nodeCache);
   }
 
   private static void wrapCastedConstructorArgs(List<Expression> arguments, AstNodeCache nodeCache) {

spock-core/src/main/java/org/spockframework/lang/SpecInternals.java

@@ -14,14 +14,47 @@
 
 package org.spockframework.lang;
 
+import org.spockframework.mock.*;
+import org.spockframework.mock.runtime.*;
 import org.spockframework.runtime.*;
 import org.spockframework.util.*;
 
+import java.lang.reflect.Type;
+import java.util.*;
+
+import groovy.lang.Closure;
+
+import static org.spockframework.util.ObjectUtil.uncheckedCast;
+
 public abstract class SpecInternals {
   private final ISpecificationContext specificationContext = new SpecificationContext();
 
   @Beta
   public ISpecificationContext getSpecificationContext() {
     return specificationContext;
   }
+
+  @Beta
+  public <T> T createMock(@Nullable String name, Type type, MockNature nature,
+      MockImplementation implementation, Map<String, Object> options, @Nullable Closure<?> closure) {
+    return createMock(name, null, type, nature, implementation, options, closure);
+  }
+
+  @Beta
+  public <T> T createMock(@Nullable String name, T instance, Type type, MockNature nature,
+      MockImplementation implementation, Map<String, Object> options, @Nullable Closure<?> closure) {
+    Object mock = CompositeMockFactory.INSTANCE.create(
+        new MockConfiguration(name, type, instance, nature, implementation, options), uncheckedCast(this));
+    if (closure != null) {
+      GroovyRuntimeUtil.invokeClosure(closure, mock);
+    }
+    return uncheckedCast(mock);
+  }
+
+  @Beta
+  public void createStaticMock(Type type, MockNature nature,
+                               Map<String, Object> options) {
+    MockConfiguration configuration = new MockConfiguration(null, type, null, nature, MockImplementation.JAVA, options);
+    JavaMockFactory.INSTANCE.createStaticMock(configuration, uncheckedCast(this));
+  }
 }

spock-core/src/main/java/org/spockframework/mock/EmptyOrDummyResponse.java

@@ -14,7 +14,6 @@
 
 package org.spockframework.mock;
 
-import org.spockframework.runtime.GroovyRuntimeUtil;
 import org.spockframework.runtime.extension.IDefaultValueProviderExtension;
 import org.spockframework.util.ReflectionUtil;
 import org.spockframework.util.ThreadSafe;
@@ -161,8 +160,7 @@ private Object createDummy(IMockInvocation invocation) {
     Class<?> type = invocation.getMethod().getReturnType();
     Type genericType = invocation.getMethod().getExactReturnType();
     Specification spec = invocation.getMockObject().getSpecification();
-    return GroovyRuntimeUtil.invokeMethod(spec, "createMock",
-        "dummy", genericType, MockNature.STUB, GroovyObject.class.isAssignableFrom(type) ?
+    return spec.createMock("dummy", genericType, MockNature.STUB, GroovyObject.class.isAssignableFrom(type) ?
         MockImplementation.GROOVY : MockImplementation.JAVA, emptyMap(), null);
   }
 }