Closure improvements (#151)

* magic

* add ls support for @DelegatesTo annotation

* comment

Author: brachy84

src/main/java/com/cleanroommc/groovyscript/core/mixin/groovy/ClosureMixin.java

@@ -0,0 +1,19 @@
+package com.cleanroommc.groovyscript.core.mixin.groovy;
+
+import com.cleanroommc.groovyscript.GroovyScript;
+import groovy.lang.Closure;
+import groovy.lang.GroovyObjectSupport;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(value = Closure.class, remap = false)
+public abstract class ClosureMixin<V> extends GroovyObjectSupport {
+
+    @Inject(method = "call([Ljava/lang/Object;)Ljava/lang/Object;", at = @At("HEAD"), cancellable = true)
+    public void call(Object[] arguments, CallbackInfoReturnable<V> cir) {
+        // redirect closure call to properly catch and log errors
+        cir.setReturnValue(GroovyScript.getSandbox().runClosure((Closure<? extends V>) (Object) this, arguments));
+    }
+}

src/main/java/com/cleanroommc/groovyscript/sandbox/ClosureHelper.java

@@ -1,14 +1,23 @@
 package com.cleanroommc.groovyscript.sandbox;
 
-import com.cleanroommc.groovyscript.GroovyScript;
+import com.cleanroommc.groovyscript.api.GroovyBlacklist;
+import com.cleanroommc.groovyscript.api.GroovyLog;
+import com.cleanroommc.groovyscript.sandbox.expand.LambdaClosure;
 import groovy.lang.Closure;
+import org.codehaus.groovy.runtime.ConvertedClosure;
 import org.jetbrains.annotations.Nullable;
 
+import java.lang.reflect.*;
+import java.util.function.Function;
+
 public class ClosureHelper {
 
+    private static final Object DUMMY = new Object();
+    private static Field h;
+
     @Nullable
     public static <T> T call(Closure<T> closure, Object... args) {
-        return GroovyScript.getSandbox().runClosure(closure, args);
+        return closure.call(args);
     }
 
     @Nullable
@@ -27,4 +36,72 @@ public static <T> T call(T defaultValue, Closure<?> closure, Object... args) {
         }
         return defaultValue;
     }
+
+    /**
+     * The code inside a closure will try to find variables in its owner by default.
+     * This allows to add another variable holder and sets it as its primary variable holder.
+     * After this method is called, variables will be first searched in the given environment and then in the owner object.
+     * The owner object is usually a {@link groovy.lang.Script} instance.
+     *
+     * @param closure     closure
+     * @param environment variable holder
+     * @param force       force overwrite current variable holder
+     * @return the given closure
+     */
+    public static <T> Closure<T> withEnvironment(Closure<T> closure, Object environment, boolean force) {
+        if (force || closure.getDelegate() == null) {
+            closure.setDelegate(environment);
+            closure.setResolveStrategy(Closure.DELEGATE_FIRST);
+        }
+        return closure;
+    }
+
+    @GroovyBlacklist
+    public static <T> Closure<T> of(Function<Object[], T> function) {
+        return of(DUMMY, function);
+    }
+
+    @GroovyBlacklist
+    public static <T> Closure<T> of(Object owner, Function<Object[], T> function) {
+        return new LambdaClosure<>(owner, function);
+    }
+
+    /**
+     * Extracts the underlying closure from a functional interface instance.
+     *
+     * @param functionalInterface a functional interface like {@link Function}
+     * @return the underlying closure or null if there is no closure
+     */
+    @GroovyBlacklist
+    @Nullable
+    public static Closure<?> getUnderlyingClosure(Object functionalInterface) {
+        if (!(functionalInterface instanceof Proxy)) return null; // not a closure
+        if (h == null) {
+            try {
+                Method getFields = Class.class.getDeclaredMethod("getDeclaredFields0", boolean.class);
+                getFields.setAccessible(true);
+                for (Field field : (Field[]) getFields.invoke(Proxy.class, false)) {
+                    if (field.getName().equals("h")) {
+                        h = field;
+                        h.setAccessible(true);
+                        break;
+                    }
+                }
+            } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
+                throw new RuntimeException(e);
+            }
+            if (h == null) {
+                throw new IllegalStateException("Field h not found");
+            }
+        }
+        try {
+            InvocationHandler handler = (InvocationHandler) h.get(functionalInterface);
+            if (handler instanceof ConvertedClosure convertedClosure) {
+                return (Closure<?>) convertedClosure.getDelegate();
+            }
+        } catch (IllegalArgumentException | IllegalAccessException e) {
+            GroovyLog.get().exception(e);
+        }
+        return null;
+    }
 }

