Patch STORE injection points

Su5eD · Su5eD · commit a2064f4e831d · 2025-10-22T09:29:55.000+02:00
diff --git a/definition/src/next/java/org/sinytra/adapter/next/env/ann/MixinAnnotationConstants.java b/definition/src/next/java/org/sinytra/adapter/next/env/ann/MixinAnnotationConstants.java
@@ -3,4 +3,7 @@
 public class MixinAnnotationConstants {
     public static final String AT_METHOD = "method";
     public static final String AT_VAL_INVOKE = "INVOKE";
+    public static final String AT_VAL_STORE = "STORE";
+
+    public static final String PROPERTY_ORDINAL = "ordinal";
 }
diff --git a/definition/src/next/java/org/sinytra/adapter/next/env/ann/ModifyVariableMixinData.java b/definition/src/next/java/org/sinytra/adapter/next/env/ann/ModifyVariableMixinData.java
@@ -2,16 +2,24 @@
 
 import org.sinytra.adapter.patch.util.MethodQualifier;
 
+import java.util.OptionalInt;
+
 public class ModifyVariableMixinData extends MixinData {
     private final boolean argsOnly;
+    private final Integer ordinal;
     
-    public ModifyVariableMixinData(ClassTarget targetClass, MethodQualifier targetMethod, AtData atData, boolean argsOnly) {
+    public ModifyVariableMixinData(ClassTarget targetClass, MethodQualifier targetMethod, AtData atData, boolean argsOnly, Integer ordinal) {
         super(targetClass, targetMethod, atData);
 
         this.argsOnly = argsOnly;
+        this.ordinal = ordinal;
     }
 
     public boolean argsOnly() {
         return this.argsOnly;
     }
+
+    public OptionalInt ordinal() {
+        return this.ordinal != null ? OptionalInt.of(this.ordinal) : OptionalInt.empty();
+    }
 }
diff --git a/definition/src/next/java/org/sinytra/adapter/next/pipeline/processor/Processors.java b/definition/src/next/java/org/sinytra/adapter/next/pipeline/processor/Processors.java
@@ -13,5 +13,6 @@ private void registerDefaultProcessors() {
         add(new InjectionTargetProcessor());
         add(new MixinMethodParametersProcessor());
         add(new ReturnTypeProcessor());
+        add(new PropertyProcessor());
     }
 }
