feat: [NOT WORKING] maybe slowly starts working

Clients/VisualStudioCode/package.json

@@ -3,7 +3,7 @@
   "name": "java-tx-language-extension",
   "displayName": "Java-TX Language Extension",
   "description": "The Language Extension for Java-TX with Typehints and Syntax Checks",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "engines": {
     "vscode": "^1.94.0"
   },
@@ -17,8 +17,8 @@
   "contributes": {
     "commands": [
       {
-        "command": "lspclient.helloWorld",
+        "command": "tx.restartLanguageServer",
-        "title": "Hello World"
+        "title": "TX: Restart Language Server"
       }
     ]
   },

Clients/VisualStudioCode/src/extension.ts

@@ -1,78 +1,85 @@
-// The module 'vscode' contains the VS Code extensibility API
-// Import the module and reference it with the alias vscode in your code below
-
 import * as vscode from 'vscode';
-import { workspace, ExtensionContext } from 'vscode';
 import {
-	LanguageClient,
+  LanguageClient,
-	LanguageClientOptions,
+  LanguageClientOptions,
-	ServerOptions,
+  ServerOptions
-	TransportKind
 } from 'vscode-languageclient/node';
 
+let client: LanguageClient | undefined;   // <— global, damit wir neu starten können
 
+function createClient(context: vscode.ExtensionContext): LanguageClient {
+  const workspaceFolder = context.extensionPath;
 
+  const serverOptions: ServerOptions = {
+    run: {
+      command: 'java',
+      args: ['-Xss2m', '-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"],
+    },
+    debug: {
+      command: 'java',
+      args: [
+      '-Xss2m',
+      '-jar',
+      workspaceFolder + '/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar',
+    ],
+    }
+  };
 
-// This method is called when your extension is activated
+  const clientOptions: LanguageClientOptions = {
-// Your extension is activated the very first time the command is executed
+    documentSelector: [{ scheme: 'file', language: 'java' }],
-export function activate(context: vscode.ExtensionContext) {
+    synchronize: {
+      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.jav')
+    },
+    revealOutputChannelOn: 4
+  };
 
-
+  return new LanguageClient(
-	
+    'javaTxLanguageServer',
-	const workspaceFolder = context.extensionPath;
+    'Java-TX Language Server',
-	const serverOptions: ServerOptions = {
+    serverOptions,
-		run: {
+    clientOptions
-			command: 'java',
+  );
-			args: ['-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"], // Absolute Pfadangabe
-		},
-		debug: {
-			command: 'java',
-			args: ['-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"], // Absolute Pfadangabe für Debug
-		}
-	};
-
-	console.log("SERVER CREATED.")
-	console.log(workspaceFolder)
-	// Clientoptionen: definiere, welche Dateitypen der Client unterstützt
-	const clientOptions: LanguageClientOptions = {
-		documentSelector: [{ scheme: 'file', language: 'java' }],
-		synchronize: {
-			fileEvents: vscode.workspace.createFileSystemWatcher('**/*.jav')
-		},
-		revealOutputChannelOn: 4
-	};
-
-	
-	// Language Client erstellen und starten
-	const client = new LanguageClient(
-		'javaTxLanguageServer',      // ID des Clients
-		'Java-TX Language Server',    // Name des Clients
-		serverOptions,
-		clientOptions
-	);
-
-	// Client starten
-	client.start().then(() => {
-		console.log("Language Client erfolgreich gestartet");
-	}).catch(error => {
-		console.error("Fehler beim Starten des Language Clients:", error);
-	});
-
-	// Use the console to output diagnostic information (console.log) and errors (console.error)
-	// This line of code will only be executed once when your extension is activated
-	console.log('Congratulations, your extension "tx" is now active!');
-
-	// The command has been defined in the package.json file
-	// Now provide the implementation of the command with registerCommand
-	// The commandId parameter must match the command field in package.json
-	const disposable = vscode.commands.registerCommand('lspclient.helloWorld', () => {
-		// The code you place here will be executed every time your command is executed
-		// Display a message box to the user
-		vscode.window.showInformationMessage('Hello World from TX!');
-	});
-
-	context.subscriptions.push(disposable);
 }
 
-// This method is called when your extension is deactivated
+export async function activate(context: vscode.ExtensionContext) {
-export function deactivate() { }
+  client = createClient(context);
+
+  client.start()
+    .then(() => console.log("Language Client erfolgreich gestartet"))
+    .catch(err => console.error("Fehler beim Starten des Language Clients:", err));
+
+  console.log('Congratulations, your extension "tx" is now active!');
+
+  // Beispiel-Command aus deinem Code bleibt
+  const hello = vscode.commands.registerCommand('lspclient.helloWorld', () => {
+    vscode.window.showInformationMessage('Hello World from TX!');
+  });
+  context.subscriptions.push(hello);
+
+  // *** NEU: Restart-Command ***
+  const restart = vscode.commands.registerCommand('tx.restartLanguageServer', async () => {
+    if (!client) {
+      vscode.window.showWarningMessage('Language Client ist nicht initialisiert.');
+      return;
+    }
+    try {
+      await client.stop();   // stoppt den Serverprozess
+      client.dispose();      // räumt Ressourcen auf
+    } catch (e) {
+      console.error('Fehler beim Stoppen des Language Clients:', e);
+    }
+    client = createClient(context); // komplett neu erzeugen
+    try {
+      await client.start();
+      vscode.window.showInformationMessage('Java-TX Language Server neu gestartet.');
+    } catch (e) {
+      console.error('Fehler beim Neustarten des Language Clients:', e);
+      vscode.window.showErrorMessage('Neustart des Language Servers fehlgeschlagen – Details in der Konsole.');
+    }
+  });
+  context.subscriptions.push(restart);
+}
+
+export function deactivate(): Thenable<void> | undefined {
+  return client?.stop();
+}

LanguageServer/src/main/java/de/dhbw/JavaTXTextDocumentService.java

@@ -107,6 +107,14 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
      */
     @Override
     public void didOpen(DidOpenTextDocumentParams params) {
+        cacheService.reset();
+        typeResolver.reset();
+        List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(params.getTextDocument().getText(), params.getTextDocument().getUri());
+        if (!syntaxErrors.isEmpty()) {
+            clientService.publishDiagnostics(params.getTextDocument().getUri(), syntaxErrors);
+        }
+        client.refreshDiagnostics();
+        client.refreshInlayHints();
         textDocuments.put(params.getTextDocument().getUri(), params.getTextDocument().getText());
         textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), params.getTextDocument().getText());
     }
@@ -121,6 +129,10 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     @Override
     public void didChange(DidChangeTextDocumentParams params) {
         logService.log("[didChange] Client triggered didChange Event.", MessageType.Info);
+        cacheService.reset();
+        String fileInput = textDocumentService.getFileOfUri(params.getTextDocument().getUri());
+        textDocuments.put(params.getTextDocument().getUri(), fileInput);
+        textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), fileInput);
         changeHandler.didChange(params);
     }
 
@@ -143,7 +155,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     public void didSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
         logService.log("[didSave] Client triggered didSave-Event.");
         clientService.startLoading("compile-task", "Inferring types...", client);
-        saveHandler.handleSave(didSaveTextDocumentParams);
+        saveHandler.asyncHandle(didSaveTextDocumentParams);
         clientService.stopLoading("compile-task", "Types successfully inferred", client);
         clientService.updateClient(client);
     }

LanguageServer/src/main/java/de/dhbw/handler/ChangeHandler.java

@@ -3,11 +3,11 @@ package de.dhbw.handler;
 import com.google.common.base.Stopwatch;
 import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TypeResolver;
-import de.dhbw.model.DiagnosticsAndTypehints;
+import de.dhbw.model.*;
-import de.dhbw.model.DocumentChanges;
-import de.dhbw.model.LSPVariable;
-import de.dhbw.model.LineCharPosition;
 import de.dhbw.service.*;
+import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.PairTPHequalRefTypeOrWildcardType;
 import org.eclipse.lsp4j.*;
 
 import java.io.BufferedWriter;