src/main/java/com/cleanroommc/groovyscript/sandbox/GroovyLogImpl.java

@@ -102,14 +102,14 @@ public void log(GroovyLog.Msg msg) {
             // has no sub messages -> log in a single line
             writeLogLine(formatLine(level, main));
             if (msg.shouldLogToMc()) {
-                logger.log(msg.getLevel(), main + " in line " + GroovyScript.getSandbox().getCurrentLine());
+                logger.log(msg.getLevel(), main);
             }
         } else if (messages.size() == 1 && main.length() + messages.get(0).length() < 100) {
             // has one sub message and the main message and the sub message have less than 100 characters ->
             // log in a single line
             writeLogLine(formatLine(level, main + ": - " + messages.get(0)));
             if (msg.shouldLogToMc()) {
-                logger.log(msg.getLevel(), main + ": - " + messages.get(0) + "  in line " + GroovyScript.getSandbox().getCurrentLine());
+                logger.log(msg.getLevel(), main + ": - " + messages.get(0));
             }
         } else {
             // has multiple log lines or the main message and the first sub message are to long ->
@@ -119,7 +119,7 @@ public void log(GroovyLog.Msg msg) {
                 writeLogLine(formatLine(level, " - " + message));
             }
             if (msg.shouldLogToMc()) {
-                logger.log(msg.getLevel(), main + " in line " + GroovyScript.getSandbox().getCurrentLine() + " : - ");
+                logger.log(msg.getLevel(), main + ": ");
                 for (String message : messages) {
                     logger.log(msg.getLevel(), " - " + message);
                 }

src/main/java/com/cleanroommc/groovyscript/sandbox/GroovySandbox.java

@@ -31,15 +31,7 @@
  */
 public abstract class GroovySandbox {
 
-    private static final ThreadLocal<GroovySandbox> currentSandbox = new ThreadLocal<>();
-    // TODO
     private String currentScript = null;
-    private int currentLine = -1;
-
-    @Nullable
-    public static GroovySandbox getCurrentSandbox() {
-        return currentSandbox.get();
-    }
 
     private final URL[] scriptEnvironment;
     private final ThreadLocal<Boolean> running = ThreadLocal.withInitial(() -> false);
@@ -82,13 +74,11 @@ protected void registerStaticImports(Class<?>... classes) {
     }
 
     protected void startRunning() {
-        currentSandbox.set(this);
         this.running.set(true);
     }
 
     protected void stopRunning() {
         this.running.set(false);
-        currentSandbox.remove();
     }
 
     protected GroovyScriptEngine createScriptEngine() {
@@ -107,7 +97,6 @@ protected Binding createBindings() {
     }
 
     public void load() throws Exception {
-        currentSandbox.set(this);
         preRun();
 
         GroovyScriptEngine engine = createScriptEngine();
@@ -120,7 +109,6 @@ public void load() throws Exception {
         } finally {
             running.set(false);
             postRun();
-            currentSandbox.set(null);
             setCurrentScript(null);
         }
     }
@@ -234,13 +222,8 @@ public String getCurrentScript() {
         return currentScript;
     }
 
-    public int getCurrentLine() {
-        return currentLine;
-    }
-
     protected void setCurrentScript(String currentScript) {
         this.currentScript = currentScript;
-        this.currentLine = -1;
     }
 
     public static String getRelativePath(String source) {

src/main/java/com/cleanroommc/groovyscript/sandbox/GroovyScriptSandbox.java

@@ -1,6 +1,7 @@
 package com.cleanroommc.groovyscript.sandbox;
 
 import com.cleanroommc.groovyscript.GroovyScript;
+import com.cleanroommc.groovyscript.api.GroovyBlacklist;
 import com.cleanroommc.groovyscript.api.GroovyLog;
 import com.cleanroommc.groovyscript.compat.mods.ModSupport;
 import com.cleanroommc.groovyscript.event.GroovyEventManager;
@@ -13,10 +14,7 @@
 import com.google.gson.JsonArray;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import groovy.lang.Binding;
-import groovy.lang.Closure;
-import groovy.lang.GroovyClassLoader;
-import groovy.lang.Script;
+import groovy.lang.*;
 import groovy.util.GroovyScriptEngine;
 import groovy.util.ResourceException;
 import groovy.util.ScriptException;
@@ -25,9 +23,11 @@
 import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.common.MinecraftForge;
 import org.apache.commons.io.FileUtils;
+import org.apache.groovy.internal.util.UncheckedThrow;
 import org.codehaus.groovy.control.CompilerConfiguration;
 import org.codehaus.groovy.control.SourceUnit;
 import org.codehaus.groovy.control.customizers.ImportCustomizer;
+import org.codehaus.groovy.runtime.InvokerInvocationException;
 import org.jetbrains.annotations.ApiStatus;
 import org.jetbrains.annotations.Nullable;
 
@@ -174,12 +174,13 @@ public void load() throws Exception {
         throw new UnsupportedOperationException("Use run(Loader loader) instead!");
     }
 
+    @ApiStatus.Internal
     @Override
     public <T> T runClosure(Closure<T> closure, Object... args) {
         startRunning();
         T result = null;
         try {
-            result = closure.call(args);
+            result = runClosureInternal(closure, args);
         } catch (Throwable t) {
             this.storedExceptions.computeIfAbsent(Arrays.asList(t.getStackTrace()), k -> {
                 GroovyLog.get().error("An exception occurred while running a closure!");
@@ -192,6 +193,24 @@ public <T> T runClosure(Closure<T> closure, Object... args) {
         return result;
     }
 
+    @GroovyBlacklist
+    private static <T> T runClosureInternal(Closure<T> closure, Object[] args) {
+        // original Closure.call(Object... arguments) code
+        try {
+            //noinspection unchecked
+            return (T) closure.getMetaClass().invokeMethod(closure, "doCall", args);
+        } catch (InvokerInvocationException e) {
+            UncheckedThrow.rethrow(e.getCause());
+            return null; // unreachable statement
+        } catch (Exception e) {
+            if (e instanceof RuntimeException) {
+                throw e;
+            } else {
+                throw new GroovyRuntimeException(e.getMessage(), e);
+            }
+        }
+    }
+
     private static String mainClassName(String name) {
         return name.contains("$") ? name.split("\\$", 2)[0] : name;
     }

src/main/java/com/cleanroommc/groovyscript/sandbox/expand/ExpansionHelper.java

@@ -1,6 +1,7 @@
 package com.cleanroommc.groovyscript.sandbox.expand;
 
 import com.cleanroommc.groovyscript.api.GroovyBlacklist;
+import com.cleanroommc.groovyscript.sandbox.ClosureHelper;
 import groovy.lang.*;
 import groovy.transform.Internal;
 import org.codehaus.groovy.reflection.*;
@@ -11,6 +12,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.Collection;
+import java.util.function.Function;
 
 public class ExpansionHelper {
 
@@ -116,9 +118,9 @@ public static void mixinMethod(Class<?> self, Class<?> other, String methodName)
         }
     }
 
-    public static void mixinMethod(Class<?> self, String name, LambdaClosure.AnyFunction<?> function) {
+    public static void mixinMethod(Class<?> self, String name, Function<Object[], ?> function) {
         ExpandoMetaClass emc = getExpandoClass(self);
-        emc.registerInstanceMethod(name, new LambdaClosure<>(function));
+        emc.registerInstanceMethod(name, ClosureHelper.of(function));
     }
 
     private static void mixinMethod(ExpandoMetaClass self, CachedMethod method, MixinInMetaClass mixin) {

src/main/java/com/cleanroommc/groovyscript/sandbox/expand/LambdaClosure.java

@@ -2,25 +2,22 @@
 
 import groovy.lang.Closure;
 
+import java.util.function.Function;
+
 public class LambdaClosure<T> extends Closure<T> {
 
-    private final AnyFunction<T> function;
+    private final Function<Object[], T> function;
 
-    public LambdaClosure(Object owner, AnyFunction<T> function) {
+    public LambdaClosure(Object owner, Function<Object[], T> function) {
         super(owner);
         this.function = function;
     }
 
-    public LambdaClosure(AnyFunction<T> function) {
+    public LambdaClosure(Function<Object[], T> function) {
         this(function.getClass(), function);
     }
 
     public T doCall(Object[] args) {
-        return function.run(args);
-    }
-
-    public interface AnyFunction<T> {
-
-        T run(Object[] args);
+        return function.apply(args);
     }
 }