Changed to using ScriptObjectMirror again for running functions.

Caused errors with some mods that defined their returns oddly.
Next breaking version should change things to return a Function directly.

.gitignore

@@ -1,6 +1,7 @@
 #occupational hazards
 /logs/
 /out/
+/repo/
 
 #eclipse
 **/bin

build.gradle

@@ -157,11 +157,15 @@ publishing {
     }
     repositories {
         maven {
-            credentials {
-                username project.properties.forgeMavenUser?:'fake'
-                password project.properties.forgeMavenPassword?:'news'
-            }
-            url 'http://files.minecraftforge.net/maven/manage/upload'
+			if (project.hasProperty('forgeMavenPassword')) {
+				credentials {
+					username project.properties.forgeMavenUser
+					password project.properties.forgeMavenPassword
+				}
+				url 'https://files.minecraftforge.net/maven/manage/upload'
+			} else {
+				url 'file://' + rootProject.file('repo').getAbsolutePath()
+			}
         }
     }
 }

src/java15/java/net/minecraftforge/coremod/NashornFactory.java

@@ -1,11 +1,20 @@
 package net.minecraftforge.coremod;
 
+import java.util.function.Function;
+
+import javax.script.Bindings;
 import javax.script.ScriptEngine;
 
 import org.openjdk.nashorn.api.scripting.NashornScriptEngineFactory;
+import org.openjdk.nashorn.api.scripting.ScriptObjectMirror;
 
 class NashornFactory {
     static ScriptEngine createEngine() {
         return new NashornScriptEngineFactory().getScriptEngine(CoreModEngine::checkClass);
     }
+
+    @SuppressWarnings("unchecked")
+	static <A,R> Function<A,R> getFunction(Bindings obj) {
+        return a -> (R)((ScriptObjectMirror)obj).call(obj, a);
+    }
 }

src/main/java/net/minecraftforge/coremod/CoreMod.java

@@ -61,44 +61,28 @@ private ITransformer<?> buildCore(Map.Entry<String,? extends Bindings> entry) {
         final Map<String, Object> targetData = (Map<String, Object>)data.get("target");
         final ITransformer.TargetType targetType = ITransformer.TargetType.valueOf((String)targetData.get("type"));
         final Set<ITransformer.Target> targets;
-        final Map<String, Object> function = (Map<String, Object>)data.get("transformer");
+        final Bindings function = (Bindings)data.get("transformer");
         switch (targetType) {
             case CLASS:
                 if (targetData.containsKey("names")) {
-                    Function<Map<String, Object>, Map<String, Object>> names = wrap(targetData.get("names"));
+                    Function<Map<String, Object>, Map<String, Object>> names = NashornFactory.getFunction((Bindings)targetData.get("names"));
                     targets = names.apply(targetData).values().stream().map(o -> (String)o).map(ITransformer.Target::targetClass).collect(Collectors.toSet());
                 } else
                     targets = Stream.of(ITransformer.Target.targetClass((String)targetData.get("name"))).collect(Collectors.toSet());
-                return new CoreModClassTransformer(this, coreName, targets, wrap(function));
+                return new CoreModClassTransformer(this, coreName, targets, NashornFactory.getFunction(function));
             case METHOD:
                 targets = Collections.singleton(ITransformer.Target.targetMethod(
                         (String) targetData.get("class"), ASMAPI.mapMethod((String) targetData.get("methodName")), (String) targetData.get("methodDesc")));
-                return new CoreModMethodTransformer(this, coreName, targets, wrap(function));
+                return new CoreModMethodTransformer(this, coreName, targets, NashornFactory.getFunction(function));
             case FIELD:
                 targets = Collections.singleton(ITransformer.Target.targetField(
                         (String) targetData.get("class"), ASMAPI.mapField((String) targetData.get("fieldName"))));
-                return new CoreModFieldTransformer(this, coreName, targets, wrap(function));
+                return new CoreModFieldTransformer(this, coreName, targets, NashornFactory.getFunction(function));
             default:
                 throw new RuntimeException("Unimplemented target type " + targetData);
         }
     }
 
-    @SuppressWarnings({ "unchecked" })
-    private <A,R> Function<A,R> wrap(Object obj) {
-        /*
-         * Takes a function returned from a previous invocation of the JS and turns it into a Function we can call from Java.
-         * The old way to do it was to use the Nashorn API directly, but this isn't something we can rely on as J15 removed nashorn by default
-         * And the point is to try and uncouple as best we can from nashorn specifics. So what we do is have the JS create a Function for us using the source for the returned function.
-         * This isn't great as doing new Function(function(){}) IS a Nashorn extension of JS, however it's also supported by other JS providers like Graal.
-         * So it's technically more compatible then using the hard dep on the java class.
-         */
-        try {
-            return (Function<A,R>)scriptEngine.eval("new java.util.function.Function(" + obj.toString() + ")");
-        } catch (ScriptException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
     public boolean hasError() {
         return !loaded;
     }

src/main/java/net/minecraftforge/coremod/NashornFactory.java

@@ -1,11 +1,20 @@
 package net.minecraftforge.coremod;
 
+import java.util.function.Function;
+
+import javax.script.Bindings;
 import javax.script.ScriptEngine;
 
 import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
+import jdk.nashorn.api.scripting.ScriptObjectMirror;
 
 class NashornFactory {
     static ScriptEngine createEngine() {
         return new NashornScriptEngineFactory().getScriptEngine(CoreModEngine::checkClass);
     }
+
+    @SuppressWarnings("unchecked")
+    static <A,R> Function<A,R> getFunction(Bindings obj) {
+        return a -> (R)((ScriptObjectMirror)obj).call(obj, a);
+    }
 }