diff --git a/definition/src/next/java/org/sinytra/adapter/next/pipeline/processor/PropertyProcessor.java b/definition/src/next/java/org/sinytra/adapter/next/pipeline/processor/PropertyProcessor.java
@@ -0,0 +1,23 @@
+package org.sinytra.adapter.next.pipeline.processor;
+
+import org.sinytra.adapter.next.env.MixinContext;
+import org.sinytra.adapter.next.env.ann.MixinData;
+import org.sinytra.adapter.next.pipeline.Recipe;
+import org.sinytra.adapter.next.pipeline.TxResult;
+import org.sinytra.adapter.next.pipeline.config.Configuration;
+import org.sinytra.adapter.patch.analysis.selector.AnnotationHandle;
+
+import static org.sinytra.adapter.next.env.ann.MixinAnnotationConstants.PROPERTY_ORDINAL;
+
+public class PropertyProcessor implements Processor {
+    @Override
+    public TxResult process(MixinData mixin, MixinContext context, Configuration dirty, Recipe recipe) {
+        if (dirty.getAtData() == null) return TxResult.FAIL;
+
+        AnnotationHandle handle = context.methodAnnotation();
+        dirty.<Integer>getProperty(PROPERTY_ORDINAL)
+            .ifPresent(o -> handle.setOrAppendNonNull(PROPERTY_ORDINAL, o));
+
+        return TxResult.SUCCESS;
+    }
+}
diff --git a/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/InjectionTargetResolver.java b/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/InjectionTargetResolver.java
@@ -25,16 +25,16 @@
 public class InjectionTargetResolver implements Resolver {
     private static final int INSN_RANGE = 5;
 
+    private final List<Resolver> subResolvers = new ArrayList<>();
+
+    public void addSubResolver(Resolver subResolver) {
+        this.subResolvers.add(subResolver);
+    }
+
     @Override
     public TxResult resolve(MixinData mixin, MixinContext context, Configuration clean, MutableConfiguration dirty, Recipe recipe) {
         if (dirty.getAtData() != null) return TxResult.PASS;
 
-        // Only support INVOKE for now
-        if (!clean.getAtData().getValue().equals(AT_VAL_INVOKE)) {
-            dirty.inheritAtData();
-            return TxResult.SUCCESS;
-        }
-
         MethodQualifier dirtyQualifier = dirty.getTargetMethod();
         if (dirtyQualifier == null) return TxResult.FAIL;
 
@@ -48,6 +48,19 @@ public TxResult resolve(MixinData mixin, MixinContext context, Configuration cle
             return TxResult.SUCCESS;
         }
 
+        for (Resolver subResolver : this.subResolvers) {
+            TxResult result = subResolver.resolve(mixin, context, clean, dirty, recipe);
+            if (result != TxResult.PASS) {
+                return result;
+            }
+        }
+
+        // Only support INVOKE for now
+        if (!clean.getAtData().getValue().equals(AT_VAL_INVOKE)) {
+            dirty.inheritAtData();
+            return TxResult.SUCCESS;
+        }
+
         // Find replacements
         if (findReplacedType(context, clean.getTargetMethod(), pair.methodNode(), clean.getAtData(), dirty)) {
             return TxResult.SUCCESS;
diff --git a/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/ModifyVarInjectionTargetSubResolver.java b/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/ModifyVarInjectionTargetSubResolver.java
@@ -0,0 +1,74 @@
+package org.sinytra.adapter.next.pipeline.resolver;
+
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.LocalVariableNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.sinytra.adapter.next.env.MixinContext;
+import org.sinytra.adapter.next.env.ann.MixinData;
+import org.sinytra.adapter.next.env.ann.ModifyVariableMixinData;
+import org.sinytra.adapter.next.pipeline.Recipe;
+import org.sinytra.adapter.next.pipeline.TxResult;
+import org.sinytra.adapter.next.pipeline.config.Configuration;
+import org.sinytra.adapter.next.pipeline.config.MutableConfiguration;
+import org.sinytra.adapter.patch.analysis.InstructionMatcher;
+import org.sinytra.adapter.patch.analysis.locals.LocalVarAnalyzer;
+import org.sinytra.adapter.patch.analysis.locals.LocalVariableLookup;
+import org.sinytra.adapter.patch.api.MethodContext;
+
+import java.util.List;
+
+import static org.sinytra.adapter.next.env.ann.MixinAnnotationConstants.AT_VAL_STORE;
+import static org.sinytra.adapter.next.env.ann.MixinAnnotationConstants.PROPERTY_ORDINAL;
+
+public class ModifyVarInjectionTargetSubResolver implements Resolver {
+
+    @Override
+    public TxResult resolve(MixinData mixin, MixinContext context, Configuration clean, MutableConfiguration dirty, Recipe recipe) {
+        if (!(mixin instanceof ModifyVariableMixinData mvdata) || !clean.getAtData().getValue().equals(AT_VAL_STORE)) {
+            return TxResult.PASS;
+        }
+
+        MethodContext.TargetPair pair = context.methods().findOwnMethodPair(context.dirtyLookup(), dirty.getTargetMethod());
+
+        // Find replacement
+        if (findComparableReplacement(mvdata, context, clean, pair, dirty)) {
+            return TxResult.SUCCESS;
+        }
+
+        return TxResult.PASS;
+    }
+
+    private static boolean findComparableReplacement(ModifyVariableMixinData mixin, MixinContext context, Configuration clean, MethodContext.TargetPair dirtyPair, MutableConfiguration dirty) {
+        if (mixin.ordinal().isEmpty()) return false;
+        int ordinal = mixin.ordinal().getAsInt();
+        Type varType = Type.getReturnType(context.methodNode().desc);
+
+        MethodContext.TargetPair cleanPair = context.methods().findOwnMethodPair(context.cleanLookup(), clean.getTargetMethod());
+        LocalVariableLookup lookup = new LocalVariableLookup(cleanPair.methodNode());
+        LocalVariableNode desired = lookup.getByTypedOrdinal(varType, ordinal).orElseThrow();
+
+        // Find variable initializer insns
+        InsnList desiredInitializerInsns = LocalVarAnalyzer.findInitializerInsns(cleanPair.methodNode(), desired.index);
+
+        // Get all matching variables
+        for (MethodNode method : dirtyPair.classNode().methods) {
+            LocalVariableLookup dirtyLookup = new LocalVariableLookup(method);
+            List<LocalVariableNode> lvs = method.localVariables.stream()
+                .filter(lvn -> desired.desc.equals(lvn.desc))
+                .filter(lvn -> {
+                    InsnList insns = LocalVarAnalyzer.findInitializerInsns(method, lvn.index);
+                    return InstructionMatcher.test(desiredInitializerInsns, insns);
+                })
+                .toList();
+            if (lvs.size() == 1) {
+                int dirtyOrdinal = dirtyLookup.getOrdinal(lvs.getFirst());
+                dirty.setProperty(PROPERTY_ORDINAL, dirtyOrdinal);
+                dirty.setTargetMethod(method);
+                dirty.inheritAtData();
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/TargetMethodResolver.java b/definition/src/next/java/org/sinytra/adapter/next/pipeline/resolver/TargetMethodResolver.java
@@ -14,6 +14,7 @@
 import org.sinytra.adapter.next.pipeline.config.Configuration;
 import org.sinytra.adapter.next.pipeline.config.MutableConfiguration;
 import org.sinytra.adapter.patch.api.MethodContext;
+import org.sinytra.adapter.patch.util.AdapterUtil;
 import org.sinytra.adapter.patch.util.MethodQualifier;
 
 import java.util.ArrayList;
@@ -111,7 +112,17 @@ private static MethodNode resolveReplacementCandidate(MixinContext context, Clas
                 valid.add(method);
             }
         }
+        if (valid.size() == 1) {
+            return valid.getFirst();
+        }
+
+        List<MethodNode> nonDeprecated = methods.stream()
+            .filter(m -> !AdapterUtil.hasAnnotation(m.visibleAnnotations, "Ljava/lang/Deprecated;"))
+            .toList();
+        if (nonDeprecated.size() == 1) {
+            return nonDeprecated.getFirst();
+        }
 
-        return valid.size() == 1 ? valid.getFirst() : null;
+        return null;
     }
 }
diff --git a/definition/src/next/java/org/sinytra/adapter/next/type/ModifyVariableMixin.java b/definition/src/next/java/org/sinytra/adapter/next/type/ModifyVariableMixin.java
@@ -9,6 +9,8 @@
 import org.sinytra.adapter.next.pipeline.Recipe;
 import org.sinytra.adapter.next.pipeline.config.Configuration;
 import org.sinytra.adapter.next.pipeline.config.MutableConfiguration;
+import org.sinytra.adapter.next.pipeline.resolver.InjectionTargetResolver;
+import org.sinytra.adapter.next.pipeline.resolver.ModifyVarInjectionTargetSubResolver;
 import org.sinytra.adapter.patch.analysis.selector.AnnotationHandle;
 import org.sinytra.adapter.patch.analysis.selector.AnnotationValueHandle;
 import org.sinytra.adapter.patch.fixes.TypeAdapter;
@@ -24,12 +26,15 @@ public class ModifyVariableMixin implements MixinType<ModifyVariableMixinData> {
     @Override
     public ModifyVariableMixinData parse(MixinContext context, ClassTarget targetClass, MethodQualifier targetMethod, AtData atData, AnnotationHandle handle) {
         boolean argsOnly = handle.<Boolean>getValue("argsOnly").map(AnnotationValueHandle::get).orElse(false);
-        return new ModifyVariableMixinData(targetClass, targetMethod, atData, argsOnly);
+        Integer ordinal = handle.<Integer>getValue("ordinal").map(AnnotationValueHandle::get).orElse(null);
+        return new ModifyVariableMixinData(targetClass, targetMethod, atData, argsOnly, ordinal);
     }
 
     @Override
     public void preProcess(ModifyVariableMixinData mixin, MixinContext context, MutableConfiguration clean, Recipe recipe) {
         clean.setParameters(MethodParameters.create(context.methodNode().desc, List.of(SINGLE_ANY, LOCALS)));
+
+        recipe.resolvers().getOrThrow(InjectionTargetResolver.class).addSubResolver(new ModifyVarInjectionTargetSubResolver());
     }
 
     @Override
@@ -50,6 +55,10 @@ public void postProcess(ModifyVariableMixinData mixin, MixinContext context, Con
                 dirty.setParameters(newParams);
                 dirty.setReturnType(dirtyVarType);
             }
+            return;
         }
+
+        dirty.inheritParameters();
+        dirty.inheritReturnType();
     }
 }
diff --git a/gradlew b/gradlew
diff --git a/test/build.gradle.kts b/test/build.gradle.kts
@@ -24,7 +24,7 @@ configurations {
 }
 
 dependencies {
-    testCompileOnly(group = "org.sinytra.adapter", name = "definition")
+    testImplementation(group = "org.sinytra.adapter", name = "definition")
     "neoForgeTestLibraries"(group = "org.sinytra.adapter", name = "definition") {
         isTransitive = false
     }
diff --git a/test/src/test/java/org/sinytra/adapter/patch/test/mixin/DynamicMixinPatchTest.java b/test/src/test/java/org/sinytra/adapter/patch/test/mixin/DynamicMixinPatchTest.java
@@ -234,7 +234,7 @@ void testSplitMethodInjectionTarget() throws Exception {
         );
         assertSameCode(
             "org/sinytra/adapter/test/mixin/GuiMixin",
-            "afterMainHud",
+            "moveAirUp",
             assertTargetMethod(),
             assertInjectionPoint()
         );
diff --git a/test/src/test/java/org/sinytra/adapter/patch/test/mixin/MinecraftMixinPatchTest.java b/test/src/test/java/org/sinytra/adapter/patch/test/mixin/MinecraftMixinPatchTest.java
@@ -3,6 +3,7 @@
 import com.mojang.logging.LogUtils;
 import org.apache.commons.lang3.tuple.Pair;
 import org.assertj.core.api.Assertions;
+import org.jetbrains.annotations.Nullable;
 import org.objectweb.asm.ClassReader;
 import org.objectweb.asm.tree.*;
 import org.sinytra.adapter.patch.analysis.selector.AnnotationHandle;
@@ -212,9 +213,9 @@ protected AssertCallback assertTargetMethod() {
     }
 
     protected AssertCallback assertInjectionPoint() {
-        Function<AnnotationNode, Pair<String, String>> injectionPointExtractor = node -> new AnnotationHandle(node).getNested("at").map(h -> {
+        Function<AnnotationNode, Pair<String, @Nullable String>> injectionPointExtractor = node -> new AnnotationHandle(node).getNested("at").map(h -> {
             String value = h.<String>getValue("value").orElseThrow().get();
-            String target = h.<String>getValue("target").orElseThrow().get();
+            String target = h.<String>getValue("target").map(AnnotationValueHandle::get).orElse(null);
             return Pair.of(value, target);
         }).orElseThrow();
 
diff --git a/test/src/testClasses/java/org/sinytra/adapter/test/mixin/GuiMixin.java b/test/src/testClasses/java/org/sinytra/adapter/test/mixin/GuiMixin.java
@@ -13,6 +13,7 @@
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyArg;
+import org.spongepowered.asm.mixin.injection.ModifyVariable;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
 
@@ -130,4 +131,22 @@ private LayeredDraw.Layer afterMainHudExpected(LayeredDraw.Layer mainHudLayer) {
             System.out.println("Hello");
         };
     }
+
+    @ModifyVariable(
+        method = "Lnet/minecraft/client/gui/Gui;renderPlayerHealth(Lnet/minecraft/client/gui/GuiGraphics;)V",
+        at = @At("STORE"),
+        ordinal = 11
+    )
+    private int moveAirUp(int y) {
+        return y;
+    }
+
+    @ModifyVariable(
+        method = "renderAirLevel(Lnet/minecraft/client/gui/GuiGraphics;)V",
+        at = @At("STORE"),
+        ordinal = 1
+    )
+    private int moveAirUpExpected(int y) {
+        return y;
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -3,4 +3,7 @@`
`3`	`3`	`public class MixinAnnotationConstants {`
`4`	`4`	`public static final String AT_METHOD = "method";`
`5`	`5`	`public static final String AT_VAL_INVOKE = "INVOKE";`
	`6`	`+ public static final String AT_VAL_STORE = "STORE";`
	`7`	`+`
	`8`	`+ public static final String PROPERTY_ORDINAL = "ordinal";`
`6`	`9`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,5 +13,6 @@ private void registerDefaultProcessors() {`
`13`	`13`	`add(new InjectionTargetProcessor());`
`14`	`14`	`add(new MixinMethodParametersProcessor());`
`15`	`15`	`add(new ReturnTypeProcessor());`
	`16`	`+ add(new PropertyProcessor());`
`16`	`17`	`}`
`17`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`import org.sinytra.adapter.next.pipeline.config.Configuration;`
`15`	`15`	`import org.sinytra.adapter.next.pipeline.config.MutableConfiguration;`
`16`	`16`	`import org.sinytra.adapter.patch.api.MethodContext;`
	`17`	`+import org.sinytra.adapter.patch.util.AdapterUtil;`
`17`	`18`	`import org.sinytra.adapter.patch.util.MethodQualifier;`
`18`	`19`
`19`	`20`	`import java.util.ArrayList;`
`@@ -111,7 +112,17 @@ private static MethodNode resolveReplacementCandidate(MixinContext context, Clas`
`111`	`112`	`valid.add(method);`
`112`	`113`	`}`
`113`	`114`	`}`
	`115`	`+ if (valid.size() == 1) {`
	`116`	`+ return valid.getFirst();`
	`117`	`+ }`
	`118`	`+`
	`119`	`+ List<MethodNode> nonDeprecated = methods.stream()`
	`120`	`+ .filter(m -> !AdapterUtil.hasAnnotation(m.visibleAnnotations, "Ljava/lang/Deprecated;"))`
	`121`	`+ .toList();`
	`122`	`+ if (nonDeprecated.size() == 1) {`
	`123`	`+ return nonDeprecated.getFirst();`
	`124`	`+ }`
`114`	`125`
`115`		`- return valid.size() == 1 ? valid.getFirst() : null;`
	`126`	`+ return null;`
`116`	`127`	`}`
`117`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,8 @@`
`9`	`9`	`import org.sinytra.adapter.next.pipeline.Recipe;`
`10`	`10`	`import org.sinytra.adapter.next.pipeline.config.Configuration;`
`11`	`11`	`import org.sinytra.adapter.next.pipeline.config.MutableConfiguration;`
	`12`	`+import org.sinytra.adapter.next.pipeline.resolver.InjectionTargetResolver;`
	`13`	`+import org.sinytra.adapter.next.pipeline.resolver.ModifyVarInjectionTargetSubResolver;`
`12`	`14`	`import org.sinytra.adapter.patch.analysis.selector.AnnotationHandle;`
`13`	`15`	`import org.sinytra.adapter.patch.analysis.selector.AnnotationValueHandle;`
`14`	`16`	`import org.sinytra.adapter.patch.fixes.TypeAdapter;`
`@@ -24,12 +26,15 @@ public class ModifyVariableMixin implements MixinType<ModifyVariableMixinData> {`
`24`	`26`	`@Override`
`25`	`27`	`public ModifyVariableMixinData parse(MixinContext context, ClassTarget targetClass, MethodQualifier targetMethod, AtData atData, AnnotationHandle handle) {`
`26`	`28`	`boolean argsOnly = handle.<Boolean>getValue("argsOnly").map(AnnotationValueHandle::get).orElse(false);`
`27`		`- return new ModifyVariableMixinData(targetClass, targetMethod, atData, argsOnly);`
	`29`	`+ Integer ordinal = handle.<Integer>getValue("ordinal").map(AnnotationValueHandle::get).orElse(null);`
	`30`	`+ return new ModifyVariableMixinData(targetClass, targetMethod, atData, argsOnly, ordinal);`
`28`	`31`	`}`
`29`	`32`
`30`	`33`	`@Override`
`31`	`34`	`public void preProcess(ModifyVariableMixinData mixin, MixinContext context, MutableConfiguration clean, Recipe recipe) {`
`32`	`35`	`clean.setParameters(MethodParameters.create(context.methodNode().desc, List.of(SINGLE_ANY, LOCALS)));`
	`36`	`+`
	`37`	`+ recipe.resolvers().getOrThrow(InjectionTargetResolver.class).addSubResolver(new ModifyVarInjectionTargetSubResolver());`
`33`	`38`	`}`
`34`	`39`
`35`	`40`	`@Override`
`@@ -50,6 +55,10 @@ public void postProcess(ModifyVariableMixinData mixin, MixinContext context, Con`
`50`	`55`	`dirty.setParameters(newParams);`
`51`	`56`	`dirty.setReturnType(dirtyVarType);`
`52`	`57`	`}`
	`58`	`+ return;`
`53`	`59`	`}`
	`60`	`+`
	`61`	`+ dirty.inheritParameters();`
	`62`	`+ dirty.inheritReturnType();`
`54`	`63`	`}`
`55`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ configurations {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`dependencies {`
`27`		`- testCompileOnly(group = "org.sinytra.adapter", name = "definition")`
	`27`	`+ testImplementation(group = "org.sinytra.adapter", name = "definition")`
`28`	`28`	`"neoForgeTestLibraries"(group = "org.sinytra.adapter", name = "definition") {`
`29`	`29`	`isTransitive = false`
`30`	`30`	`}`