upgrade to utility class

Author: FalsePattern

src/main/java/com/falsepattern/jfunge/interpreter/LambdaHelper.java

@@ -0,0 +1,45 @@
+package com.falsepattern.jfunge.interpreter;
+
+import lombok.*;
+import lombok.experimental.*;
+
+import java.lang.invoke.LambdaMetafactory;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+
+@UtilityClass
+public final class LambdaHelper {
+    public static MethodHandle newLambdaMetaFactory(Class<?> functionalInterface, Method staticMethod) {
+        try {
+            val interfaceMethod = Arrays.stream(functionalInterface.getDeclaredMethods())
+                                        .filter(method1 -> !method1.isDefault())
+                                        .findFirst()
+                                        .orElseThrow(() -> new IllegalArgumentException(functionalInterface.getName() + " does not have a single abstract method"));
+            val interfaceMethodName = interfaceMethod.getName();
+            val factoryType = MethodType.methodType(functionalInterface);
+            val interfaceMethodType = MethodType.methodType(interfaceMethod.getReturnType(),
+                                                            interfaceMethod.getParameterTypes());
+
+            // Get the method handle for the static method
+            val lookup = MethodHandles.lookup();
+            val implementation = lookup.unreflect(staticMethod);
+            val dynamicMethodType = implementation.type();
+
+            return LambdaMetafactory
+                    .metafactory(lookup,
+                                 interfaceMethodName,
+                                 factoryType,
+                                 interfaceMethodType,
+                                 implementation,
+                                 dynamicMethodType)
+                    .getTarget();
+        } catch (Throwable throwable) {
+            val errStr = "Failed to bind method: %s to functional interface: %s";
+            throw new RuntimeException(String.format(errStr, staticMethod.getName(), functionalInterface.getName()),
+                                       throwable);
+        }
+    }
+}

src/main/java/com/falsepattern/jfunge/interpreter/instructions/InstructionSet.java

@@ -1,13 +1,10 @@
 package com.falsepattern.jfunge.interpreter.instructions;
 
-import com.falsepattern.jfunge.interpreter.ExecutionContext;
+import com.falsepattern.jfunge.interpreter.LambdaHelper;
 import lombok.val;
 
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
-import java.lang.invoke.LambdaMetafactory;
-import java.lang.invoke.MethodHandles;
-import java.lang.invoke.MethodType;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.function.IntConsumer;
@@ -16,25 +13,27 @@
 public interface InstructionSet {
     default void load(ObjIntConsumer<Instruction> instructionSet) {
         val clazz = this.getClass();
-        Arrays.stream(clazz.getDeclaredMethods()).filter((method) -> Modifier.isStatic(method.getModifiers()) && method.isAnnotationPresent(Instr.class)).forEach((method) -> {
-            val lookup = MethodHandles.lookup();
-            val methodType = MethodType.methodType(void.class, ExecutionContext.class);
-            try {
-                val lambda = (Instruction) LambdaMetafactory.metafactory(lookup, "process", MethodType.methodType(Instruction.class), methodType, lookup.findStatic(clazz, method.getName(), methodType), methodType).getTarget().invokeExact();
-                val ann = method.getAnnotation(Instr.class);
-                instructionSet.accept(lambda, ann.value());
-            } catch (Throwable e) {
-                throw new RuntimeException(e);
-            }
-        });
+        Arrays.stream(clazz.getDeclaredMethods())
+              .filter((method) -> Modifier.isStatic(method.getModifiers()) && method.isAnnotationPresent(Instr.class))
+              .forEach((method) -> {
+                  try {
+                      val lambda = (Instruction) LambdaHelper.newLambdaMetaFactory(Instruction.class, method).invokeExact();
+                      val ann = method.getAnnotation(Instr.class);
+                      instructionSet.accept(lambda, ann.value());
+                  } catch (Throwable e) {
+                      throw new RuntimeException(e);
+                  }
+              });
     }
 
     default void unload(IntConsumer instructionSet) {
         val clazz = this.getClass();
-        Arrays.stream(clazz.getDeclaredMethods()).filter((method) -> Modifier.isStatic(method.getModifiers()) && method.isAnnotationPresent(Instr.class)).forEach((method) -> {
-            val ann = method.getAnnotation(Instr.class);
-            instructionSet.accept(ann.value());
-        });
+        Arrays.stream(clazz.getDeclaredMethods())
+              .filter((method) -> Modifier.isStatic(method.getModifiers()) && method.isAnnotationPresent(Instr.class))
+              .forEach((method) -> {
+                  val ann = method.getAnnotation(Instr.class);
+                  instructionSet.accept(ann.value());
+              });
     }
 
     @Retention(RetentionPolicy.RUNTIME)