From 4f4caac67f26f68370ab3f4b07f9e199d1ec99c2 Mon Sep 17 00:00:00 2001
From: yoyosource <yoyosource@nidido.de>
Date: Sat, 25 Feb 2023 15:04:30 +0100
Subject: [PATCH] Fix LinkageProcessor

---
 src/de/steamwar/linkage/LinkageProcessor.java | 24 +++++++++++--------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/de/steamwar/linkage/LinkageProcessor.java b/src/de/steamwar/linkage/LinkageProcessor.java
index f547817..488f9bf 100644
--- a/src/de/steamwar/linkage/LinkageProcessor.java
+++ b/src/de/steamwar/linkage/LinkageProcessor.java
@@ -173,18 +173,15 @@ public class LinkageProcessor extends AbstractProcessor {
 
         Map<String, MethodBuilder> methods = new HashMap<>();
         for (Map.Entry<Set<String>, List<TypeElement>> entry : groupedByChecks.entrySet()) {
-            Map<String, Map<LinkageType, List<TypeElement>>> groupedByMethod = new HashMap<>();
+            Map<String, Map<TypeElement, List<LinkageType>>> groupedByMethod = new HashMap<>();
             for (TypeElement typeElement : entry.getValue()) {
                 for (Map.Entry<String, List<LinkageType>> linkages : getLinkagesOfType(typeElement).entrySet()) {
-                    Map<LinkageType, List<TypeElement>> internalGroup = groupedByMethod.computeIfAbsent(linkages.getKey(), s -> new HashMap<>());
-                    for (LinkageType linkageType : linkages.getValue()) {
-                        List<TypeElement> list = internalGroup.computeIfAbsent(linkageType, s -> new ArrayList<>());
-                        list.add(typeElement);
-                    }
+                    groupedByMethod.computeIfAbsent(linkages.getKey(), ignored -> new HashMap<>())
+                            .put(typeElement, linkages.getValue());
                 }
             }
 
-            for (Map.Entry<String, Map<LinkageType, List<TypeElement>>> group : groupedByMethod.entrySet()) {
+            for (Map.Entry<String, Map<TypeElement, List<LinkageType>>> group : groupedByMethod.entrySet()) {
                 MethodBuilder method = methods.computeIfAbsent(group.getKey(), s -> {
                     MethodBuilder methodBuilder = new MethodBuilder(s, "void");
                     buildPlan.addMethod(methodBuilder);
@@ -192,10 +189,17 @@ public class LinkageProcessor extends AbstractProcessor {
                 });
 
                 if (!entry.getKey().isEmpty()) method.addLine("if (" + String.join(" && ", entry.getKey()) + ") {");
-                for (Map.Entry<LinkageType, List<TypeElement>> toGenerate : group.getValue().entrySet()) {
-                    toGenerate.getValue().forEach(typeElement -> {
+                for (Map.Entry<TypeElement, List<LinkageType>> toGenerate : group.getValue().entrySet()) {
+                    TypeElement typeElement = toGenerate.getKey();
+                    String instance = getElement(typeElement, neededFields);
+                    if (toGenerate.getValue().size() > 1 && instance.startsWith("new ")) {
+                        method.addLine(typeElement.getSimpleName() + " local" + typeElement.getSimpleName().toString() + " = " + instance + ";");
+                        instance = "local" + typeElement.getSimpleName().toString();
+                    }
+                    String finalInstance = instance;
+                    toGenerate.getValue().forEach(linkageType -> {
                         buildPlan.addImport(typeElement.getQualifiedName().toString());
-                        toGenerate.getKey().generateCode(buildPlan, method, getElement(typeElement, neededFields), typeElement);
+                        linkageType.generateCode(buildPlan, method, finalInstance, typeElement);
                     });
                 }
                 if (!entry.getKey().isEmpty()) method.addLine("}");