feat(allium)!: Make mixin building more like standard class builder experience.

Author: hugeblank

.gitignore

@@ -31,3 +31,7 @@ bin/
 # fabric
 
 run/
+
+# allium
+
+docs

allium/src/main/java/dev/moongarden/allium/api/event/MixinMethodHook.java

@@ -17,7 +17,6 @@
 import java.util.ArrayList;
 import java.util.List;
 
-@LuaWrapped
 public class MixinMethodHook {
     private final Script script;
     private final String id;
@@ -42,7 +41,10 @@ private static EClass<?> forName(String id, String name) {
         }
     }
 
-    @LuaWrapped
+    public String id() {
+        return id;
+    }
+
     public ScriptResource hook(LuaFunction func, @OptionalArg Boolean destroyOnUnload) {
         if (!MixinLib.isComplete())
             throw new IllegalStateException("Hook cannot be set during pre-launch phase.");

allium/src/main/java/dev/moongarden/allium/loader/ScriptExecutor.java

@@ -102,16 +102,11 @@ public LuaValue execute(Path path) throws LuaError, CompileException, IOExceptio
         LuaFunction func = LoadState.load(
             state,
             stream,
-            '=' + id + ":/" + path.relativize(path),
+            '=' + id + ":/" + path.getParent().relativize(path),
             state.globals()
         );
         Allium.PROFILER.pop();
-        try {
-            return Dispatch.call(state, func);
-        } catch (UnwindThrowable e) {
-            logger.warn("Unhandled yield. Avoid using coroutine.yield in places that will bleed into Java logic.");
-        }
-        return Constants.NIL;
+        return LuaThread.runMain(state, func).first();
     }
 
     private static final class PrintMethod extends VarArgFunction {

allium/src/main/java/dev/moongarden/allium/loader/lib/MixinLib.java

@@ -8,13 +8,12 @@
 import dev.moongarden.allium.api.event.MixinMethodHook;
 import dev.moongarden.allium.loader.Script;
 import dev.moongarden.allium.loader.lib.mixin.MixinClassInfo;
-import dev.moongarden.allium.loader.lib.mixin.annotation.method.MixinMethodAnnotations;
-import dev.moongarden.allium.loader.lib.mixin.annotation.sugar.MixinSugars;
-import dev.moongarden.allium.loader.lib.mixin.builder.MixinClassBuilder;
+import dev.moongarden.allium.loader.lib.mixin.builder.AbstractMixinBuilder;
+import dev.moongarden.allium.loader.lib.mixin.builder.HookDefinition;
 import dev.moongarden.allium.loader.type.StaticBinder;
 import dev.moongarden.allium.api.LuaWrapped;
 import dev.moongarden.allium.api.OptionalArg;
-import dev.moongarden.allium.loader.type.userdata.ClassUserdata;
+import dev.moongarden.allium.loader.type.exception.InvalidMixinException;
 import dev.moongarden.allium.util.ByteArrayStreamHandler;
 import dev.moongarden.allium.util.JsonObjectBuilder;
 import dev.moongarden.allium.util.asm.VisitedClass;
@@ -30,29 +29,19 @@
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 @LuaWrapped(name = "mixin")
 public class MixinLib extends WrappedScriptLibrary {
     private static boolean COMPLETE = false;
 
-    // This being the way to define embedded "tables" is hilarious to me.
-    private static final ClassUserdata<MixinMethodAnnotations> ANNOTATION = StaticBinder.bindClass(EClass.fromJava(MixinMethodAnnotations.class));
-    private static final ClassUserdata<MixinSugars> SUGAR = StaticBinder.bindClass(EClass.fromJava(MixinSugars.class));
-
-
-    @LuaWrapped public final ClassUserdata<MixinMethodAnnotations> annotation = ANNOTATION;
-    @LuaWrapped public final ClassUserdata<MixinSugars> sugar = SUGAR;
     private final String mixinPackage = "allium." + script.getID() + ".mixin";
     private final String mixinConfigName = "allium-"+ script.getID() +"-generated.mixins.json";
     private final List<MixinClassInfo> mixins = new ArrayList<>();
     private final List<MixinClassInfo> client = new ArrayList<>();
     private final List<MixinClassInfo> server = new ArrayList<>();
     private final Map<String, String> duckMap = new HashMap<>();
-    private final Map<String, MixinMethodHook> eventMap = new HashMap<>();
+    private final Map<String, Map<String, MixinMethodHook>> classHooks = new HashMap<>();
 
     private int nextMixinId = 0;
 
@@ -61,8 +50,11 @@ public MixinLib(Script script) {
     }
 
     @LuaWrapped
-    public MixinMethodHook get(String hookId) {
-        return eventMap.get(hookId);
+    public HookDefinition get(String classId) throws InvalidMixinException {
+        if (!classHooks.containsKey(classId))
+            throw new InvalidMixinException(InvalidMixinException.Type.INVALID_CLASS_ID, classId);
+
+        return new HookDefinition(classHooks.get(classId));
     }
 
     @LuaWrapped
@@ -74,7 +66,7 @@ public LuaValue quack(String mixinId) throws ClassNotFoundException {
     }
 
     @LuaWrapped
-    public MixinClassBuilder to(String targetClass, @OptionalArg @Nullable String[] interfaces, @OptionalArg @Nullable String targetEnvironment, @OptionalArg @Nullable Boolean duck) throws LuaError {
+    public AbstractMixinBuilder to(String targetClass, @OptionalArg @Nullable String[] interfaces, @OptionalArg @Nullable String targetEnvironment, @OptionalArg @Nullable Boolean duck) throws LuaError {
         EnvType targetEnv;
         if (targetEnvironment == null) {
             targetEnv = null;
@@ -85,7 +77,7 @@ public MixinClassBuilder to(String targetClass, @OptionalArg @Nullable String[]
         } else {
             throw new LuaError("Mixin for " + targetClass + " expects target environment of nil, 'client' or 'server'.");
         }
-        return MixinClassBuilder.create(
+        return AbstractMixinBuilder.create(
                 targetClass,
                 interfaces == null ? new String[]{} : interfaces,
                 targetEnv,
@@ -114,8 +106,8 @@ public void addDuck(String id, String path) {
         duckMap.put(id, path);
     }
 
-    public void addMethodHook(String id, MixinMethodHook hook) {
-        eventMap.put(id, hook);
+    public void addHooks(String id, Map<String, MixinMethodHook> hooks) {
+        classHooks.put(id, hooks);
     }
 
     public JsonArray mixinsToJson(List<MixinClassInfo> list, Map<String, byte[]> configMap) {

allium/src/main/java/dev/moongarden/allium/loader/lib/mixin/annotation/method/InjectorChef.java

@@ -1,5 +1,6 @@
 package dev.moongarden.allium.loader.lib.mixin.annotation.method;
 
+import dev.moongarden.allium.api.event.MixinMethodHook;
 import dev.moongarden.allium.loader.Script;
 import dev.moongarden.allium.loader.lib.mixin.annotation.sugar.LuaSugar;
 import dev.moongarden.allium.loader.type.exception.InvalidArgumentException;
@@ -12,12 +13,13 @@
 import java.util.List;
 
 public interface InjectorChef {
-    void bake(
+    MixinMethodHook bake(
             Script script,
+            String classId,
             String eventId,
             ClassWriter classWriter,
             VisitedClass mixinClass,
             List<LuaMethodAnnotation> annotations,
             @Nullable List<? extends LuaSugar> sugarParameters
-    ) throws InvalidMixinException, LuaError, InvalidArgumentException;
+    ) throws InvalidMixinException, LuaError;
 }

allium/src/main/java/dev/moongarden/allium/loader/lib/mixin/annotation/method/LuaInjectorAnnotation.java

@@ -3,8 +3,8 @@
 import dev.moongarden.allium.api.event.MixinMethodHook;
 import dev.moongarden.allium.loader.Script;
 import dev.moongarden.allium.loader.lib.mixin.annotation.LuaAnnotationParser;
-import dev.moongarden.allium.loader.lib.mixin.builder.MixinClassBuilder;
-import dev.moongarden.allium.loader.lib.mixin.builder.MixinMethodBuilder;
+import dev.moongarden.allium.loader.lib.mixin.builder.AbstractMixinBuilder;
+import dev.moongarden.allium.loader.lib.mixin.builder.InternalMixinMethodBuilder;
 import dev.moongarden.allium.loader.lib.mixin.builder.MixinParameter;
 import dev.moongarden.allium.loader.type.exception.InvalidArgumentException;
 import dev.moongarden.allium.loader.type.exception.InvalidMixinException;
@@ -37,7 +37,7 @@ protected String createInjectName(String scriptId, String visitedMethodName) {
     }
 
     protected static VisitedMethod getVisitedMethod(VisitedClass mixinClass, LuaAnnotationParser annotation) throws InvalidMixinException, LuaError {
-        String descriptor = MixinClassBuilder.cleanDescriptor(
+        String descriptor = AbstractMixinBuilder.cleanDescriptor(
             mixinClass,
             annotation.findElement("method", String.class)
         );
@@ -46,17 +46,20 @@ protected static VisitedMethod getVisitedMethod(VisitedClass mixinClass, LuaAnno
         return mixinClass.getMethod(descriptor);
     }
 
-    protected static MixinMethodBuilder.WriteFactory createInjectWriteFactory(Script script, String eventName) {
+    protected static InternalMixinMethodBuilder.WriteFactory createInjectWriteFactory(Script script, String classId, String eventName) {
         final Type objectType = Type.getType(Object.class);
+
         return (methodVisitor, desc, paramTypes) -> {
             int varPrefix = paramTypes.size();
             Type returnType = Type.getReturnType(desc);
             List<Type> types = paramTypes.stream().map(MixinParameter::getType).toList();
 
             AsmUtil.getScript(methodVisitor, script);
             methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Owners.SCRIPT, "getMixinLib", "()Ldev/moongarden/allium/loader/lib/MixinLib;", false);
+            methodVisitor.visitLdcInsn(classId);
+            methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Owners.MIXIN_LIB, "get", "(Ljava/lang/String;)Ldev/moongarden/allium/loader/lib/mixin/builder/HookDefinition;", false);
             methodVisitor.visitLdcInsn(eventName);
-            methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Owners.MIXIN_LIB, "get", "(Ljava/lang/String;)Ldev/moongarden/allium/api/event/MixinMethodHook;", false);
+            methodVisitor.visitMethodInsn(INVOKEVIRTUAL, Owners.HOOK_DEFINITION, "forId", "(Ljava/lang/String;)Ldev/moongarden/allium/api/event/MixinMethodHook;", false);
 
             AsmUtil.createArray(methodVisitor, varPrefix, types, Object.class, (visitor, index, arg) -> {
                 visitor.visitVarInsn(arg.getOpcode(ILOAD), index); // <- 2

allium/src/main/java/dev/moongarden/allium/loader/lib/mixin/annotation/method/MixinMethodAnnotations.java

@@ -1,10 +1,11 @@
 package dev.moongarden.allium.loader.lib.mixin.annotation.method.injectors;
 
+import dev.moongarden.allium.api.event.MixinMethodHook;
 import dev.moongarden.allium.loader.Script;
 import dev.moongarden.allium.loader.lib.mixin.annotation.method.LuaInjectorAnnotation;
 import dev.moongarden.allium.loader.lib.mixin.annotation.method.LuaMethodAnnotation;
 import dev.moongarden.allium.loader.lib.mixin.annotation.sugar.LuaSugar;
-import dev.moongarden.allium.loader.lib.mixin.builder.MixinMethodBuilder;
+import dev.moongarden.allium.loader.lib.mixin.builder.InternalMixinMethodBuilder;
 import dev.moongarden.allium.loader.lib.mixin.builder.MixinParameter;
 import dev.moongarden.allium.loader.type.exception.InvalidArgumentException;
 import dev.moongarden.allium.loader.type.exception.InvalidMixinException;
@@ -34,23 +35,23 @@ public LuaCustom(LuaState state, LuaTable annotationTable, Class<?> annotation,
     }
 
     @Override
-    public void bake(Script script, String eventId, ClassWriter classWriter, VisitedClass mixinClass, List<LuaMethodAnnotation> annotations, @Nullable List<? extends LuaSugar> sugarParameters) throws InvalidMixinException, LuaError, InvalidArgumentException {
+    public MixinMethodHook bake(Script script, String classId, String eventId, ClassWriter classWriter, VisitedClass mixinClass, List<LuaMethodAnnotation> annotations, @Nullable List<? extends LuaSugar> sugarParameters) throws InvalidMixinException, LuaError {
         VisitedMethod visitedMethod = mixinClass.getMethod(methodDescriptor);
         List<MixinParameter> params = parameters.stream().map(str -> new MixinParameter(Type.getType(str))).toList();
 
-        MixinMethodBuilder methodBuilder = MixinMethodBuilder.of(
+        InternalMixinMethodBuilder methodBuilder = new InternalMixinMethodBuilder(
                 classWriter, visitedMethod, createInjectName(script.getID(), visitedMethod.name()), params
         );
 
         if (sugarParameters != null) methodBuilder.sugars(sugarParameters);
 
-        methodBuilder
+        return methodBuilder
                 .access(visitedMethod.access() & ~(ACC_PUBLIC | ACC_PROTECTED) | ACC_PRIVATE)
                 .returnType(Type.getType(returnType))
                 .annotations(annotations.stream().map(LuaMethodAnnotation::parser).toList())
                 .signature(visitedMethod.signature())
                 .exceptions(visitedMethod.exceptions())
-                .code(createInjectWriteFactory(script, eventId))
-                .build(script, eventId);
+                .code(createInjectWriteFactory(script, classId, eventId))
+                .buildForClass(script, eventId);
     }
 }