From dbae5f0bf34d138895cd8d5ef16977e0a5fd6968 Mon Sep 17 00:00:00 2001
From: Su5eD <su5ed@outlook.com>
Date: Fri, 19 Jul 2024 11:38:46 +0200
Subject: [PATCH] Fix lambda expansion analysis

---
 .../adapter/patch/api/MethodTransform.java    |  2 +-
 .../param/ReplaceParametersTransformer.java   |  1 +
 .../MethodTransformationPipeline.java         |  5 ++++
 .../sinytra/adapter/gradle/ClassAnalyzer.java | 25 ++++++++++---------
 4 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/definition/src/main/java/org/sinytra/adapter/patch/api/MethodTransform.java b/definition/src/main/java/org/sinytra/adapter/patch/api/MethodTransform.java
index bf116ef..1306e80 100644
--- a/definition/src/main/java/org/sinytra/adapter/patch/api/MethodTransform.java
+++ b/definition/src/main/java/org/sinytra/adapter/patch/api/MethodTransform.java
@@ -9,7 +9,7 @@
 
 public interface MethodTransform {
     default Codec<? extends MethodTransform> codec() {
-        throw new UnsupportedOperationException("This transform is not serializable");
+        throw new UnsupportedOperationException("Transform %s is not serializable".formatted(getClass()));
     }
 
     default Collection<String> getAcceptedAnnotations() {
diff --git a/definition/src/main/java/org/sinytra/adapter/patch/transformer/operation/param/ReplaceParametersTransformer.java b/definition/src/main/java/org/sinytra/adapter/patch/transformer/operation/param/ReplaceParametersTransformer.java
index 9e9e027..f584650 100644
--- a/definition/src/main/java/org/sinytra/adapter/patch/transformer/operation/param/ReplaceParametersTransformer.java
+++ b/definition/src/main/java/org/sinytra/adapter/patch/transformer/operation/param/ReplaceParametersTransformer.java
@@ -20,6 +20,7 @@
 import static org.sinytra.adapter.patch.PatchInstance.MIXINPATCH;
 import static org.sinytra.adapter.patch.transformer.operation.param.ParamTransformationUtil.findWrapOperationOriginalCall;
 
+// TODO Just add @Coerce if the types are inherited
 public record ReplaceParametersTransformer(int index, Type type, boolean upgradeUsage) implements ParameterTransformer {
     static final Codec<ReplaceParametersTransformer> CODEC = RecordCodecBuilder.create(in -> in.group(
         Codec.intRange(0, 255).fieldOf("index").forGetter(ReplaceParametersTransformer::index),
diff --git a/definition/src/main/java/org/sinytra/adapter/patch/transformer/pipeline/MethodTransformationPipeline.java b/definition/src/main/java/org/sinytra/adapter/patch/transformer/pipeline/MethodTransformationPipeline.java
index 67c3228..95bc50b 100644
--- a/definition/src/main/java/org/sinytra/adapter/patch/transformer/pipeline/MethodTransformationPipeline.java
+++ b/definition/src/main/java/org/sinytra/adapter/patch/transformer/pipeline/MethodTransformationPipeline.java
@@ -36,6 +36,11 @@ private MethodTransformationPipeline(MethodTransform transform, List<Supplier<Me
         this.filters = filters;
     }
 
+    @Override
+    public Codec<? extends MethodTransform> codec() {
+        return CODEC;
+    }
+
     @Override
     public Patch.Result apply(ClassNode classNode, MethodNode methodNode, MethodContext methodContext, PatchContext context) {
         for (MethodTransformFilter filter : filters) {
diff --git a/plugin/src/main/java/org/sinytra/adapter/gradle/ClassAnalyzer.java b/plugin/src/main/java/org/sinytra/adapter/gradle/ClassAnalyzer.java
index 2e50ade..affd06b 100644
--- a/plugin/src/main/java/org/sinytra/adapter/gradle/ClassAnalyzer.java
+++ b/plugin/src/main/java/org/sinytra/adapter/gradle/ClassAnalyzer.java
@@ -382,27 +382,28 @@ private void findExpandedLambdas(List<? super Patch> patches, Map<? super String
             for (int cleanIdx = 0, dirtyIdx = 0; cleanIdx < cleanLambdas.size() && dirtyIdx < dirtyLambdas.size(); ) {
                 String cleanLambda = cleanLambdas.get(cleanIdx);
                 String dirtyLambda = dirtyLambdas.get(cleanIdx);
-                if (cleanLambda.equals(dirtyLambda)) {
+                MethodNode cleanLambdaMethod = findUniqueMethod(this.cleanMethods, cleanLambda);
+                MethodNode dirtyLambdaMethod = findUniqueMethod(this.dirtyMethods, dirtyLambda);
+                if (cleanLambdaMethod.name.equals(dirtyLambdaMethod.name) && cleanLambdaMethod.desc.equals(dirtyLambdaMethod.desc)) {
                     cleanIdx++;
                     dirtyIdx++;
                 } else {
-                    boolean noDirty;
+                    boolean removed = !dirtyLambdas.contains(cleanLambda);
                     // Lambda removed in Forge, ignore
-                    if (noDirty = !dirtyLambdas.contains(cleanLambda)) {
+                    if (removed) {
                         cleanIdx++;
                     }
-                    // Lambda added by Forge, ignore
-                    if (!cleanLambdas.contains(dirtyLambda)) {
+                    if (cleanLambdas.contains(dirtyLambda)) {
+                        cleanIdx++;
                         dirtyIdx++;
 
                         // Lambda (likely) modified by Forge, proceed
-                        if (noDirty) {
-                            MethodNode cleanLambdaMethod = findUniqueMethod(this.cleanMethods, cleanLambda);
-                            MethodNode dirtyLambdaMethod = findUniqueMethod(this.dirtyMethods, dirtyLambda);
+                        if (!removed) {
                             tryFindExpandedMethod(patches, replacementCalls, cleanLambdaMethod, dirtyLambdaMethod);
                         }
-                    } else {
-                        cleanIdx++;
+                    }
+                    // Lambda added by Forge, ignore
+                    else {
                         dirtyIdx++;
                     }
                 }
@@ -453,7 +454,7 @@ private void tryFindExpandedMethod(List<? super PatchInstance> patches, Map<? su
         Type[] parameterTypes = Type.getArgumentTypes(clean.desc);
         LayeredParamsDiffSnapshot diff = EnhancedParamsDiff.compareMethodParameters(clean, dirty);
         if (!diff.isEmpty()) {
-            LayeredParamsDiffSnapshot valid = valiadateSnapshot(diff, parameterTypes, clean, dirty);
+            LayeredParamsDiffSnapshot valid = validateSnapshot(diff, parameterTypes, clean, dirty);
             if (valid == null) {
                 return;
             }
@@ -480,7 +481,7 @@ private void tryFindExpandedMethod(List<? super PatchInstance> patches, Map<? su
         }
     }
 
-    private LayeredParamsDiffSnapshot valiadateSnapshot(LayeredParamsDiffSnapshot snapshot, Type[] parameterTypes, MethodNode clean, MethodNode dirty) {
+    private LayeredParamsDiffSnapshot validateSnapshot(LayeredParamsDiffSnapshot snapshot, Type[] parameterTypes, MethodNode clean, MethodNode dirty) {
         if (!snapshot.replacements().isEmpty()) {
             List<Pair<Integer, Type>> newReplacements = new ArrayList<>(snapshot.replacements());
             List<Pair<Integer, Integer>> swaps = new ArrayList<>();