@@ -40,27 +40,32 @@ public class ChangeHandler {
 
 
     public static String findAddedWord(String str1, String str2) {
-        String[] words1 = str1.split("\\s+");
-        String[] words2 = str2.split("\\s+");
-
         int i = 0, j = 0;
-        while (i < words1.length && j < words2.length) {
+
-            if (words1[i].equals(words2[j])) {
+        // Suche den ersten Unterschied
-                i++;
+        while (i < str1.length() && j < str2.length() && str1.charAt(i) == str2.charAt(j)) {
-                j++;
+            i++;
-            } else {
+            j++;
-                return words2[j]; // Unterschied gefunden
-            }
         }
 
-        // Falls das neue Wort am Ende steht
+        // Falls alles gleich ist, gibt es nichts Neues
-        if (j < words2.length) {
+        if (i == str1.length() && j == str2.length()) {
-            return words2[j];
+            return null;
         }
 
-        return null; // Kein Unterschied gefunden
+        // Suche ab Ende rückwärts, um den gemeinsamen Suffix zu finden
+        int iEnd = str1.length() - 1;
+        int jEnd = str2.length() - 1;
+        while (iEnd >= i && jEnd >= j && str1.charAt(iEnd) == str2.charAt(jEnd)) {
+            iEnd--;
+            jEnd--;
+        }
+
+        // Der Unterschied liegt nun zwischen j und jEnd in str2
+        return str2.substring(j, jEnd + 1);
     }
 
+
     public void didChange(DidChangeTextDocumentParams params) {
         String currentText = textDocumentService.getFileOfUri(params.getTextDocument().getUri());
 
@@ -68,177 +73,129 @@ public class ChangeHandler {
         params.getContentChanges().forEach(el -> summedUp.set(summedUp.get() + el.getText()));
         textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), summedUp.get());
 
-        DocumentChanges documentChanges = textDocumentService.calculateDifference(currentText, summedUp.get());
-        HashMap<LineCharPosition, String> preciseChanges = documentChanges.getPreciseChanges();
-        HashMap<Integer, List<String>> textChanges;
 
+        List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(summedUp.get(), params.getTextDocument().getUri());
 
-        String type = findAddedWord(currentText, summedUp.get());
+        if (!syntaxErrors.isEmpty()) {
-        logService.log("ADDED TYPE IS: " + type);
+            clientService.publishDiagnostics(params.getTextDocument().getUri(), syntaxErrors);
-
-        //Have to check of old saved Input because the result set and Inlay Hints will be updated according to the old AST which contains the old Positions
-        if (cacheService.getLastSavedFiles().containsKey(params.getTextDocument().getUri())) {
-            DocumentChanges changesFromOldSave = textDocumentService.calculateDifference(cacheService.getLastSavedFiles().get(params.getTextDocument().getUri()), summedUp.get());
-            ;
-            textChanges = changesFromOldSave.getTextChanges();
-            preciseChanges = changesFromOldSave.getPreciseChanges();
-            logService.log(textChanges.values().stream().map(el -> String.join(", ", el)).collect(Collectors.joining("\n")));
-        } else {
-            textChanges = documentChanges.getTextChanges();
         }
+        logService.log("Found [" + syntaxErrors.size() + "] Syntax Errors in Document.");
 
+        if (syntaxErrors.isEmpty()) {
 
-        String input = summedUp.get();
+            String type = findAddedWord(currentText, summedUp.get());
+            String input = summedUp.get();
 
+            logService.log("Variables are: " + cacheService.getVariables().size());
 
-        logService.log("Variables are: " + cacheService.getVariables().size());
+            boolean shouldCalculate = false;
 
-
+            logService.log("Type is here: " + type);
-        AtomicBoolean needToCalculate = new AtomicBoolean(false);
+            for (LSPVariable variable : cacheService.getVariables()) {
-
+                for (Type variableType : variable.getPossibleTypes()) {
-        cacheService.getVariables().forEach(
+                    logService.log(variableType.getType() + " <> "+ type.replaceAll(" ", "") + ": " + type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", "")));
-                el -> el.getPossibleTypes().forEach(pos -> needToCalculate.set(needToCalculate.get() || pos.getType().equalsIgnoreCase(type)))
+                    shouldCalculate = shouldCalculate || type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", ""));
-        );
+                    if (shouldCalculate) {
-
+                        break;
-
+                    }
-
+                }
-        if (false) {
-            typeResolver.reduceCurrent(preciseChanges, cacheService.getVariables());
-            try {
-                File tempDir = new File(System.getProperty("java.io.tmpdir"));
-                File tempFile = File.createTempFile("newText", ".tmp", tempDir);
-                FileWriter fileWriter = new FileWriter(tempFile, true);
-                System.out.println(tempFile.getAbsolutePath());
-                BufferedWriter bw = new BufferedWriter(fileWriter);
-                bw.write(summedUp.get());
-                bw.close();
-                typeResolver.updateAst(tempFile.toURI().getPath());
-                tempFile.delete();
-            } catch (Exception e) {
-                logService.log(e.getMessage());
             }
 
+            logService.log("Should Calculate is: " + shouldCalculate);
 
-            var sWatch = Stopwatch.createUnstarted();
+            if (false) {
-            sWatch.start();
+                try {
-
+                    File tempDir = new File(System.getProperty("java.io.tmpdir"));
-            try {
+                    File tempFile = File.createTempFile("newText", ".tmp", tempDir);
-
+                    FileWriter fileWriter = new FileWriter(tempFile, true);
-                String currentInput = textDocumentService.getFileOfUri(params.getTextDocument().getUri());
+                    System.out.println(tempFile.getAbsolutePath());
-
+                    BufferedWriter bw = new BufferedWriter(fileWriter);
-                if (currentInput == null) {
+                    bw.write(summedUp.get());
-                    logService.log("[didChange] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
+                    bw.close();
+                    typeResolver.updateAst(tempFile.toURI().getPath());
+                    tempFile.delete();
+                } catch (Exception e) {
+                    logService.log(e.getMessage());
                 }
 
-                ArrayList<LSPVariable> typesOfMethodAndParameters = typeResolver.infereChangeInput(params.getTextDocument().getUri());
+                var sWatch = Stopwatch.createUnstarted();
-
+                sWatch.start();
-
-                DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(typesOfMethodAndParameters, params.getTextDocument().getUri());
-
-                List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
-                List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
-
-
-                cacheService.updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
-
-
-            } catch (Exception e) {
-                logService.log("[didChange] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
-
-                for (var stackTrace : e.getStackTrace()) {
-                    logService.log(stackTrace.toString());
-                }
-
-                clientService.showMessage(MessageType.Error, e.getMessage());
-                cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), params.getTextDocument().getUri());
-
-            } finally {
-                sWatch.stop();
-                logService.log("[didChange] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
-            }
-
-
-            //updatePositions(params, offsetPerLine);
-
-
-            cacheService.getGlobalInlayHintMap().put(params.getTextDocument().getUri(), cacheService.getGlobalInlayHintMap().get(params.getTextDocument().getUri()).stream().filter(el -> {
-                //TODO: Hier das Label aufspalten an | weil die Typehints immer mit und getrennt sind und so jeder Typhint für sich durchlaufen werden kann.
-                logService.log(el.getLabel().getLeft().replaceAll(" ", "") + "<>" + String.join(",", textChanges.get(el.getPosition().getLine())) + ": " + (!textChanges.get(el.getPosition().getLine()).contains(el.getLabel().getLeft().replaceAll(" ", "")) ? "true" : "false"), MessageType.Info);
-                return !textChanges.get(el.getPosition().getLine()).contains(el.getLabel().getLeft().replaceAll(" ", ""));
-            }).toList());
-
-            cacheService.getGlobalDiagnosticsMap().put(params.getTextDocument().getUri(), cacheService.getGlobalDiagnosticsMap().get(params.getTextDocument().getUri()).stream().filter(el -> {
-                logService.log(el.getMessage().replaceAll(" ", "") + "<>" + String.join(",", textChanges.get(el.getRange().getStart().getLine())) + ": " + (!textChanges.get(el.getRange().getStart().getLine()).contains(el.getMessage().replaceAll(" ", "")) ? "true" : "false"), MessageType.Info);
-                return !textChanges.get(el.getRange().getStart().getLine()).contains(el.getMessage().replaceAll(" ", ""));
-            }).toList());
-
-            List<Diagnostic> typeDiagnostics = cacheService.getGlobalDiagnosticsMap().get(params.getTextDocument().getUri());
-            List<Diagnostic> parserErrors = parserService.getDiagnosticsOfErrors(input, params.getTextDocument().getUri());
-
-            ArrayList<Diagnostic> allDiagnostics = new ArrayList<>(typeDiagnostics);
-            allDiagnostics.addAll(parserErrors);
-
-            clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
-        } else {
-            var sWatch = Stopwatch.createUnstarted();
-            sWatch.start();
-
-            try {
-
-                String fileInput = input;
-                logService.log("Input ist:");
-                logService.log(fileInput);
-//                cacheService.getLastSavedFiles().put(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
-//                typeResolver.getCompilerInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
 
                 try {
-                    File tempDir2 = new File(System.getProperty("java.io.tmpdir"));
+                    ArrayList<LSPVariable> typesOfMethodAndParameters = typeResolver.infereChangeInput();
-                    File tempFile2 = File.createTempFile("newText", ".tmp", tempDir2);
+                    DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(typesOfMethodAndParameters, params.getTextDocument().getUri());
-                    FileWriter fileWriter = new FileWriter(tempFile2, true);
-                    BufferedWriter bw = new BufferedWriter(fileWriter);
-                    bw.write(fileInput);
-                    bw.close();
-
-
-                    if (fileInput == null) {
-                        logService.log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
-                    }
-
-                    ArrayList<LSPVariable> variables = typeResolver.infereInput(tempFile2.toURI().toString(), fileInput, false);
-                    cacheService.setVariables(variables);
-
-                    DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehintsWithInput(variables, input);
 
                     List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
                     List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
 
                     cacheService.updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
 
-                    List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
-                    allDiagnostics.addAll(parserService.getDiagnosticsOfErrors(fileInput, params.getTextDocument().getUri()));
-
-                    clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
-
-                    tempFile2.delete();
                 } catch (Exception e) {
-                    logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+                    logService.log("[didChange] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
-
+                    for (var stackTrace : e.getStackTrace()) {
-                    for (StackTraceElement elem : e.getStackTrace()) {
+                        logService.log(stackTrace.toString());
-                        logService.log(elem.toString());
                     }
-                    clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+
+                    clientService.showMessage(MessageType.Error, e.getMessage());
                     cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), params.getTextDocument().getUri());
 
                 } finally {
                     sWatch.stop();
-                    logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
+                    logService.log("[didChange] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
-
                 }
 
-            } catch (Exception e) {
+                List<Diagnostic> typeDiagnostics = cacheService.getGlobalDiagnosticsMap().get(params.getTextDocument().getUri());
-                logService.log(e.getMessage());
+                ArrayList<Diagnostic> allDiagnostics = new ArrayList<>(typeDiagnostics);
-            }
+                clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
+            } else {
+                logService.log("Calculating again.");
+                var sWatch = Stopwatch.createUnstarted();
+                sWatch.start();
 
+                try {
+                    try {
+                        File tempDir2 = new File(System.getProperty("java.io.tmpdir"));
+                        File tempFile2 = File.createTempFile("newText", ".tmp", tempDir2);
+                        FileWriter fileWriter = new FileWriter(tempFile2, true);
+                        BufferedWriter bw = new BufferedWriter(fileWriter);
+                        bw.write(input);
+                        bw.close();
+
+                        ArrayList<LSPVariable> variables = typeResolver.infereInput(tempFile2.toURI().toString(), input, false);
+                        cacheService.setVariables(variables);
+
+                        DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehintsWithInput(variables, input);
+
+                        List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+                        List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
+
+                        cacheService.updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
+
+                        List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
+                        allDiagnostics.addAll(parserService.getDiagnosticsOfErrors(input, params.getTextDocument().getUri()));
+
+                        clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
+
+                        tempFile2.delete();
+                    } catch (Exception e) {
+                        logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+
+                        for (StackTraceElement elem : e.getStackTrace()) {
+                            logService.log(elem.toString());
+                        }
+                        clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+                        cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), params.getTextDocument().getUri());
+
+                    } finally {
+                        sWatch.stop();
+                        logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
+                    }
+
+                } catch (Exception e) {
+                    logService.log(e.getMessage());
+                }
+
+            }
         }
     }
 

LanguageServer/src/main/java/de/dhbw/handler/CodeActionHandler.java

@@ -5,7 +5,7 @@ import de.dhbw.helper.TypeResolver;
 import de.dhbw.service.CacheService;
 import de.dhbw.service.LogService;
 import de.dhbw.service.TextDocumentService;
-import de.dhbwstuttgart.typedeployment.TypeInsert;
+import de.dhbw.model.PlaceholderVariable;
 import org.eclipse.lsp4j.*;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 
@@ -100,13 +100,10 @@ public class CodeActionHandler {
     public List<Either<Command, CodeAction>> handleNewCodeAction(CodeActionParams params) {
 
         String documentUri = params.getTextDocument().getUri();
-
-
-        List<Diagnostic> diagnosticInCurrentDocument = params.getContext().getDiagnostics();
         Range rangeOfInsert = params.getRange();
 
         //All Diagnostics that are in range of the hover -> All Diagnostics of the selected Variable and thus all Types of the Variable
-        Map<String, List<TypeInsert>> typeInsertsOverlapping = getOverlapping(typeResolver.getInserts(), rangeOfInsert.getStart().getLine()+1, rangeOfInsert.getStart().getCharacter(), rangeOfInsert.getEnd().getCharacter());
+        Map<String, List<PlaceholderVariable>> typeInsertsOverlapping = getOverlapping(typeResolver.getInserts(), rangeOfInsert.getStart().getLine()+1, rangeOfInsert.getStart().getCharacter(), rangeOfInsert.getEnd().getCharacter());
         logService.log("Inserts are:");
         typeResolver.getInserts().forEach((key, value) -> logService.log(key));
         logService.log("Size is: " + typeInsertsOverlapping.size());

LanguageServer/src/main/java/de/dhbw/handler/SaveHandler.java

@@ -1,15 +1,27 @@
 package de.dhbw.handler;
 
 import com.google.common.base.Stopwatch;
+import de.dhbw.helper.ResultListener;
 import de.dhbw.model.DiagnosticsAndTypehints;
 import de.dhbw.service.*;
 import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TypeResolver;
 import de.dhbw.model.LSPVariable;
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
+import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.target.generate.GenerateGenerics;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import org.apache.commons.io.output.NullOutputStream;
 import org.eclipse.lsp4j.*;
 
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
 import java.net.URI;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -37,42 +49,46 @@ public class SaveHandler {
 
     public void handleSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
 
+        cacheService.reset();
+        typeResolver.reset();
         var sWatch = Stopwatch.createUnstarted();
         sWatch.start();
 
+
         try {
 
             String fileInput = textDocumentService.getFileOfUri(didSaveTextDocumentParams.getTextDocument().getUri());
-            cacheService.getLastSavedFiles().put(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
-            //typeResolver.getCompilerInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
 
-            if (fileInput == null) {
+            List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(fileInput, didSaveTextDocumentParams.getTextDocument().getUri());
-                logService.log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
+            if (!syntaxErrors.isEmpty()) {
+                clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), syntaxErrors);
             }
+            logService.log("Found [" + syntaxErrors.size() + "] Syntax Errors in Document.");
 
-            ArrayList<LSPVariable> variables = typeResolver.infereInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput, false);
+            if (syntaxErrors.isEmpty()) {
-            cacheService.setVariables(variables);
 
-            DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(variables, didSaveTextDocumentParams.getTextDocument().getUri());
+                cacheService.getLastSavedFiles().put(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
+                //typeResolver.getCompilerInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
 
-            List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+                if (fileInput == null) {
-            List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
+                    logService.log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
+                }
 
-            cacheService.updateGlobalMaps(diagnostics, typeHint, didSaveTextDocumentParams.getTextDocument().getUri());
+                ArrayList<LSPVariable> variables = typeResolver.infereInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput, false);
+                cacheService.setVariables(variables);
 
-            List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
+                DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(variables, didSaveTextDocumentParams.getTextDocument().getUri());
-            allDiagnostics.addAll(parserService.getDiagnosticsOfErrors(fileInput, didSaveTextDocumentParams.getTextDocument().getUri()));
 
-            clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), allDiagnostics);
+                List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+                List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
 
-//            LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+                cacheService.updateGlobalMaps(diagnostics, typeHint, didSaveTextDocumentParams.getTextDocument().getUri());
-//            Path path = Paths.get(new URI(didSaveTextDocumentParams.getTextDocument().getUri())).getParent();
+
-//            logService.log("Path is: " + path.toString());
+                List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
-//
+
-//            try{
+                clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), allDiagnostics);
-//                path.toFile().mkdirs();
+
-//            }catch (Exception e){}
+            }
-//            languageServerInterface.generateBytecode(path.toUri());
 
         } catch (Exception e) {
             logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
@@ -88,4 +104,28 @@ public class SaveHandler {
             logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
         }
     }
+
+
+
+
+
+    public void asyncHandle(DidSaveTextDocumentParams didSaveTextDocumentParams) {
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+        try {
+            ResultListener resultListener = new ResultListener(typeResolver, didSaveTextDocumentParams, cacheService, conversionHelper, clientService);
+            resultListener.init(didSaveTextDocumentParams);
+
+        } catch (Exception e) {
+            logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+
+            for (StackTraceElement elem : e.getStackTrace()) {
+                logService.log(elem.toString());
+            }
+            clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+            cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), didSaveTextDocumentParams.getTextDocument().getUri());
+
+        }
+    }
 }

LanguageServer/src/main/java/de/dhbw/helper/ASTTransformationHelper.java

@@ -1,162 +1,98 @@
 package de.dhbw.helper;
 
-import de.dhbw.model.*;
+import de.dhbw.model.PlaceholderPoint;
-import de.dhbwstuttgart.languageServerInterface.model.LanguageServerTransferObject;
+import de.dhbw.model.PlaceholderType;
+import de.dhbw.model.PlaceholderVariable;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
 import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.Pattern;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.statement.Assign;
+import de.dhbwstuttgart.syntaxtree.type.*;
-import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.target.generate.GenerateGenerics;
-import de.dhbwstuttgart.syntaxtree.statement.Statement;
+import de.dhbwstuttgart.target.generate.GenericsResult;
-import org.apache.log4j.Logger;
+import de.dhbwstuttgart.target.generate.GenericsResultSet;
 
+import de.dhbwstuttgart.typeinference.result.*;
+import org.antlr.v4.runtime.Token;
 
-import java.util.ArrayList;
+import java.util.HashSet;
-import java.util.List;
+import java.util.Set;
-import java.util.stream.Collectors;
 
 public class ASTTransformationHelper {
 
-    private static final Logger log = Logger.getLogger(ASTTransformationHelper.class);
+    public static Set<PlaceholderVariable> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults, GenericsResult generics) {
-    private final DuplicationUtils duplicationUtils;
+    	return new PlaceholderPlacer().getTypeInserts(forSourcefile, withResults, generics);
-    private final TypeUtils typeUtils;
-    private final GenericUtils genericUtils;
-
-    public ASTTransformationHelper(DuplicationUtils duplicationUtils, TypeUtils typeUtils, GenericUtils genericUtils) {
-        this.duplicationUtils = duplicationUtils;
-        this.typeUtils = typeUtils;
-        this.genericUtils = genericUtils;
     }
 
-    public List<LSPParameter> constructorToVariable(LanguageServerTransferObject transferObject) {
+    public static PlaceholderVariable createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
+														 ResultSet resultSet, GenericsResultSet constraints, GenericsResultSet classConstraints) {
 
-        List<LSPParameter> methodsWithParametersLSPVariableList = new ArrayList<>();
+			ResolvedType resolvedType = resultSet.resolveType(type);
+			PlaceholderPoint insertPoint = new PlaceholderPoint(offset,
+					new PlaceholderToInsertString(resolvedType.resolvedType, constraints, classConstraints).insert, PlaceholderType.NORMAL_INSERT);
+			return new PlaceholderVariable(insertPoint, createGenericInsert(constraints, classConstraints, cl, m, resultSet, offset), resolvedType.getResultPair());
+    }
 
-        for (var constructor : transferObject.getAst().KlassenVektor.getFirst().getConstructors()) {
+    private static synchronized Set<PlaceholderPoint> createGenericInsert(GenericsResultSet methodConstraints, GenericsResultSet classConstraints, ClassOrInterface cl, Method m, ResultSet resultSet, Token mOffset){
-            for (var constructorParam : constructor.getParameterList().getFormalparalist()) {
+        Set<PlaceholderPoint> result = createGenericClassInserts(classConstraints, cl);
-                var types = typeUtils.getAvailableTypes(transferObject.getResultSets(), constructorParam.getType());
+    	
-                methodsWithParametersLSPVariableList.add(new LSPParameter("", types, constructorParam.getOffset().getLine(), constructorParam.getOffset().getCharPositionInLine(), constructorParam.getOffset().getStopIndex(), constructorParam.getType()));
+    	if (m != null) {
+        	result.addAll(createMethodConstraints(methodConstraints, m.getOffset() != null ? m.getOffset() : mOffset));
+    	}
+        
+        return result;
+    }
+    
+    private static Set<PlaceholderPoint> createMethodConstraints(GenericsResultSet constraints, Token mOffset) {
+    	Set<PlaceholderPoint> result = new HashSet<>();
+    	Token offset = mOffset;
+
+		if (constraints.size() == 0) {
+			return result;
+		} 
+		
+		String insert = " <";
+
+        for (var genericInsertConstraint : constraints) {
+        	if (genericInsertConstraint instanceof GenerateGenerics.PairEQ peq) {
+        		insert += peq.left.resolve().getName();
+        	} else if (genericInsertConstraint instanceof GenerateGenerics.PairLT psm) {
+        		insert += psm.left.resolve().getName() + " extends " + psm.right.resolve().getName();
+        	}
+        	insert += ", ";
+        }
+        
+        insert = insert.substring(0, insert.length() -2);
+        insert += ">";
+
+        result.add(new PlaceholderPoint(offset, insert, PlaceholderType.GENERERIC_METHOD_INSERT));
+    	return result;
+    }
+
+	private static Set<PlaceholderPoint> createGenericClassInserts(GenericsResultSet classConstraints, ClassOrInterface cl) {
+		Set<PlaceholderPoint> result = new HashSet<>();
+		Token offset = cl.getGenerics().getOffset();
+
+		if (classConstraints == null || classConstraints.size() == 0) {
+			return result;
+		} 
+		
+		String insert = " <";
+
+        for (var genericInsertConstraint : classConstraints) {
+            if (genericInsertConstraint instanceof GenerateGenerics.PairEQ peq) {
+                insert += peq.left.resolve().getName();
+            } else if (genericInsertConstraint instanceof GenerateGenerics.PairLT psm) {
+                insert += psm.left.resolve().getName() + " extends " + psm.right.resolve().getName();
             }
+            insert += ", ";
         }
 
-        return methodsWithParametersLSPVariableList;
+        insert = insert.substring(0, insert.length() -2);
-    }
+        insert += ">";
-
-    public List<LSPParameter> fieldDeclToVariable(LanguageServerTransferObject transferObject) {
-
-        List<LSPParameter> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-        for (var fieldDecl : transferObject.getAst().KlassenVektor.getFirst().getFieldDecl()) {
-            var types = typeUtils.getAvailableTypes(transferObject.getResultSets(), fieldDecl.getReturnType());
-            methodsWithParametersLSPVariableList.add(new LSPParameter("", types, fieldDecl.getOffset().getLine(), fieldDecl.getOffset().getCharPositionInLine(), fieldDecl.getOffset().getStopIndex(), fieldDecl.getReturnType()));
-        }
-
-        if (transferObject.getAst().KlassenVektor.getFirst().getfieldInitializations().isPresent()) {
-            methodsWithParametersLSPVariableList.addAll(lambdaExpressionToVariable(transferObject.getAst().KlassenVektor.getFirst().getfieldInitializations().get().block.statements, transferObject));
-        }
-
-        return methodsWithParametersLSPVariableList;
-    }
-
-    public List<LSPClass> addGenericClassPosition(LanguageServerTransferObject transferObject, String input) {
-
-        List<LSPClass> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-//        for (var method : transferObject.getAst().getAllMethods()) {
-//            for (var clazz : transferObject.getAst().getClasses()) {
-//                ArrayList<Type> genericTypes = genericUtils.getClassGenerics(transferObject.getGeneratedGenerics(), method, clazz);
-//                TextHelper helper = new TextHelper();
-//                if (!genericTypes.isEmpty()) {
-//                    methodsWithParametersLSPVariableList.add(new LSPClass("test", genericTypes, clazz.getOffset().getLine(), helper.getClassPositionForGeneric(clazz.getOffset().getLine() - 1, input, clazz.getOffset().getStopIndex()), clazz.getOffset().getStopIndex(), clazz.getReturnType()));
-//                }
-//            }
-//
-//        }
-
-        return methodsWithParametersLSPVariableList;
-    }
-
-
-    public List<LSPVariable> methodsWithParameterToVariable(LanguageServerTransferObject transferObj, boolean ENABLE_GENERICS) {
-        List<LSPVariable> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-        for (var method : transferObj.getAst().getAllMethods()) {
-            methodsWithParametersLSPVariableList.addAll(methodToVariable(transferObj, method, ENABLE_GENERICS));
-
-            for (var param : method.getParameterList()) {
-                methodsWithParametersLSPVariableList.addAll(parameterToVariable(transferObj, param, method, ENABLE_GENERICS));
-            }
-            methodsWithParametersLSPVariableList.addAll(lambdaExpressionToVariable(method.block.statements, transferObj));
-        }
-        return methodsWithParametersLSPVariableList;
-    }
-
-
-    private List<LSPParameter> lambdaExpressionToVariable(List<Statement> statements, LanguageServerTransferObject transferObj) {
-        List<LSPParameter> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-        for (var statement : statements) {
-
-            if (statement instanceof Assign assign) {
-
-                if (assign.rightSide instanceof LambdaExpression lambdaExpression)
-
-                    for (var param : lambdaExpression.params.getFormalparalist()) {
-                        var types = typeUtils.getAvailableTypes(transferObj.getResultSets(), param.getType());
-                        methodsWithParametersLSPVariableList.add(new LSPParameter("", types, param.getOffset().getLine(), param.getOffset().getCharPositionInLine(), param.getOffset().getStopIndex(), param.getType()));
-
-                    }
-
-            }
-        }
-
-        return methodsWithParametersLSPVariableList;
-    }
-
-    private List<LSPMethod> methodToVariable(LanguageServerTransferObject transferObj, Method method, boolean ENABLE_GENERICS) {
-        List<LSPMethod> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-        var types = typeUtils.getAvailableTypes(transferObj.getResultSets(), method);
-        if (!duplicationUtils.filterOutDuplicates(types).isEmpty()) {
-            methodsWithParametersLSPVariableList.add(new LSPMethod(method.name, duplicationUtils.filterOutDuplicates(types), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-        }
-
-        if (ENABLE_GENERICS) {
-            var generics = genericUtils.getAvailableGenericTypes(transferObj.getGeneratedGenerics().values().stream().flatMap(List::stream).collect(Collectors.toList()), method);
-            if (!generics.isEmpty()) {
-                ArrayList<Type> typesThatAreGeneric = duplicationUtils.filterOutDuplicates(generics, types);
-                typesThatAreGeneric.forEach(el -> el.setType("<" + el.getType() + "> " + el.getType()));
-                //TODO: Muss Global und wird mehrmals so gemacht. Das if hier ist eigentlich falsch wegen unnötiger Berechnungszeit
-                if (!duplicationUtils.filterOutDuplicates(typesThatAreGeneric).isEmpty()) {
-                    methodsWithParametersLSPVariableList.add(new LSPMethod(method.name, duplicationUtils.filterOutDuplicates(typesThatAreGeneric), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-                }
-            }
-        }
-
-        return methodsWithParametersLSPVariableList;
-    }
-
-    private List<LSPParameter> parameterToVariable(LanguageServerTransferObject transferObj, Pattern param, Method method, boolean ENABLE_GENERICS) {
-        List<LSPParameter> parameters = new ArrayList<>();
-
-        ArrayList<Type> typeParam = typeUtils.getAvailableTypes(transferObj.getResultSets(), param.getType());
-
-        if (!typeParam.isEmpty()) {
-            parameters.add(new LSPParameter(method.name, duplicationUtils.filterOutDuplicates(typeParam), param.getOffset().getLine(), param.getOffset().getCharPositionInLine(), param.getOffset().getStopIndex(), param.getType()));
-        }
-
-        if (ENABLE_GENERICS) {
-            ArrayList<Type> genericParam = genericUtils.getAvailableGenericTypes(transferObj.getGeneratedGenerics().values().stream().flatMap(List::stream).collect(Collectors.toList()), param.getType());
-            if (!genericParam.isEmpty()) {
-                ArrayList<Type> typesThatAreGeneric = duplicationUtils.filterOutDuplicates(genericParam, typeParam);
-
-                if (!duplicationUtils.filterOutDuplicates(typesThatAreGeneric).isEmpty()) {
-                    parameters.add(new LSPParameter(method.name, duplicationUtils.filterOutDuplicates(typesThatAreGeneric), method.getOffset().getLine(), param.getOffset().getCharPositionInLine(), param.getOffset().getStopIndex(), param.getType()));
-                    parameters.add(new LSPParameter(method.name, new ArrayList<>(duplicationUtils.filterOutDuplicates(typesThatAreGeneric).stream().map(el -> new Type("<" + el.getType() + ">", true)).toList()), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-                }
-            }
-        }
-
-        return parameters;
-    }
 
+        result.add(new PlaceholderPoint(offset, insert, PlaceholderType.GENERIC_CLASS_INSERT));
+        
+        return result;
+	}
 }
+

LanguageServer/src/main/java/de/dhbw/helper/GenericUtils.java

@@ -1,69 +0,0 @@
-package de.dhbw.helper;
-
-import de.dhbw.model.Type;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Method;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
-import de.dhbwstuttgart.target.generate.GenericsResult;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
-public class GenericUtils {
-    public ArrayList<Type> getClassGenerics(Map<SourceFile, List<GenericsResult>> genericsResult, Method method, ClassOrInterface clazz) {
-        ArrayList<Type> genericTypes = new ArrayList<>();
-
-        genericsResult.forEach(((key, value) -> value.forEach(genericResultSet -> {
-
-            var result = genericResultSet.resolveTarget(method.getReturnType());
-
-
-            var genericResult = genericResultSet.getBounds(method.getReturnType(), clazz, method);
-            if (result != null && genericResult != null) {
-                genericResult.forEach(res -> {
-                            if (res != null && !res.isOnMethod()) {
-                                genericTypes.add(new Type("<" + result.name() + (res.bound().toString().equals("java.lang.Object") ? ">" : " extends " + res.bound().toString() + ">"), true));
-
-                            }
-                        }
-                );
-            }
-
-        })));
-
-        return genericTypes;
-    }
-
-    public ArrayList<Type> getAvailableGenericTypes(List<GenericsResult> genericsResult, RefTypeOrTPHOrWildcardOrGeneric parameter) {
-
-
-        ArrayList<String> paramTypes = new ArrayList<>();
-        genericsResult.forEach(conSet -> {
-            if (parameter.toString().toLowerCase().contains("tph ")) {
-                paramTypes.add(conSet.resolveTarget(parameter).name());
-            }
-        });
-
-        return new ArrayList<>(paramTypes.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, true)).toList());
-
-    }
-
-    public ArrayList<Type> getAvailableGenericTypes(List<GenericsResult> genericsResult, Method method) {
-
-        ArrayList<String> genericTypes = new ArrayList<>();
-
-        genericsResult.forEach(conSet -> {
-            if (method.getReturnType().toString().toLowerCase().contains("tph ")) {
-                if (conSet.resolveTarget(method.getReturnType()) != null && conSet.resolveTarget(method.getReturnType()).name() != null && conSet.resolveTarget(method.getReturnType()).name().contains("GTV")) {
-                    genericTypes.add(conSet.resolveTarget(method.getReturnType()).name().replaceAll("GTV ", ""));
-                }
-            }
-        });
-
-
-        return new ArrayList<>(genericTypes.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, true)).toList());
-
-    }
-}

LanguageServer/src/main/java/de/dhbw/helper/PlaceholderPlacer.java

@@ -0,0 +1,31 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.PlaceholderVariable;
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class PlaceholderPlacer extends AbstractASTWalker {
+    Set<PlaceholderVariable> inserts = new HashSet<>();
+    private ResultSet withResults;
+    String pkgName;
+    private GenericsResult genericsResult;
+
+    public Set<PlaceholderVariable> getTypeInserts(SourceFile forSourceFile, ResultSet withResults, GenericsResult genericsResult){
+        this.withResults = withResults;
+        this.genericsResult = genericsResult;
+        pkgName = forSourceFile.getPkgName();
+        forSourceFile.accept(this);
+        return inserts;
+    }
+
+    @Override
+    public void visit(ClassOrInterface classOrInterface) {
+        de.dhbw.helper.PlaceholderPlacerClass cl = new de.dhbw.helper.PlaceholderPlacerClass(classOrInterface, withResults, genericsResult);
+        this.inserts.addAll(cl.inserts);
+    }
+}
+

LanguageServer/src/main/java/de/dhbw/helper/PlaceholderPlacerClass.java

@@ -0,0 +1,65 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.PlaceholderVariable;
+import de.dhbwstuttgart.syntaxtree.*;
+import de.dhbwstuttgart.syntaxtree.statement.LambdaExpression;
+import de.dhbwstuttgart.syntaxtree.type.TypePlaceholder;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.target.generate.GenericsResultSet;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.HashSet;
+import java.util.Set;
+
+class PlaceholderPlacerClass extends AbstractASTWalker{
+    protected final ResultSet results;
+    private GenericsResult generatedGenerics;
+    protected final ClassOrInterface cl;
+    public final Set<PlaceholderVariable> inserts = new HashSet<>();
+    private Method method;
+
+    GenericsResultSet constraints;
+	GenericsResultSet classConstraints;
+
+    PlaceholderPlacerClass(ClassOrInterface forClass, ResultSet withResults, GenericsResult generatedGenerics){
+        this.cl = forClass;
+        this.method = null;
+        this.results = withResults;
+        this.generatedGenerics = generatedGenerics;
+        forClass.accept(this);
+    }
+
+    @Override
+    public void visit(Method method) {
+        this.method = method;
+        constraints = generatedGenerics.get(method);
+		classConstraints = generatedGenerics.get(cl);
+        if(method.getReturnType() instanceof TypePlaceholder)
+            inserts.add(ASTTransformationHelper.createInsertPoints(
+                    method.getReturnType(), method.getReturnType().getOffset(), cl, method, results, constraints, classConstraints));
+        super.visit(method);
+    }
+
+    @Override
+    public void visit(Field field) {
+        if(field.getType() instanceof TypePlaceholder){
+        	classConstraints = generatedGenerics.get(cl);
+                inserts.add(ASTTransformationHelper.createInsertPoints(
+                        field.getType(), field.getType().getOffset(), cl, method, results, null, classConstraints));
+        }
+        super.visit(field);
+    }
+
+    @Override
+    public void visit(FormalParameter param) {
+            if(param.getType() instanceof TypePlaceholder)
+                inserts.add(ASTTransformationHelper.createInsertPoints(
+                        param.getType(), param.getType().getOffset(), cl, method, results, constraints, classConstraints));
+        super.visit(param);
+    }
+
+    @Override
+    public void visit(LambdaExpression lambdaExpression) {
+        //Lambda-Ausdrücke brauchen keine Typeinsetzungen
+    }
+}

LanguageServer/src/main/java/de/dhbw/helper/PlaceholderToInsertString.java

@@ -0,0 +1,77 @@
+package de.dhbw.helper;
+
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.target.generate.GenericsResultSet;
+import de.dhbwstuttgart.typeinference.result.*;
+
+import java.util.Iterator;
+
+public class PlaceholderToInsertString implements ResultSetVisitor{
+    public String insert = "";
+    private GenericsResultSet constraints;
+    private GenericsResultSet classConstraints;
+    
+
+    public PlaceholderToInsertString(RefTypeOrTPHOrWildcardOrGeneric type, GenericsResultSet constraints, GenericsResultSet classConstraints){
+        this.constraints = constraints;
+        this.classConstraints = classConstraints;
+    	type.accept(this);
+    }
+
+    @Override
+    public void visit(PairTPHsmallerTPH p) {
+
+    }
+
+    @Override
+    public void visit(PairTPHequalRefTypeOrWildcardType p) {
+
+    }
+
+    @Override
+    public void visit(PairTPHEqualTPH p) {
+
+    }
+
+    @Override
+    public void visit(RefType resolved) {
+        insert = resolved.getName().toString();
+        if(resolved.getParaList().size() > 0){
+            insert += "<";
+            Iterator<RefTypeOrTPHOrWildcardOrGeneric> iterator = resolved.getParaList().iterator();
+            while(iterator.hasNext()){
+                RefTypeOrTPHOrWildcardOrGeneric typeParam = iterator.next();
+                insert += new PlaceholderToInsertString(typeParam, constraints, classConstraints).insert;
+                if(iterator.hasNext())insert += ", ";
+            }
+            insert += ">";
+        }
+    }
+
+    @Override
+    public void visit(GenericRefType genericRefType) {
+        insert += genericRefType.getParsedName();
+    }
+
+    @Override
+    public void visit(SuperWildcardType superWildcardType) {
+        insert += "? super " + new PlaceholderToInsertString(superWildcardType.getInnerType(), constraints, classConstraints).insert;
+    }
+
+    @Override
+    public void visit(TypePlaceholder typePlaceholder) {
+        ResultPair<?, ?> resultPair = null;
+        if (constraints != null)
+            resultPair = constraints.getResultPairFor(typePlaceholder).orElse(null);
+        if (resultPair == null)
+            resultPair = classConstraints.getResultPairFor(typePlaceholder).orElse(null);
+
+        if (resultPair != null)
+            insert += ((TypePlaceholder)resultPair.getLeft()).getName();
+    }
+
+    @Override
+    public void visit(ExtendsWildcardType extendsWildcardType) {
+        insert += "? extends " + new PlaceholderToInsertString(extendsWildcardType.getInnerType(), constraints, classConstraints).insert;
+    }
+}

LanguageServer/src/main/java/de/dhbw/helper/Recalculator.java

@@ -0,0 +1,6 @@
+package de.dhbw.helper;
+
+public class Recalculator {
+
+
+}

LanguageServer/src/main/java/de/dhbw/helper/ResultListener.java

@@ -0,0 +1,123 @@
+package de.dhbw.helper;
+
+import com.google.common.base.Stopwatch;
+import de.dhbw.handler.SaveHandler;
+import de.dhbw.model.DiagnosticsAndTypehints;
+import de.dhbw.model.LSPVariable;
+import de.dhbw.service.CacheService;
+import de.dhbw.service.ClientService;
+import de.dhbwstuttgart.core.JavaTXCompiler;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultEvent;
+import de.dhbwstuttgart.typeinference.unify.UnifyResultListener;
+import org.apache.commons.io.output.NullOutputStream;
+import org.eclipse.lsp4j.Diagnostic;
+import org.eclipse.lsp4j.DidSaveTextDocumentParams;
+import org.eclipse.lsp4j.InlayHint;
+import org.eclipse.lsp4j.MessageType;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ResultListener implements UnifyResultListener {
+
+    TypeResolver typeResolver;
+    SourceFile ast;
+    DidSaveTextDocumentParams didSaveTextDocumentParams;
+    CacheService cacheService;
+    ConversionHelper conversionHelper;
+    ClientService clientService;
+    JavaTXCompiler compiler;
+    SourceFile sourceFile;
+
+
+    public ResultListener(TypeResolver saveHandler, DidSaveTextDocumentParams didSaveTextDocumentParams, CacheService cacheService, ConversionHelper conversionHelper, ClientService clientService){
+        this.typeResolver = saveHandler;
+        this.didSaveTextDocumentParams = didSaveTextDocumentParams;
+        this.cacheService = cacheService;
+        this.conversionHelper = conversionHelper;
+        this.clientService = clientService;
+    }
+
+    public void init(DidSaveTextDocumentParams didSaveTextDocumentParams){
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+        try {
+            System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+
+            var uri = new URI(didSaveTextDocumentParams.getTextDocument().getUri());
+            var path = Path.of(uri);
+
+            var file = path.toFile();
+            Files.createDirectories(path.getParent().resolve("out"));
+
+            this.compiler = new JavaTXCompiler(file, false);
+            sourceFile = compiler.sourceFiles.get(file);
+
+            compiler.typeInferenceAsync(this, new OutputStreamWriter(new NullOutputStream()));
+
+
+        } catch (Exception e) {
+
+            clientService.sendClientLog("KRITISCHE");
+            clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+            for (StackTraceElement stack : e.getStackTrace()){
+                clientService.sendClientLog(stack.toString());
+            }
+            cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), didSaveTextDocumentParams.getTextDocument().getUri());
+
+        }
+    }
+
+
+    @Override
+    public void onNewTypeResultFound(UnifyResultEvent unifyResultEvent) {
+        try {
+
+            clientService.sendClientLog("YEEEEEEEEEEEP: " + (unifyResultEvent.getNewTypeResult() == null ? "Null" : "Nicht null"));
+            List<LSPVariable> lspVariables = typeResolver.infereIncremental(unifyResultEvent.getNewTypeResult(), this.compiler.getGeneratedGenerics().get(sourceFile), ast);
+
+            if(cacheService.getVariables() == null){
+                clientService.sendClientLog("Variablen null");
+                cacheService.setVariables(new ArrayList<>());
+            }
+
+            cacheService.getVariables().addAll(lspVariables);
+
+
+            DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(new ArrayList<>(lspVariables), didSaveTextDocumentParams.getTextDocument().getUri());
+            clientService.sendClientLog("Diagnostiken erstellt");
+            List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+            List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
+
+            cacheService.getGlobalInlayHintMap().computeIfAbsent(didSaveTextDocumentParams.getTextDocument().getUri(), k -> new ArrayList<>());
+            cacheService.getGlobalDiagnosticsMap().computeIfAbsent(didSaveTextDocumentParams.getTextDocument().getUri(), k -> new ArrayList<>());
+
+
+            cacheService.getGlobalInlayHintMap().get(didSaveTextDocumentParams.getTextDocument().getUri()).addAll(typeHint);
+            cacheService.getGlobalDiagnosticsMap().get(didSaveTextDocumentParams.getTextDocument().getUri()).addAll(diagnostics);
+            clientService.sendClientLog("paaaaaaaaaaaaast");
+            clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), cacheService.getGlobalDiagnosticsMap().get(didSaveTextDocumentParams.getTextDocument().getUri()));
+
+        } catch (IOException e) {
+            clientService.sendClientLog("KOMISCHER FEHLER!");
+            throw new RuntimeException(e);
+        } catch (ClassNotFoundException e) {
+            clientService.sendClientLog("KOMISCHER FEHLER!");
+            throw new RuntimeException(e);
+        } catch (URISyntaxException e) {
+            clientService.sendClientLog("KOMISCHER FEHLER!");
+            throw new RuntimeException(e);
+        }
+    }
+}

LanguageServer/src/main/java/de/dhbw/helper/TypeResolver.java

@@ -2,6 +2,7 @@ package de.dhbw.helper;
 
 
 import de.dhbw.model.*;
+import de.dhbw.model.PlaceholderVariable;
 import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
 import de.dhbwstuttgart.languageServerInterface.model.LanguageServerTransferObject;
@@ -11,11 +12,11 @@ import de.dhbwstuttgart.syntaxtree.factory.NameGenerator;
 import de.dhbwstuttgart.syntaxtree.visual.ASTPrinter;
 import de.dhbwstuttgart.target.generate.GenericsResult;
 import de.dhbwstuttgart.typedeployment.TypeInsert;
-import de.dhbwstuttgart.typedeployment.TypeInsertFactory;
 import de.dhbwstuttgart.typeinference.result.ResultSet;
 import org.apache.log4j.LogManager;
 import org.apache.log4j.Logger;
 
+import java.io.File;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.io.PrintStream;
@@ -32,16 +33,14 @@ import java.util.*;
 public class TypeResolver {
     private static final Logger logger = LogManager.getLogger(TypeResolver.class);
 
-    private final ASTTransformationHelper astTransformationHelper;
     private final TypeUtils typeUtils;
-    private final GenericUtils genericUtils;
     private final DuplicationUtils duplicationUtils;
     private final boolean ENABLE_GENERICS = true;
     private List<GenericsResult> generatedGenerics = null;
-    private HashMap<String, List<TypeInsert>> inserts;
+    private HashMap<String, List<PlaceholderVariable>> inserts;
 
 
-    public HashMap<String, List<TypeInsert>> getInserts() {
+    public HashMap<String, List<PlaceholderVariable>> getInserts() {
         return inserts;
     }
 
@@ -50,11 +49,16 @@ public class TypeResolver {
 
     private LanguageServerTransferObject current;
 
+    public void reset() {
+        HashMap<String, List<TypeInsert>> inserts = null;
+        List<GenericsResult> generatedGenerics = null;
+        current = null;
+    }
+
+
     public TypeResolver() {
         this.typeUtils = new TypeUtils();
-        this.genericUtils = new GenericUtils();
         this.duplicationUtils = new DuplicationUtils();
-        this.astTransformationHelper = new ASTTransformationHelper(duplicationUtils, typeUtils, genericUtils);
     }
 
 
@@ -91,18 +95,19 @@ public class TypeResolver {
         return current;
     }
 
-    public ArrayList<LSPVariable> infereChangeInput(String pathString) throws IOException, ClassNotFoundException, URISyntaxException {
+    public ArrayList<LSPVariable> infereChangeInput() throws IOException, ClassNotFoundException, URISyntaxException {
-        Set<TypeInsert> tips = new HashSet<>();
+
+        Set<PlaceholderVariable> tips = new HashSet<>();
 
         for (int i = 0; i < current.getResultSets().size(); i++) {
             ResultSet tiResult = current.getResultSets().get(i);
-            tips.addAll(TypeInsertFactory.createTypeInsertPoints(current.getAst(), tiResult, generatedGenerics.get(i)));
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(current.getAst(), tiResult, generatedGenerics.get(i)));
 
         }
 
-        HashMap<String, List<TypeInsert>> insertsOnLines = new HashMap<>();
+        HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
 
-        for (TypeInsert insert : tips) {
+        for (PlaceholderVariable insert : tips) {
             if (!insertsOnLines.containsKey(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine())) {
                 insertsOnLines.put(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine(), new ArrayList<>(List.of(insert)));
             } else {
@@ -110,12 +115,21 @@ public class TypeResolver {
             }
         }
 
+        inserts = insertsOnLines;
+
         ArrayList<LSPVariable> variables = new ArrayList<>(insertsOnLines.entrySet().stream().map(el -> new LSPVariable("test", new ArrayList<>(el.getValue().stream().map(typeinsert -> new Type(typeinsert.getInsertString(), typeinsert.point.isGenericClassInsertPoint())).toList()), el.getValue().getFirst().point.point.getLine(), el.getValue().getFirst().point.point.getCharPositionInLine(), el.getValue().get(0).point.point.getStopIndex(), el.getValue().get(0).getResultPair().getLeft())).toList());
 
+
         for (var variable : variables) {
-            Set<Type> set = new HashSet<>(variable.getPossibleTypes().stream().map(el -> new Type(el.getType().replaceAll(" ", ""), el.isGeneric())).toList());
+
-            variable.getPossibleTypes().clear();
+            HashMap<String, Type> uniqueType = new HashMap<>();
-            variable.getPossibleTypes().addAll(set);
+
+            for (var type : variable.getPossibleTypes()) {
+                if (!uniqueType.containsKey(type.getType().replaceAll(" ", ""))) {
+                    uniqueType.put(type.getType(), type);
+                }
+            }
+            variable.setPossibleTypes(new ArrayList<>(uniqueType.values()));
             logger.info(variable.getLine() + ":" + variable.getCharPosition());
             for (Type t : variable.getPossibleTypes()) {
                 logger.info(t.getType());
@@ -131,33 +145,39 @@ public class TypeResolver {
 
         var uri = new URI(pathString);
         var path = Path.of(uri);
-        var file = path.toFile();
-        NameGenerator.resetTo("A");
-        var compiler = new JavaTXCompiler(file, false);
 
+        logger.info("Path is for calculation: " + path.toString());
+        var file = path.toFile();
+        Files.createDirectories(path.getParent().resolve("out"));
+        JavaTXCompiler compiler = new JavaTXCompiler(List.of(file), List.of(path.getParent().toFile()), path.getParent().resolve("out").toFile());
         var parsedSource = compiler.sourceFiles.get(file);
         var tiResults = compiler.typeInference(file);
-        Set<TypeInsert> tips = new HashSet<>();
+        Set<PlaceholderVariable> tips = new HashSet<>();
 
-        for (var sf : compiler.sourceFiles.values()) {
+//        for (var sf : compiler.sourceFiles.values()) {
-            Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(sf, tiResults);
+//            Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(sf, tiResults);
-            logger.info("Path for Class-File is: " + path.getParent().resolve("out").toFile());
+//            logger.info("Path for Class-File is: " + path.getParent().resolve("out").toFile());
-            Files.createDirectories(path.getParent().resolve("out"));
+//            Files.createDirectories(path.getParent().resolve("out"));
-            compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
+//            compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
+//
+//        }
 
-        }
+        Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(parsedSource, tiResults);
+        logger.info("Path for Class-File is: " + path.getParent().resolve("out").toFile());
+        Files.createDirectories(path.getParent().resolve("out"));
+        compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
 
         generatedGenerics = compiler.getGeneratedGenerics().get(compiler.sourceFiles.get(file));
         for (int i = 0; i < tiResults.size(); i++) {
             ResultSet tiResult = tiResults.get(i);
-            tips.addAll(TypeInsertFactory.createTypeInsertPoints(parsedSource, tiResult, compiler.getGeneratedGenerics().get(compiler.sourceFiles.get(file)).get(i)));
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, compiler.getGeneratedGenerics().get(compiler.sourceFiles.get(file)).get(i)));
         }
         System.setOut(System.out);
         this.current = new LanguageServerTransferObject(tiResults, parsedSource, "", compiler.getGeneratedGenerics());
 
-        HashMap<String, List<TypeInsert>> insertsOnLines = new HashMap<>();
+        HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
 
-        for (TypeInsert insert : tips) {
+        for (PlaceholderVariable insert : tips) {
             if (!insertsOnLines.containsKey(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine())) {
                 insertsOnLines.put(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine(), new ArrayList<>(List.of(insert)));
             } else {
@@ -167,15 +187,32 @@ public class TypeResolver {
 
         inserts = insertsOnLines;
 
-        insertsOnLines.forEach((key, value) -> value.forEach(type -> logger.info(type.insert(input))));
+        logger.info("TYPES ARE:");
+        insertsOnLines.forEach((key, value) -> value.forEach(type -> logger.info(type.point.getInsertString())));
+        ArrayList<LSPVariable> variables = new ArrayList<>();
 
-        ArrayList<LSPVariable> variables = new ArrayList<>(insertsOnLines.entrySet().stream().map(el -> new LSPVariable("test", new ArrayList<>(el.getValue().stream().map(typeinsert -> new Type(typeinsert.getInsertString(), typeinsert.point.isGenericClassInsertPoint())).toList()), el.getValue().getFirst().point.point.getLine(), el.getValue().getFirst().point.point.getCharPositionInLine(), el.getValue().get(0).point.point.getStopIndex(), el.getValue().get(0).getResultPair().getLeft())).toList());
+
+        for(var entrySet : insertsOnLines.entrySet()){
+            ArrayList<Type> typesOfVariable  = new ArrayList<>();
+
+            for(PlaceholderVariable typeinsert : entrySet.getValue()){
+                typesOfVariable.add(new Type(typeinsert.getInsertString(), typeinsert.point.isGenericClassInsertPoint()));
+            }
+
+            variables.add(new LSPVariable("test",typesOfVariable , entrySet.getValue().getFirst().point.point.getLine(), entrySet.getValue().getFirst().point.point.getCharPositionInLine(), entrySet.getValue().get(0).point.point.getStopIndex(), entrySet.getValue().get(0).getResultPair().getLeft()));
+        }
 
 
         for (var variable : variables) {
-            Set<Type> set = new HashSet<>(variable.getPossibleTypes().stream().map(el -> new Type(el.getType().replaceAll(" ", ""), el.isGeneric())).toList());
+
-            variable.getPossibleTypes().clear();
+            HashMap<String, Type> uniqueType = new HashMap<>();
-            variable.getPossibleTypes().addAll(set);
+
+            for (var type : variable.getPossibleTypes()) {
+                if (!uniqueType.containsKey(type.getType().replaceAll(" ", ""))) {
+                    uniqueType.put(type.getType(), type);
+                }
+            }
+            variable.setPossibleTypes(new ArrayList<>(uniqueType.values()));
             logger.info(variable.getLine() + ":" + variable.getCharPosition());
             for (Type t : variable.getPossibleTypes()) {
                 logger.info(t.getType());
@@ -187,65 +224,69 @@ public class TypeResolver {
     }
 
 
-    /**
+    public ArrayList<LSPVariable> infereIncremental(List<ResultSet> newResultSet,  List<GenericsResult> generatedGenerics, SourceFile ast) throws IOException, ClassNotFoundException, URISyntaxException {
-     * Zum Erhalt für sowohl Parameter als auch Methoden.
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
-     */
+        logger.info("HMMMMMMMMMMMMM");
-    public ArrayList<LSPVariable> infereInput(String input, String path) throws IOException, ClassNotFoundException, URISyntaxException {
+        var parsedSource = ast;
-        logger.info("Infering Types for Input.");
+        var tiResults = newResultSet;
-
+        Set<PlaceholderVariable> tips = new HashSet<>();
-        current = updateIfNotPresent(path, input);
-        LanguageServerTransferObject transferObj = current;
 
 
-        ArrayList<LSPVariable> methodsWithParametersLSPVariableList = new ArrayList<>();
+        for (int i = 0; i < tiResults.size(); i++) {
-
+            ResultSet tiResult = tiResults.get(i);
-
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, null));
-        methodsWithParametersLSPVariableList.addAll(astTransformationHelper.constructorToVariable(transferObj));
-        methodsWithParametersLSPVariableList.addAll(astTransformationHelper.fieldDeclToVariable(transferObj));
-
-
-        if (!transferObj.getResultSets().isEmpty()) {
-            //TODO: Hier noch irgendwie die Klasse rausfinden oder durchgehen.
-
-            if (ENABLE_GENERICS) {
-                methodsWithParametersLSPVariableList.addAll(astTransformationHelper.addGenericClassPosition(transferObj, input));
-            }
-
-            methodsWithParametersLSPVariableList.addAll(astTransformationHelper.methodsWithParameterToVariable(transferObj, ENABLE_GENERICS));
         }
 
-        return methodsWithParametersLSPVariableList;
+        logger.info("OKI DOKI ALLES ERSTELLT");
-    }
+        System.setOut(System.out);
 
-    public ArrayList<LSPVariable> infereInput(String input, String path, SourceFile sourceFile) throws IOException, ClassNotFoundException, URISyntaxException {
+        HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
-        logger.info("Infering Types for Input.");
 
-        current = updateIfNotPresent(path, input);
+        for (PlaceholderVariable insert : tips) {
-        LanguageServerTransferObject transferObj = current;
+            if (!insertsOnLines.containsKey(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine())) {
-
+                insertsOnLines.put(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine(), new ArrayList<>(List.of(insert)));
-        transferObj = new LanguageServerTransferObject(transferObj.getResultSets(), sourceFile, "", transferObj.getGeneratedGenerics());
+            } else {
-
+                insertsOnLines.get(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine()).add(insert);
-
-        ArrayList<LSPVariable> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-
-        methodsWithParametersLSPVariableList.addAll(astTransformationHelper.constructorToVariable(transferObj));
-        methodsWithParametersLSPVariableList.addAll(astTransformationHelper.fieldDeclToVariable(transferObj));
-
-
-        if (!transferObj.getResultSets().isEmpty()) {
-            //TODO: Hier noch irgendwie die Klasse rausfinden oder durchgehen.
-
-            if (ENABLE_GENERICS) {
-                methodsWithParametersLSPVariableList.addAll(astTransformationHelper.addGenericClassPosition(transferObj, input));
             }
-
-            methodsWithParametersLSPVariableList.addAll(astTransformationHelper.methodsWithParameterToVariable(transferObj, ENABLE_GENERICS));
         }
 
-        return methodsWithParametersLSPVariableList;
+        inserts = insertsOnLines;
-    }
 
+        logger.info("TYPES ARE:");
+        insertsOnLines.forEach((key, value) -> value.forEach(type -> logger.info(type.point.getInsertString())));
+        ArrayList<LSPVariable> variables = new ArrayList<>();
+
+
+        for(var entrySet : insertsOnLines.entrySet()){
+            ArrayList<Type> typesOfVariable  = new ArrayList<>();
+
+            for(PlaceholderVariable typeinsert : entrySet.getValue()){
+                typesOfVariable.add(new Type(typeinsert.getInsertString(), typeinsert.point.isGenericClassInsertPoint()));
+            }
+
+            variables.add(new LSPVariable("test",typesOfVariable , entrySet.getValue().getFirst().point.point.getLine(), entrySet.getValue().getFirst().point.point.getCharPositionInLine(), entrySet.getValue().get(0).point.point.getStopIndex(), entrySet.getValue().get(0).getResultPair().getLeft()));
+        }
+
+
+        for (var variable : variables) {
+
+            HashMap<String, Type> uniqueType = new HashMap<>();
+
+            for (var type : variable.getPossibleTypes()) {
+                if (!uniqueType.containsKey(type.getType().replaceAll(" ", ""))) {
+                    uniqueType.put(type.getType(), type);
+                }
+            }
+            variable.setPossibleTypes(new ArrayList<>(uniqueType.values()));
+            logger.info(variable.getLine() + ":" + variable.getCharPosition());
+            for (Type t : variable.getPossibleTypes()) {
+                logger.info(t.getType());
+            }
+
+        }
+
+        return variables;
+    }
 
     public void reduceCurrent(HashMap<LineCharPosition, String> combinedList, List<LSPVariable> variables) {
 
@@ -280,4 +321,8 @@ public class TypeResolver {
         logger.info(ASTPrinter.print(current.getAst()));
     }
 
+    public void updateCurrent(List<ResultSet> resultSets){
+        current.getResultSets().addAll(resultSets);
+    }
+
 }

LanguageServer/src/main/java/de/dhbw/model/PlaceholderPoint.java

@@ -0,0 +1,93 @@
+package de.dhbw.model;
+
+import org.antlr.v4.runtime.Token;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+
+public class PlaceholderPoint {
+    public Token point;
+    private String insertString;
+    private int extraOffset = 0;
+    private PlaceholderType kind;
+
+    public PlaceholderPoint(Token point, String toInsert, PlaceholderType kind){
+        this.point = point;
+        this.kind = kind;
+        this.insertString = (toInsert.endsWith(" ")) ? toInsert : toInsert + " " ;
+    }
+    
+    public boolean isGenericClassInsertPoint() {
+    	return kind == PlaceholderType.GENERIC_CLASS_INSERT;
+    }
+
+    public String insert(String intoSource, List<PlaceholderPoint> additionalOffset){
+        return new StringBuilder(intoSource).insert(point.getStartIndex()+extraOffset, insertString).toString();
+    }
+
+    public String getInsertString() {
+        return insertString;
+    }
+       
+    public void addExtraOffset(int toAdd) {
+    	this.extraOffset += toAdd;
+    }
+    
+    public int getPositionInCode() {
+    	return point.getStartIndex() + extraOffset; 
+    }
+    
+    /* PL 2018-06-19
+     * Zwei TypeInsertPoint's sind gleich, wenn ihre point's gleich sind 
+     * eingefuegt damit man TypeReplaceMarker vergleichen kann
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
+    public boolean equals(Object obj) {
+    	return this == obj;
+    	/*
+    	if(!(obj instanceof TypeInsertPoint)) {
+			return false;
+    	}
+    	else {
+    		return 
+	    		((TypeInsertPoint)obj).getPositionInCode() == this.getPositionInCode() &&
+	    		((TypeInsertPoint)obj).insertString.equals(this.insertString);
+    	}		
+    	*/	
+    }
+    
+    public int hashCode() {
+    	return getPositionInCode() * 11 * insertString.hashCode();
+    }
+    
+    public Set<PlaceholderPoint> getAdditionalPoints() {
+    	return this.getAdditionalPoints();
+    }
+    
+    public String toString() {
+    	return point.getLine() + ":" + point.getCharPositionInLine() + ":" + insertString;
+    }
+    
+    public static final class TypeInsertPointPositionComparator implements Comparator<PlaceholderPoint> {
+
+    	@Override
+    	public int compare(PlaceholderPoint o1, PlaceholderPoint o2) {
+    		if (o1.point == null && o2.point == null) {
+    			return 0;
+    		} else if (o2.point == null) {
+    			return 1;
+    		} else if (o1.point == null) {
+    			return -1;
+    		}
+    		
+    		if (o1.getPositionInCode() > o2.getPositionInCode()) {
+    			return 1;
+    		} else if (o1.getPositionInCode() < o2.getPositionInCode()) {
+    			return -1;
+    		}
+    		return 0;
+    	}
+
+    }
+}

LanguageServer/src/main/java/de/dhbw/model/PlaceholderType.java

@@ -0,0 +1,7 @@
+package de.dhbw.model;
+
+public enum PlaceholderType {
+	NORMAL_INSERT,
+	GENERIC_CLASS_INSERT,
+	GENERERIC_METHOD_INSERT
+}

LanguageServer/src/main/java/de/dhbw/model/PlaceholderVariable.java

@@ -0,0 +1,68 @@
+package de.dhbw.model;
+
+import de.dhbwstuttgart.typeinference.result.ResultPair;
+
+import java.util.*;
+
+public class PlaceholderVariable {
+    /**
+     * point wird hauptsächlich zur Anzeige einer Annotation im Eclipse-plugin benutzt.
+     */
+    public final PlaceholderPoint point;
+    Set<PlaceholderPoint> inserts;
+    ResultPair<?, ?> resultPair;
+
+    public PlaceholderVariable(PlaceholderPoint point, Set<PlaceholderPoint> additionalPoints, ResultPair<?, ?> resultPair) {
+        this.point = point;
+        inserts = additionalPoints;
+        this.resultPair = resultPair;
+    }
+
+    public String insert(String intoSource) {
+        List<PlaceholderPoint> offsets = new ArrayList<>();
+        String ret = intoSource;
+
+        List<PlaceholderPoint> insertsSorted = new ArrayList<>();
+        insertsSorted.add(point);
+        insertsSorted.addAll(inserts);
+        Collections.sort(insertsSorted, new PlaceholderPoint.TypeInsertPointPositionComparator().reversed());
+
+        for (PlaceholderPoint insertPoint : insertsSorted) {
+            ret = insertPoint.insert(ret, new ArrayList<>());
+            offsets.add(insertPoint);
+        }
+        return ret;
+    }
+
+    public String getInsertString() {
+        return point.getInsertString();
+    }
+
+    public ResultPair<?, ?> getResultPair() {
+        return this.resultPair;
+    }
+
+    public boolean equals(Object obj) {
+        if (!(obj instanceof PlaceholderVariable)) {
+            return false;
+        } else {
+            return ((PlaceholderVariable) obj).point.equals(this.point);
+
+        }
+    }
+
+    public Set<PlaceholderPoint> getAdditionalPoints() {
+        PlaceholderPoint.TypeInsertPointPositionComparator comparator = new PlaceholderPoint.TypeInsertPointPositionComparator();
+        TreeSet<PlaceholderPoint> result = new TreeSet<>(comparator.reversed());
+        result.addAll(inserts);
+        return result;
+    }
+
+    public Set<PlaceholderPoint> getAdditionalPointsUnsorted() {
+        return inserts;
+    }
+
+    public String toString() {
+        return point.toString();
+    }
+}

LanguageServer/src/main/java/de/dhbw/service/CacheService.java

@@ -36,6 +36,22 @@ public class CacheService {
         this.typeInserts = typeInserts;
     }
 
+    public void reset(){
+       globalInlayHintMap = new HashMap<>();
+       lastSavedFiles = new HashMap<>();
+       currentlyCalculating = false;
+       globalDiagnosticsMap = new HashMap<>();
+       textDocuments = new HashMap<>();
+       codeSnippetOptions = new CodeSnippetOptions();
+       textHelper = new TextHelper();
+       dontShowHints = false;
+       typeResolver = new TypeResolver();
+       fileRoot = null;
+       singleFileOpened = false;
+       typeInserts = null;
+    }
+
+
     public void updateGlobalMaps(List<Diagnostic> diagnostics, List<InlayHint> typeHint, String uri) {
         globalDiagnosticsMap.put(uri, diagnostics);
         globalInlayHintMap.put(uri, typeHint);

LanguageServer/src/main/java/de/dhbw/service/TextDocumentService.java

@@ -14,6 +14,11 @@ public class TextDocumentService {
 
     }
 
+    public void reset(){
+        files.clear();
+    }
+
+
     public String getFileOfUri(String uri) {
         return files.get(uri);
     }

LanguageServer/src/test/java/CompilerInterfaceTest.java

@@ -12,29 +12,6 @@ public class CompilerInterfaceTest {
 
     @Test
     public void testAbstractSyntaxAsString() throws IOException, ClassNotFoundException, URISyntaxException {
-        TypeResolver typeResolver = new TypeResolver();
-        var res = typeResolver.infereInput("import java.lang.Integer;\n import java.lang.String;\n" +
-                "public class test{\n" +
-                "public main(test){" +
-                "if(0>1){" +
-                "return \"w\";" +
-                "}" +
-                "Integer i = 0;" +
-                "return i;" +
-                "}" +
-                "}", "c%3A/Users/ruben/Neuer%20Ordner%20%282%29/LSP-Vortrag/images/test.jav");
-
-        var res2 = typeResolver.infereInput("import java.lang.Integer;\n import java.lang.String;\n" +
-                "public class test{\n" +
-                "public main(test){" +
-                "if(0>1){" +
-                "return \"w\";" +
-                "}" +
-                "Integer i = 0;" +
-                "return i;" +
-                "}" +
-                "}", "c%3A/Users/ruben/Neuer%20Ordner%20%282%29/LSP-Vortrag/images/test.jav");
-        System.out.println("TEST OUTPUT:");
 //
 //        ArrayList<String> allTypes = new ArrayList<>();
 //