Update README.md

# Conflicts:
#	Clients/VisualStudioCode/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar
#	Clients/VisualStudioCode/package.json

Clients/Intellij/.idea/misc.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

Clients/Intellij/build.gradle

@@ -1,28 +0,0 @@
-plugins {
-    id 'java'
-    id 'org.jetbrains.intellij.platform' version '2.2.1'
-
-}
-
-group = 'org.example'
-version = '1.0-SNAPSHOT'
-
-repositories {
-    mavenCentral()
-    maven { url "https://jitpack.io" }
-
-    intellijPlatform {
-        defaultRepositories()
-    }
-}
-
-
-dependencies {
-    testImplementation platform('org.junit:junit-bom:5.10.0')
-    testImplementation 'org.junit.jupiter:junit-jupiter'
-    implementation "com.github.Ballerina-Platform.lsp4intellij:lsp4intellij:master-SNAPSHOT"
-}
-
-test {
-    useJUnitPlatform()
-}

Clients/Intellij/build.gradle.kts

@@ -0,0 +1,41 @@
+plugins {
+    id("org.jetbrains.intellij") version "1.17.3"
+    kotlin("jvm") version "1.9.0"
+}
+
+group = "com.example"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+    maven { url = uri("https://jitpack.io") }
+}
+
+dependencies {
+    implementation(kotlin("stdlib"))
+    implementation("com.github.ballerina-platform:lsp4intellij:0.9.0")
+}
+
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+}
+
+
+intellij {
+    version.set("2023.3")
+}
+
+tasks {
+    patchPluginXml {
+        sinceBuild.set("233")
+        untilBuild.set("233.*")
+    }
+}

Clients/Intellij/installation.md

@@ -0,0 +1,13 @@
+# Installation des Intellij Language Clients
+
+Um den Language Client für Intellij installieren zu können, kann die Erweiterung
+[LSP4IJ](https://plugins.jetbrains.com/plugin/23257-lsp4ij) installiert werden.
+
+## Installation
+1. Installiere [LSP4IJ](https://plugins.jetbrains.com/plugin/23257-lsp4ij)
+2. Öffne den Language Server Tab
+3. Füge einen neuen Language-Server hinzu
+4. Vergebe einen Namen und füge folgenden Command hinzu: `java -jar "<path/to/LanguageServer.jar>`
+5. Füge unter Mappings -> File name patterns *.jav und Language ID java_tx hinzu
+6. öffne eine Datei mit Dateiendung .jav
+7. Fertig

Clients/Intellij/src/main/kotlin/kotlin/com/example/lsp/PreloadActivityTX.java

@@ -0,0 +1,14 @@
+package kotlin.com.example.lsp;
+
+import com.intellij.openapi.application.PreloadingActivity;
+import com.intellij.openapi.progress.ProgressIndicator;
+import org.wso2.lsp4intellij.IntellijLanguageClient;
+import org.wso2.lsp4intellij.client.languageserver.serverdefinition.RawCommandServerDefinition;
+
+public class PreloadActivityTX extends PreloadingActivity {
+    @Override
+    public void preload(ProgressIndicator indicator) {
+        String[] command = new String[]{"java", "-jar", "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"};
+        IntellijLanguageClient.addServerDefinition(new RawCommandServerDefinition("jav", command));
+    }
+}

Clients/Intellij/src/resources/META-INF/plugin.xml

@@ -13,7 +13,7 @@ see also jetbrains documentation: https://plugins.jetbrains.com/docs/intellij/pl
 
     <extensions defaultExtensionNs="com.intellij">
         <!-- register a preloading activity. You need to init IntellijLanguageClient with your config, see readme -->
-        <preloadingActivity implementation="your.plugin.MyPreloadingActivity" id="your.plugin.MyPreloadingActivity"/>
+        <preloadingActivity implementation="kotlin.com.example.lsp.PreloadActivityTX" id="kotlin.com.example.lsp.PreloadActivityTX"/>
 
         <!-- register intellijLanguageClient as a Service OR as a plugin component (see readme)... -->
         <applicationService serviceImplementation="org.wso2.lsp4intellij.IntellijLanguageClient"/>

Clients/VisualStudioCode/README.md

@@ -1,3 +1,3 @@
-# lspclient README
+# Java-TX Language Server
 
-This is the README for the Java-TX LSP Client.
+This is the official Plugin for Java-TX.

Clients/VisualStudioCode/package.json

@@ -1,8 +1,9 @@
 {
-  "name": "lspclient",
-  "displayName": "LSPClient",
-  "description": "",
-  "version": "0.0.1",
+  "icon": "TX.png",
+  "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.9",
   "engines": {
     "vscode": "^1.94.0"
   },
@@ -16,8 +17,8 @@
   "contributes": {
     "commands": [
       {
-        "command": "lspclient.helloWorld",
-        "title": "Hello World"
+        "command": "tx.restartLanguageServer",
+        "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,
-	LanguageClientOptions,
-	ServerOptions,
-	TransportKind
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions
 } 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: ['-Xss10m', '-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"],
+    },
+    debug: {
+      command: 'java',
+      args: [
+      '-Xss10m',
+      '-jar',
+      workspaceFolder + '/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar',
+    ],
+    }
+  };
 
-// This method is called when your extension is activated
-// Your extension is activated the very first time the command is executed
-export function activate(context: vscode.ExtensionContext) {
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [{ scheme: 'file', pattern: '**/*.jav' }],
+    synchronize: {
+      fileEvents: vscode.workspace.createFileSystemWatcher('**/*.jav')
+    },
+    revealOutputChannelOn: 4
+  };
 
-
-	
-	const workspaceFolder = context.extensionPath;
-	const serverOptions: ServerOptions = {
-		run: {
-			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);
+  return new LanguageClient(
+    'javaTxLanguageServer',
+    'Java-TX Language Server',
+    serverOptions,
+    clientOptions
+  );
 }
 
-// This method is called when your extension is deactivated
-export function deactivate() { }
+export async function activate(context: vscode.ExtensionContext) {
+  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/pom.xml

@@ -20,6 +20,11 @@
             <artifactId>antlr4</artifactId>
             <version>4.11.1</version>
         </dependency>
+        <dependency>
+            <groupId>io.github.java-diff-utils</groupId>
+            <artifactId>java-diff-utils</artifactId>
+            <version>4.12</version>
+        </dependency>
         <dependency>
             <groupId>log4j</groupId>
             <artifactId>log4j</artifactId>
@@ -75,6 +80,12 @@
             <version>0.1</version>
         </dependency>
     </dependencies>
+    <properties>
+        <!-- Setzt Java 21 als globale Version -->
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <maven.compiler.release>21</maven.compiler.release>
+    </properties>
 
     <build>
         <plugins>
@@ -96,6 +107,7 @@
                 <configuration>
                     <source>21</source>
                     <target>21</target>
+                    <release>21</release>
                 </configuration>
             </plugin>
 

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

@@ -8,7 +8,6 @@ import org.eclipse.lsp4j.services.TextDocumentService;
 import org.eclipse.lsp4j.services.WorkspaceService;
 import org.eclipse.lsp4j.services.LanguageServer;
 
-import java.net.URI;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 /**

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

@@ -1,58 +1,68 @@
 package de.dhbw;
 
-import com.google.common.base.Stopwatch;
+import de.dhbw.handler.*;
+import de.dhbw.service.CacheService;
+import de.dhbw.service.ClientService;
+import de.dhbw.service.LogService;
 import de.dhbw.helper.CodeSnippetOptions;
+import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TextHelper;
 import de.dhbw.helper.TypeResolver;
-import de.dhbw.model.LSPVariable;
-import de.dhbw.model.LineCharPosition;
 import de.dhbw.model.SnippetWithName;
-import de.dhbw.model.Type;
-import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
-import de.dhbwstuttgart.languageServerInterface.ParserInterface;
-import de.dhbwstuttgart.languageServerInterface.model.ParserError;
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Logger;
+import de.dhbw.service.ParserService;
 import org.eclipse.lsp4j.*;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
-import org.eclipse.lsp4j.jsonrpc.messages.Message;
 import org.eclipse.lsp4j.services.LanguageClient;
 import org.eclipse.lsp4j.services.TextDocumentService;
 
-import java.io.File;
-import java.io.IOException;
 import java.net.URI;
-import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.Paths;
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
 /**
  * Handles Actions in Documents, such as Autocompletion, Change-Events and Syntax-Checks
  */
 public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.TextDocumentService {
 
+    private final FormattingHandler formattingHandler;
+    private final SaveHandler saveHandler;
+    private final ParserService parserService;
+    private final TypeResolver typeResolver;
+    private final de.dhbw.service.TextDocumentService textDocumentService;
+    private final LogService logService;
+    private final ClientService clientService;
+    private final CacheService cacheService;
+    private final ConversionHelper conversionHelper;
+    private final ChangeHandler changeHandler;
+    private final TextHelper textHelper;
+    private final CodeActionHandler codeActionHandler;
 
-    private static final Logger logger = LogManager.getLogger(JavaTXTextDocumentService.class);
     LanguageClient client;
-    HashMap<String, List<InlayHint>> globalInlayHintMap = new HashMap<>();
-    Boolean currentlyCalculating = false;
-    HashMap<String, List<Diagnostic>> globalDiagnosticsMap = new HashMap<>();
     HashMap<String, String> textDocuments = new HashMap<>();
     CodeSnippetOptions codeSnippetOptions = new CodeSnippetOptions();
-    TextHelper textHelper = new TextHelper();
     Boolean dontShowHints = false;
-    TypeResolver typeResolver = new TypeResolver();
     Path fileRoot = null;
     Boolean singleFileOpened = false;
-    List<LSPVariable> variables = new ArrayList<>();
+
+    public JavaTXTextDocumentService() {
+        this.textHelper = new TextHelper();
+        this.cacheService = new CacheService();
+        this.clientService = new ClientService(null);
+        this.typeResolver = new TypeResolver();
+        this.textDocumentService = new de.dhbw.service.TextDocumentService();
+        this.conversionHelper = new ConversionHelper(textHelper, textDocumentService);
+        this.logService = new LogService(clientService);
+        this.formattingHandler = new FormattingHandler(textDocumentService);
+        this.parserService = new ParserService(conversionHelper, clientService, cacheService);
+        this.codeActionHandler = new CodeActionHandler(textHelper, textDocumentService, cacheService, typeResolver, logService, conversionHelper);
+        this.saveHandler = new SaveHandler(typeResolver, textDocumentService, logService, cacheService, conversionHelper, clientService, parserService);
+        this.changeHandler = new ChangeHandler(textDocumentService, parserService, conversionHelper, clientService, typeResolver, cacheService, logService);
+    }
 
     public void setClient(LanguageClient client) {
         this.client = client;
+        clientService.setClient(client);
     }
 
     public void setFileRoot(List<WorkspaceFolder> root) {
@@ -97,68 +107,16 @@ 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());
-    }
-
-
-    public ArrayList<String> difference(String first, String second) {
-        ArrayList<String> result = new ArrayList<>();
-
-        int i = 0, j = 0;
-        int startDiff = -1;
-
-        while (j < second.length()) {
-            if (i < first.length() && first.charAt(i) == second.charAt(j)) {
-                if (startDiff != -1) {
-                    result.add(second.substring(startDiff, j));
-                    startDiff = -1;
-                }
-                i++;
-                j++;
-            } else {
-                if (startDiff == -1) {
-                    startDiff = j;
-                }
-                j++;
-            }
-        }
-
-        if (startDiff != -1) {
-            result.add(second.substring(startDiff));
-        }
-
-        return result;
-    }
-
-    public Map<LineCharPosition, String> differenceLinePos(String first, String second, int line) {
-        Map<LineCharPosition, String> result = new HashMap<>();
-
-        int i = 0, j = 0;
-        int startDiff = -1;
-
-        while (j < second.length()) {
-            if (i < first.length() && first.charAt(i) == second.charAt(j)) {
-                if (startDiff != -1) {
-                    String diff = second.substring(startDiff, j);
-                    result.put(new LineCharPosition(line, startDiff), diff);
-                    startDiff = -1;
-                }
-                i++;
-                j++;
-            } else {
-                if (startDiff == -1) {
-                    startDiff = j;
-                }
-                j++;
-            }
-        }
-
-        if (startDiff != -1) {
-            String diff = second.substring(startDiff);
-            result.put(new LineCharPosition(line, startDiff), diff);
-        }
-
-        return result;
+        textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), params.getTextDocument().getText());
     }
 
 
@@ -170,144 +128,12 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
      */
     @Override
     public void didChange(DidChangeTextDocumentParams params) {
-        log("[didChange] Client triggered didChange Event.", MessageType.Info);
-
-
-        //TODO: Regenerate if Line-Count does not match -> Return new AST and see where the Positions are instead of calculating them from changes in Text-Document. Even possible?
-
-        String currentText = textDocuments.get(params.getTextDocument().getUri());
-        ArrayList<String> currentTextLines = new ArrayList<>(Arrays.stream(currentText.split("\n")).toList());
-        HashMap<LineCharPosition, String> preciseChanges = new HashMap<>();
-        String newText = params.getContentChanges().getFirst().getText();
-        ArrayList<String> newTextLines = new ArrayList<>(Arrays.stream(newText.split("\n")).toList());
-
-        ArrayList<Integer> offsetPerLine = new ArrayList<>();
-        HashMap<Integer, List<String>> textChanges = new HashMap<>();
-        int index = 0;
-        for (String newTextLine : newTextLines) {
-            if (!(currentTextLines.size() > index)) {
-                offsetPerLine.add(0);
-            } else {
-
-
-                Map<LineCharPosition, String> lineDiffs = differenceLinePos(currentTextLines.get(index), newTextLine, index);
-                preciseChanges.putAll(lineDiffs);
-
-                textChanges.put(index, difference(currentTextLines.get(index), newTextLine).stream().map(el -> el.replaceAll(" ", "")).toList());
-                offsetPerLine.add(newTextLine.length() - currentTextLines.get(index).length());
-            }
-
-            index++;
-        }
-
-
-        AtomicReference<String> summedUp = new AtomicReference<>("");
-        params.getContentChanges().forEach(el -> summedUp.set(summedUp.get() + el.getText()));
-        textDocuments.put(params.getTextDocument().getUri(), summedUp.get());
-
-        String input = summedUp.get();
-
-        ParserInterface parserInterface = new ParserInterface();
-
-        List<ParserError> parserErrors = parserInterface.getParseErrors(input);
-
-        List<Diagnostic> diagnosticsList = parserErrors.stream().map(el -> {
-            Range errorRange = new Range(
-                    new Position(el.getLine() - 1, el.getCharPositionInLine()),        // Startposition
-                    new Position(el.getLine() - 1, el.getEndCharPosition())            // Endposition
-            );
-            return new Diagnostic(
-                    errorRange,
-                    el.getMsg(),
-                    DiagnosticSeverity.Error,
-                    "JavaTX Language Server"
-            );
-        }).toList();
-
-
-//        PublishDiagnosticsParams diagnosticsParams = new PublishDiagnosticsParams(params.getTextDocument().getUri(), diagnostics);
-//        client.publishDiagnostics(diagnosticsParams);
-
-
-        List<String> combinedList = new ArrayList<>();
-
-        for (List<String> list : textChanges.values()) {
-            combinedList.addAll(list);
-        }
-
-        typeResolver.reduceCurrent(preciseChanges, variables, client);
-        //Reduce and display Typehints and Diagnostics
-
-        if (!currentlyCalculating) {
-            currentlyCalculating = true;
-
-            ArrayList<Diagnostic> diagnostics = new ArrayList<>();
-            var sWatch = Stopwatch.createUnstarted();
-            sWatch.start();
-
-            try {
-                if (textDocuments.get(params.getTextDocument().getUri()) == null) {
-                    log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
-                }
-                ArrayList<LSPVariable> typesOfMethodAndParameters = typeResolver.infereInput(textDocuments.get(params.getTextDocument().getUri()), params.getTextDocument().getUri());
-
-                List<InlayHint> typeHint = new ArrayList<>();
-
-                for (var variable : typesOfMethodAndParameters) {
-
-                    InlayHint inlayHint = getInlayHint(variable);
-                    typeHint.add(inlayHint);
-
-
-                    //Diagnostics of Types
-                    for (var type : variable.getPossibleTypes()) {
-                        Diagnostic diagnostic = getDiagnostic(variable, params.getTextDocument().getUri(), type);
-                        diagnostics.add(diagnostic);
-                    }
-                }
-
-                updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
-
-
-            } catch (Exception e) {
-                log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
-                client.showMessage(new MessageParams(MessageType.Error, e.getMessage()));
-                updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), params.getTextDocument().getUri());
-
-            } finally {
-                currentlyCalculating = false;
-                sWatch.stop();
-                log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
-            }
-        }
-
-        for (var inlayHint : globalInlayHintMap.get(params.getTextDocument().getUri())) {
-            inlayHint.getPosition().setCharacter(inlayHint.getPosition().getCharacter() + offsetPerLine.get(inlayHint.getPosition().getLine()));
-        }
-
-        for (var inlayHint : globalDiagnosticsMap.get(params.getTextDocument().getUri())) {
-            inlayHint.getRange().getStart().setCharacter(inlayHint.getRange().getStart().getCharacter() + offsetPerLine.get(inlayHint.getRange().getStart().getLine()));
-            inlayHint.getRange().getEnd().setCharacter(inlayHint.getRange().getEnd().getCharacter() + offsetPerLine.get(inlayHint.getRange().getEnd().getLine()));
-        }
-
-        for (var textChangeLine : textChanges.entrySet()) {
-            log(textChangeLine.getKey() + " - " + String.join(",", textChangeLine.getValue()), MessageType.Info);
-        }
-
-
-        globalInlayHintMap.put(params.getTextDocument().getUri(), globalInlayHintMap.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.
-            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());
-
-        globalDiagnosticsMap.put(params.getTextDocument().getUri(), globalDiagnosticsMap.get(params.getTextDocument().getUri()).stream().filter(el -> {
-            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());
-
-        updateClient(client);
-        client.publishDiagnostics(new PublishDiagnosticsParams(params.getTextDocument().getUri(), globalDiagnosticsMap.get(params.getTextDocument().getUri())));
+        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);
     }
 
     /**
@@ -317,183 +143,27 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
      */
     @Override
     public CompletableFuture<List<? extends TextEdit>> formatting(DocumentFormattingParams params) {
-        log("[formatting] Client requested formatting.", MessageType.Info);
-
-        List<TextEdit> edits = new ArrayList<>();
-
-
-        String[] lines = textDocuments.get(params.getTextDocument().getUri()).split("\n");
-        StringBuilder formattedText = new StringBuilder();
-
-        for (String line : lines) {
-            formattedText.append(line.stripTrailing()).append("\n");
-        }
-
-        TextEdit edit = new TextEdit();
-        edit.setRange(new Range(new Position(0, 0), new Position(lines.length, 0)));
-        edit.setNewText(formattedText.toString().trim());
-
-        edits.add(edit);
-        return CompletableFuture.completedFuture(edits);
+        logService.log("[formatting] Client requested formatting.", MessageType.Info);
+        return CompletableFuture.completedFuture(formattingHandler.handleFormat(params));
     }
 
     @Override
     public void didClose(DidCloseTextDocumentParams params) {
     }
 
-    private void log(String message, MessageType type) {
-        client.logMessage(new MessageParams(type, message));
-        switch (type) {
-            case Error -> logger.error(message);
-            case Warning -> logger.warn(message);
-            case Info -> logger.info(message);
-            default -> logger.debug(message);
-        }
-    }
-
-    private InlayHint getInlayHint(LSPVariable variable) {
-        InlayHint inlayHint = new InlayHint();
-
-        String typeDisplay = "";
-        for (Type type : variable.getPossibleTypes()) {
-            typeDisplay += " | " + type.getType().replaceAll("GTV ", "");
-        }
-
-
-        inlayHint.setLabel(typeDisplay.length() > 2 ? typeDisplay.substring(2) : typeDisplay);
-        inlayHint.setPosition(new Position(variable.getLine() - 1, variable.getCharPosition()));
-        inlayHint.setKind(InlayHintKind.Parameter);
-        inlayHint.setPaddingRight(true);
-        inlayHint.setPaddingRight(true);
-        return inlayHint;
-    }
-
-    private Diagnostic getDiagnostic(LSPVariable variable, String fileUri, Type type) {
-        Range errorRange = new Range(
-                new Position(variable.getLine() - 1, variable.getCharPosition()),               // Startposition
-                new Position(variable.getLine() - 1, textHelper.getEndingCharOfStartingChar(variable.getLine() - 1, variable.getCharPosition(), textDocuments.get(fileUri)))    // Endposition
-        );
-        Diagnostic diagnostic = new Diagnostic(
-                errorRange,
-                //TODO: REMOVE! Temporary Fix because GTV, like TPH can be thrown away in the TypeResolver
-                type.getType().replaceAll("GTV ", ""),
-                DiagnosticSeverity.Hint,
-                "JavaTX Language Server"
-        );
-        diagnostic.setCode(type.isGeneric() ? "GENERIC" : "TYPE");
-
-        return diagnostic;
-    }
-
-    private void updateGlobalMaps(List<Diagnostic> diagnostics, List<InlayHint> typeHint, String uri) {
-        globalDiagnosticsMap.put(uri, diagnostics);
-        globalInlayHintMap.put(uri, typeHint);
-    }
-
-    private void updateClient(LanguageClient client) {
-        client.refreshInlayHints();
-        client.refreshDiagnostics();
-    }
-
-    private void startLoading(String taskName, String title, LanguageClient client) {
-        Either<String, Integer> token = Either.forLeft(taskName);
-        client.createProgress(new WorkDoneProgressCreateParams(token));
-
-        WorkDoneProgressBegin begin = new WorkDoneProgressBegin();
-        begin.setTitle(title);
-        begin.setCancellable(false);
-        begin.setPercentage(0);
-
-        ProgressParams beginParams = new ProgressParams(token, Either.forLeft(begin));
-        client.notifyProgress(beginParams);
-
-    }
-
-    private void stopLoading(String taskName, String title, LanguageClient client) {
-        Either<String, Integer> token = Either.forLeft(taskName);
-        WorkDoneProgressEnd end = new WorkDoneProgressEnd();
-        end.setMessage(title);
-
-        ProgressParams endParams = new ProgressParams(token, Either.forLeft(end));
-        client.notifyProgress(endParams);
-    }
-
     @Override
     public void didSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
-        log("[didSave] Client triggered didSave-Event.", MessageType.Info);
-
-        startLoading("compile-task", "Inferring types...", client);
-
-        if (!currentlyCalculating) {
-            currentlyCalculating = true;
-
-            ArrayList<Diagnostic> diagnostics = new ArrayList<>();
-            var sWatch = Stopwatch.createUnstarted();
-            sWatch.start();
-
-            try {
-                typeResolver.getCompilerInput(didSaveTextDocumentParams.getTextDocument().getUri(), textDocuments.get(didSaveTextDocumentParams.getTextDocument().getUri()));
-                if (textDocuments.get(didSaveTextDocumentParams.getTextDocument().getUri()) == null) {
-                    log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
-                }
-                ArrayList<LSPVariable> typesOfMethodAndParameters = typeResolver.infereInput(textDocuments.get(didSaveTextDocumentParams.getTextDocument().getUri()), didSaveTextDocumentParams.getTextDocument().getUri());
-
-                variables = typesOfMethodAndParameters;
-                List<InlayHint> typeHint = new ArrayList<>();
-
-                for (var variable : typesOfMethodAndParameters) {
-
-                    InlayHint inlayHint = getInlayHint(variable);
-                    typeHint.add(inlayHint);
-
-
-                    //Diagnostics of Types
-                    for (var type : variable.getPossibleTypes()) {
-                        Diagnostic diagnostic = getDiagnostic(variable, didSaveTextDocumentParams.getTextDocument().getUri(), type);
-                        diagnostics.add(diagnostic);
-                    }
-                }
-
-                updateGlobalMaps(diagnostics, typeHint, didSaveTextDocumentParams.getTextDocument().getUri());
-
-                PublishDiagnosticsParams diagnosticsParams = new PublishDiagnosticsParams(didSaveTextDocumentParams.getTextDocument().getUri(), diagnostics);
-                client.publishDiagnostics(diagnosticsParams);
-
-
-            } catch (Exception e) {
-                log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
-                client.showMessage(new MessageParams(MessageType.Error, e.getMessage()));
-                updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), didSaveTextDocumentParams.getTextDocument().getUri());
-
-            } finally {
-                currentlyCalculating = false;
-                sWatch.stop();
-                log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
-            }
-
-
-        }
-
-        stopLoading("compile-task", "Types successfully inferred", client);
-
-        dontShowHints = false;
-        updateClient(client);
-
-        ArrayList<File> files = new ArrayList<>();
-
-        if (fileRoot != null) {
-            try (Stream<Path> stream = Files.walk(Paths.get(fileRoot.toUri()))) {
-                stream.filter(Files::isRegularFile)
-                        .forEach(el -> files.add(el.toFile()));
-            } catch (IOException e) {
-            }
-        }
+        logService.log("[didSave] Client triggered didSave-Event.");
+        clientService.startLoading("compile-task", "Inferring types...", client);
+        saveHandler.handleSave(didSaveTextDocumentParams);
+        clientService.stopLoading("compile-task", "Types successfully inferred", client);
+        clientService.updateClient(client);
     }
 
     @Override
     public CompletableFuture<List<InlayHint>> inlayHint(InlayHintParams params) {
-        log("[inlayHint] The Client requested Inlay-Hints.", MessageType.Info);
-        return CompletableFuture.supplyAsync(() -> dontShowHints ? Collections.emptyList() : globalInlayHintMap.get(params.getTextDocument().getUri()) == null ? Collections.emptyList() : globalInlayHintMap.get(params.getTextDocument().getUri()));
+        logService.log("[inlayHint] The Client requested Inlay-Hints.", MessageType.Info);
+        return CompletableFuture.supplyAsync(() -> dontShowHints ? Collections.emptyList() : cacheService.getGlobalInlayHintMap().get(params.getTextDocument().getUri()) == null ? Collections.emptyList() : cacheService.getGlobalInlayHintMap().get(params.getTextDocument().getUri()));
     }
 
     @Override
@@ -626,100 +296,15 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     @Override
     public CompletableFuture<List<Either<Command, CodeAction>>> codeAction(CodeActionParams params) {
 
-        log("[codeAction] Client requested Insert at Line [" + params.getRange().getStart().getLine() + "] and from Char [" + params.getRange().getStart().getCharacter() + "] to [" + params.getRange().getEnd().getCharacter() + "].", MessageType.Info);
+        logService.log("[codeAction] Client requested Insert at Line [" + params.getRange().getStart().getLine() + "] and from Char [" + params.getRange().getStart().getCharacter() + "] to [" + params.getRange().getEnd().getCharacter() + "].", MessageType.Info);
 
-        log("Code-Action Context was: " + params.getContext().getTriggerKind().name(), MessageType.Info);
-
-        List<Either<Command, CodeAction>> actions = new ArrayList<>();
-
-
-        List<Diagnostic> diagnosticInCurrentDocument = params.getContext().getDiagnostics();
-        Range requestedRange = params.getRange();
-
-        //All Diagnostics that are in range of the hover -> All Diagnostics of the selected Variable and thus all Types of the Variable
-        List<Diagnostic> diagnosticsOverlappingHover = diagnosticInCurrentDocument.stream()
-                .filter(diagnostic -> rangesOverlap(diagnostic.getRange(), requestedRange)).toList();
-
-        Range rangeOfInsert = params.getRange();
-
-
-        String documentUri = params.getTextDocument().getUri();
-
-
-        for (Diagnostic typeDiagnostic : diagnosticsOverlappingHover) {
-            try {
-                String typeWithReplacedVariable = typeDiagnostic.getMessage() +
-                        " " +
-                        textHelper.getTextOfChars(
-                                textDocuments.get(params.getTextDocument().getUri()),
-                                rangeOfInsert.getStart().getLine(),
-                                rangeOfInsert.getStart().getCharacter(),
-                                rangeOfInsert.getEnd().getCharacter()
-                        );
-
-                ArrayList<TextEdit> listOfChanges = new ArrayList<>();
-
-                if (typeDiagnostic.getCode().getLeft().equals("GENERIC")) {
-                    for (var diagnostic : globalDiagnosticsMap.get(params.getTextDocument().getUri())) {
-
-                        if (diagnostic.getMessage().contains(typeDiagnostic.getMessage()) || typeDiagnostic.getMessage().contains(diagnostic.getMessage())) {
-                            String genericType = diagnostic.getMessage() +
-                                    " " +
-                                    textHelper.getTextOfChars(
-                                            textDocuments.get(params.getTextDocument().getUri()),
-                                            diagnostic.getRange().getStart().getLine(),
-                                            diagnostic.getRange().getStart().getCharacter(),
-                                            diagnostic.getRange().getEnd().getCharacter()
-                                    );
-                            listOfChanges.add(new TextEdit(diagnostic.getRange(), genericType));
-                        }
-                    }
-                } else {
-                    listOfChanges.add(new TextEdit(rangeOfInsert, typeWithReplacedVariable));
-                }
-
-                var isTypeImported = false;
-
-                if (!typeDiagnostic.getCode().getLeft().equalsIgnoreCase("generic")) {
-                    isTypeImported = typeResolver.isTypeImported(textDocuments.get(params.getTextDocument().getUri()), typeDiagnostic.getMessage());
-                }
-                if (!isTypeImported && !typeDiagnostic.getMessage().equals("void") && !typeDiagnostic.getCode().getLeft().equals("GENERIC")) {
-                    Range importRange = new Range(new Position(0, 0), new Position(0, 0));
-
-                    var typeWithoutGenerics = typeDiagnostic.getMessage().contains("<") ? typeDiagnostic.getMessage().substring(0, typeDiagnostic.getMessage().indexOf('<')) : typeDiagnostic.getMessage();
-                    listOfChanges.add(new TextEdit(importRange, "import " + typeWithoutGenerics + ";\n"));
-                }
-
-                Map<String, List<TextEdit>> changes = new HashMap<>();
-                changes.put(documentUri, listOfChanges);
-
-                WorkspaceEdit edit = new WorkspaceEdit();
-                edit.setChanges(changes);
-
-                CodeAction action = new CodeAction("Insert " + typeDiagnostic.getMessage());
-                action.setKind(CodeActionKind.QuickFix);
-                action.setEdit(edit);
-                actions.add(Either.forRight(action));
-            } catch (Exception e) {
-                log("Error creating Actions, returning empty List. The Error was: " + e.getMessage(), MessageType.Error);
-            }
-        }
+        logService.log("Code-Action Context was: " + params.getContext().getTriggerKind().name(), MessageType.Info);
 
         return CompletableFuture.supplyAsync(() -> {
-            return actions;
+            return codeActionHandler.handleNewCodeAction(params);
         });
     }
 
-
-    private boolean rangesOverlap(Range range1, Range range2) {
-        int start1 = range1.getStart().getLine() * 1000 + range1.getStart().getCharacter();
-        int end1 = range1.getEnd().getLine() * 1000 + range1.getEnd().getCharacter();
-        int start2 = range2.getStart().getLine() * 1000 + range2.getStart().getCharacter();
-        int end2 = range2.getEnd().getLine() * 1000 + range2.getEnd().getCharacter();
-
-        return start1 <= end2 && start2 <= end1;
-    }
-
     @Override
     public CompletableFuture<CodeAction> resolveCodeAction(CodeAction unresolved) {
         return CompletableFuture.completedFuture(new CodeAction());

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

@@ -3,13 +3,8 @@ package de.dhbw;
 import org.apache.log4j.LogManager;
 import org.apache.log4j.Logger;
 import org.eclipse.lsp4j.*;
-import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.services.WorkspaceService;
 
-import java.util.Collections;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-
 /**
  *
  * Handles Actions in Workspace

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

@@ -0,0 +1,203 @@
+package de.dhbw.handler;
+
+import com.google.common.base.Stopwatch;
+import de.dhbw.helper.ConversionHelper;
+import de.dhbw.helper.TypeResolver;
+import de.dhbw.model.*;
+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;
+import java.io.File;
+import java.io.FileWriter;
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+public class ChangeHandler {
+
+    private final TextDocumentService textDocumentService;
+    private final ParserService parserService;
+    private final ConversionHelper conversionHelper;
+    private final ClientService clientService;
+    private final TypeResolver typeResolver;
+    private final CacheService cacheService;
+    private final LogService logService;
+
+    public ChangeHandler(TextDocumentService textDocumentService, ParserService parserService, ConversionHelper conversionHelper, ClientService clientService, TypeResolver typeResolver, CacheService cacheService, LogService logService) {
+        this.textDocumentService = textDocumentService;
+        this.parserService = parserService;
+        this.conversionHelper = conversionHelper;
+        this.clientService = clientService;
+        this.typeResolver = typeResolver;
+        this.cacheService = cacheService;
+        this.logService = logService;
+    }
+
+
+    public static String findAddedWord(String str1, String str2) {
+        int i = 0, j = 0;
+
+        // Suche den ersten Unterschied
+        while (i < str1.length() && j < str2.length() && str1.charAt(i) == str2.charAt(j)) {
+            i++;
+            j++;
+        }
+
+        // Falls alles gleich ist, gibt es nichts Neues
+        if (i == str1.length() && j == str2.length()) {
+            return null;
+        }
+
+        // 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());
+
+        AtomicReference<String> summedUp = new AtomicReference<>("");
+        params.getContentChanges().forEach(el -> summedUp.set(summedUp.get() + el.getText()));
+        textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), summedUp.get());
+
+
+        List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(summedUp.get(), params.getTextDocument().getUri());
+
+        if (!syntaxErrors.isEmpty()) {
+            clientService.publishDiagnostics(params.getTextDocument().getUri(), syntaxErrors);
+        }
+        logService.log("Found [" + syntaxErrors.size() + "] Syntax Errors in Document.");
+
+        if (syntaxErrors.isEmpty()) {
+
+            String type = findAddedWord(currentText, summedUp.get());
+            String input = summedUp.get();
+
+            logService.log("Variables are: " + cacheService.getVariables().size());
+
+            boolean shouldCalculate = false;
+
+            logService.log("Type is here: " + type);
+            for (LSPVariable variable : cacheService.getVariables()) {
+                for (Type variableType : variable.getPossibleTypes()) {
+                    logService.log(variableType.getType() + " <> "+ type.replaceAll(" ", "") + ": " + type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", "")));
+                    shouldCalculate = shouldCalculate || type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", ""));
+                    if (shouldCalculate) {
+                        break;
+                    }
+                }
+            }
+
+            logService.log("Should Calculate is: " + shouldCalculate);
+
+            if (false) {
+                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());
+                }
+
+                var sWatch = Stopwatch.createUnstarted();
+                sWatch.start();
+
+                try {
+                    ArrayList<LSPVariable> typesOfMethodAndParameters = typeResolver.infereChangeInput();
+                    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);
+                }
+
+                List<Diagnostic> typeDiagnostics = cacheService.getGlobalDiagnosticsMap().get(params.getTextDocument().getUri());
+                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

@@ -0,0 +1,222 @@
+package de.dhbw.handler;
+
+import de.dhbw.helper.ConversionHelper;
+import de.dhbw.helper.TextHelper;
+import de.dhbw.helper.TypeResolver;
+import de.dhbw.service.CacheService;
+import de.dhbw.service.LogService;
+import de.dhbw.service.TextDocumentService;
+import de.dhbw.model.PlaceholderVariable;
+import org.eclipse.lsp4j.*;
+import org.eclipse.lsp4j.jsonrpc.messages.Either;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class CodeActionHandler {
+
+    private final TextHelper textHelper;
+    private final TextDocumentService textDocumentService;
+    private final CacheService cacheService;
+    private final TypeResolver typeResolver;
+    private final LogService logService;
+    private final ConversionHelper conversionHelper;
+
+    public CodeActionHandler(TextHelper textHelper, TextDocumentService textDocumentService, CacheService cacheService, TypeResolver typeResolver, LogService logService, ConversionHelper conversionHelper) {
+        this.textHelper = textHelper;
+        this.textDocumentService = textDocumentService;
+        this.cacheService = cacheService;
+        this.typeResolver = typeResolver;
+        this.logService = logService;
+        this.conversionHelper = conversionHelper;
+    }
+
+    public static Range wholeDocumentRange(String text) {
+        if (text == null || text.isEmpty()) {
+            return new Range(new Position(0, 0), new Position(0, 0));
+        }
+
+        int lastLine = 0;
+        int lastBreak = -1; // Index des letzten Zeilenumbruchszeichens, das zum Zeilenende gehört
+
+        final int n = text.length();
+        for (int i = 0; i < n; i++) {
+            char c = text.charAt(i);
+            if (c == '\n') {
+                lastLine++;
+                lastBreak = i;
+            } else if (c == '\r') {
+                // Unterscheide \r\n von alleine stehendem \r
+                if (i + 1 < n && text.charAt(i + 1) == '\n') {
+                    lastLine++;
+                    lastBreak = i + 1;
+                    i++; // \n überspringen
+                } else {
+                    lastLine++;
+                    lastBreak = i;
+                }
+            }
+        }
+
+        int lastLineStart = lastBreak + 1;
+        int endChar = n - lastLineStart; // Länge der letzten Zeile in UTF-16 Code Units
+
+        return new Range(new Position(0, 0), new Position(lastLine, endChar));
+    }
+
+
+    public static <V> Map<String, V> getOverlapping(
+            Map<String, V> map,
+            int line,
+            int startChar,
+            int endChar
+    ) {
+        if (startChar > endChar) {
+            int t = startChar;
+            startChar = endChar;
+            endChar = t;
+        }
+
+        final int s = startChar, e = endChar;
+
+        return map.entrySet().stream()
+                .filter(entry -> {
+                    String key = entry.getKey();
+                    String[] parts = key.split("\\s+");
+                    if (parts.length != 2) return false;
+                    try {
+                        int kLine = Integer.parseInt(parts[0]);
+                        int kChar = Integer.parseInt(parts[1]);
+                        return kLine == line && kChar >= s && kChar <= e;
+                    } catch (NumberFormatException ex) {
+                        // Key nicht im erwarteten Format
+                        return false;
+                    }
+                })
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+
+
+    public List<Either<Command, CodeAction>> handleNewCodeAction(CodeActionParams params) {
+
+        String documentUri = params.getTextDocument().getUri();
+        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<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());
+        logService.log("Range is: " + rangeOfInsert.getStart().getLine() + " -> " + rangeOfInsert.getStart().getCharacter() + " - " + rangeOfInsert.getEnd().getCharacter());
+        List<Either<Command, CodeAction>> actions = new ArrayList<>();
+
+        for (var typeInsertList : typeInsertsOverlapping.values()) {
+            for (var typeInsert : typeInsertList) {
+                try {
+                    logService.log("NEW TEXT OF FILE BEFORE INSERT IS:");
+                    logService.log(textDocumentService.getFileOfUri(documentUri));
+                    String typeWithReplacedVariable = typeInsert.insert(textDocumentService.getFileOfUri(documentUri));
+
+                    ArrayList<TextEdit> listOfChanges = new ArrayList<>();
+
+                    listOfChanges.add(new TextEdit(wholeDocumentRange(textDocumentService.getFileOfUri(documentUri)), typeWithReplacedVariable));
+
+                    var isTypeImported = false;
+
+                    Map<String, List<TextEdit>> changes = new HashMap<>();
+                    changes.put(documentUri, listOfChanges);
+
+                    WorkspaceEdit edit = new WorkspaceEdit();
+                    edit.setChanges(changes);
+
+                    CodeAction action = new CodeAction("Insert " + conversionHelper.cleanType(typeInsert.getInsertString()));
+                    action.setKind(CodeActionKind.QuickFix);
+                    action.setEdit(edit);
+                    actions.add(Either.forRight(action));
+                } catch (Exception e) {
+                    logService.log("Error creating Actions, returning empty List. The Error was: " + e.getMessage(), MessageType.Error);
+                }
+            }
+        }
+        return actions;
+    }
+
+    public List<Either<Command, CodeAction>> handleCodeAction(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
+        List<Diagnostic> diagnosticsOverlappingHover = diagnosticInCurrentDocument.stream()
+                .filter(diagnostic -> textDocumentService.rangesOverlap(diagnostic.getRange(), rangeOfInsert)).toList();
+
+
+        List<Either<Command, CodeAction>> actions = new ArrayList<>();
+
+        for (Diagnostic typeDiagnostic : diagnosticsOverlappingHover) {
+            try {
+                String typeWithReplacedVariable = typeDiagnostic.getMessage() +
+                        " " +
+                        textHelper.getTextOfChars(
+                                textDocumentService.getFileOfUri(documentUri),
+                                rangeOfInsert.getStart().getLine(),
+                                rangeOfInsert.getStart().getCharacter(),
+                                rangeOfInsert.getEnd().getCharacter()
+                        );
+
+                ArrayList<TextEdit> listOfChanges = new ArrayList<>();
+
+                if (typeDiagnostic.getCode().getLeft().equals("GENERIC")) {
+                    for (var diagnostic : cacheService.getGlobalDiagnosticsMap().get(documentUri)) {
+
+                        if (diagnostic.getCode().getLeft().equals("GENERIC")) {
+                            String genericType = diagnostic.getMessage() +
+                                    " " +
+                                    textHelper.getTextOfChars(
+                                            textDocumentService.getFileOfUri(params.getTextDocument().getUri()),
+                                            diagnostic.getRange().getStart().getLine(),
+                                            diagnostic.getRange().getStart().getCharacter(),
+                                            diagnostic.getRange().getEnd().getCharacter()
+                                    );
+                            listOfChanges.add(new TextEdit(diagnostic.getRange(), genericType));
+                        }
+                    }
+                } else {
+                    listOfChanges.add(new TextEdit(rangeOfInsert, typeWithReplacedVariable));
+                }
+
+                var isTypeImported = false;
+
+                if (!typeDiagnostic.getCode().getLeft().equalsIgnoreCase("generic")) {
+                    isTypeImported = typeResolver.isTypeImported(textDocumentService.getFileOfUri(params.getTextDocument().getUri()), typeDiagnostic.getMessage());
+                }
+                if (!isTypeImported && !typeDiagnostic.getMessage().equals("void") && !typeDiagnostic.getCode().getLeft().equals("GENERIC")) {
+                    Range importRange = new Range(new Position(0, 0), new Position(0, 0));
+
+                    var typeWithoutGenerics = typeDiagnostic.getMessage().contains("<") ? typeDiagnostic.getMessage().substring(0, typeDiagnostic.getMessage().indexOf('<')) : typeDiagnostic.getMessage();
+                    listOfChanges.add(new TextEdit(importRange, "import " + typeWithoutGenerics + ";\n"));
+                }
+
+                Map<String, List<TextEdit>> changes = new HashMap<>();
+                changes.put(documentUri, listOfChanges);
+
+                WorkspaceEdit edit = new WorkspaceEdit();
+                edit.setChanges(changes);
+
+                CodeAction action = new CodeAction("Insert " + typeDiagnostic.getMessage());
+                action.setKind(CodeActionKind.QuickFix);
+                action.setEdit(edit);
+                actions.add(Either.forRight(action));
+            } catch (Exception e) {
+                logService.log("Error creating Actions, returning empty List. The Error was: " + e.getMessage(), MessageType.Error);
+            }
+        }
+        return actions;
+    }
+}

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

@@ -0,0 +1,38 @@
+package de.dhbw.handler;
+
+import de.dhbw.service.TextDocumentService;
+import org.eclipse.lsp4j.DocumentFormattingParams;
+import org.eclipse.lsp4j.Position;
+import org.eclipse.lsp4j.Range;
+import org.eclipse.lsp4j.TextEdit;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FormattingHandler {
+
+    private final TextDocumentService textDocumentService;
+
+    public FormattingHandler(TextDocumentService textDocumentService) {
+        this.textDocumentService = textDocumentService;
+    }
+
+    public List<TextEdit> handleFormat(DocumentFormattingParams params){
+        List<TextEdit> edits = new ArrayList<>();
+
+
+        String[] lines = textDocumentService.getFileOfUri(params.getTextDocument().getUri()).split("\n");
+        StringBuilder formattedText = new StringBuilder();
+
+        for (String line : lines) {
+            formattedText.append(line.stripTrailing()).append("\n");
+        }
+
+        TextEdit edit = new TextEdit();
+        edit.setRange(new Range(new Position(0, 0), new Position(lines.length, 0)));
+        edit.setNewText(formattedText.toString().trim());
+
+        edits.add(edit);
+        return edits;
+    }
+}

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

@@ -0,0 +1,96 @@
+package de.dhbw.handler;
+
+import com.google.common.base.Stopwatch;
+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.languageServerInterface.LanguageServerInterface;
+import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import org.eclipse.lsp4j.*;
+
+import java.net.URI;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SaveHandler {
+
+    private final TypeResolver typeResolver;
+    private final TextDocumentService textDocumentService;
+    private final LogService logService;
+    private final CacheService cacheService;
+    private final ConversionHelper conversionHelper;
+    private final ClientService clientService;
+    private final ParserService parserService;
+
+    public SaveHandler(TypeResolver typeResolver, TextDocumentService textDocumentService, LogService logService, CacheService cacheService, ConversionHelper conversionHelper, ClientService clientService, ParserService parserService) {
+        this.typeResolver = typeResolver;
+        this.textDocumentService = textDocumentService;
+        this.logService = logService;
+        this.cacheService = cacheService;
+        this.conversionHelper = conversionHelper;
+        this.clientService = clientService;
+        this.parserService = parserService;
+    }
+
+    public void handleSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
+
+        cacheService.reset();
+        typeResolver.reset();
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+
+        try {
+
+            String fileInput = textDocumentService.getFileOfUri(didSaveTextDocumentParams.getTextDocument().getUri());
+
+            List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(fileInput, didSaveTextDocumentParams.getTextDocument().getUri());
+            if (!syntaxErrors.isEmpty()) {
+                clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), syntaxErrors);
+            }
+            logService.log("Found [" + syntaxErrors.size() + "] Syntax Errors in Document.");
+
+            if (syntaxErrors.isEmpty()) {
+
+                cacheService.getLastSavedFiles().put(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
+                //typeResolver.getCompilerInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput);
+
+                if (fileInput == null) {
+                    logService.log("[didSave] Input of Text Document is null in TextDocument-Hashmap.", MessageType.Error);
+                }
+
+                ArrayList<LSPVariable> variables = typeResolver.infereInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput, false);
+                cacheService.setVariables(variables);
+
+                DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(variables, didSaveTextDocumentParams.getTextDocument().getUri());
+
+                List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+                List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
+
+                cacheService.updateGlobalMaps(diagnostics, typeHint, didSaveTextDocumentParams.getTextDocument().getUri());
+
+                List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
+
+                clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), allDiagnostics);
+
+            }
+
+        } 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());
+
+        } finally {
+            sWatch.stop();
+            logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
+        }
+    }
+}

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

@@ -0,0 +1,98 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.PlaceholderPoint;
+import de.dhbw.model.PlaceholderType;
+import de.dhbw.model.PlaceholderVariable;
+import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.syntaxtree.type.*;
+import de.dhbwstuttgart.target.generate.GenerateGenerics;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.target.generate.GenericsResultSet;
+
+import de.dhbwstuttgart.typeinference.result.*;
+import org.antlr.v4.runtime.Token;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class ASTTransformationHelper {
+
+    public static Set<PlaceholderVariable> createTypeInsertPoints(SourceFile forSourcefile, ResultSet withResults, GenericsResult generics) {
+    	return new PlaceholderPlacer().getTypeInserts(forSourcefile, withResults, generics);
+    }
+
+    public static PlaceholderVariable createInsertPoints(RefTypeOrTPHOrWildcardOrGeneric type, Token offset, ClassOrInterface cl, Method m,
+														 ResultSet resultSet, GenericsResultSet constraints, GenericsResultSet classConstraints) {
+
+			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());
+    }
+
+    private static synchronized Set<PlaceholderPoint> createGenericInsert(GenericsResultSet methodConstraints, GenericsResultSet classConstraints, ClassOrInterface cl, Method m, ResultSet resultSet, Token mOffset){
+        Set<PlaceholderPoint> result = createGenericClassInserts(classConstraints, cl);
+    	
+    	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 += ", ";
+        }
+
+        insert = insert.substring(0, insert.length() -2);
+        insert += ">";
+
+        result.add(new PlaceholderPoint(offset, insert, PlaceholderType.GENERIC_CLASS_INSERT));
+        
+        return result;
+	}
+}
+

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

@@ -0,0 +1,128 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.DiagnosticsAndTypehints;
+import de.dhbw.service.TextDocumentService;
+import de.dhbw.model.LSPVariable;
+import de.dhbw.model.Type;
+import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import org.eclipse.lsp4j.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ConversionHelper {
+
+    private final TextHelper textHelper;
+    private final TextDocumentService textDocumentService;
+
+    public ConversionHelper(TextHelper textHelper, TextDocumentService textDocumentService) {
+        this.textHelper = textHelper;
+        this.textDocumentService = textDocumentService;
+    }
+
+    public String cleanType(String type){
+        return type.replaceAll("java.lang.", "").replaceAll("java.util.", "");
+    }
+
+    public InlayHint getInlayHint(LSPVariable variable) {
+        InlayHint inlayHint = new InlayHint();
+
+        String typeDisplay = "";
+        for (Type type : variable.getPossibleTypes()) {
+                typeDisplay += " | " + cleanType(type.getType().replaceAll("GTV ", ""));
+        }
+
+
+        inlayHint.setLabel(typeDisplay.length() > 2 ? typeDisplay.substring(2) : typeDisplay);
+        inlayHint.setPosition(new Position(variable.getLine() - 1, variable.getCharPosition()));
+        inlayHint.setKind(InlayHintKind.Parameter);
+        inlayHint.setPaddingRight(true);
+        inlayHint.setPaddingRight(true);
+        return inlayHint;
+    }
+
+    public Diagnostic getDiagnostic(LSPVariable variable, String fileUri, Type type) {
+        Range errorRange = new Range(
+                new Position(variable.getLine() - 1, variable.getCharPosition()),               // Startposition
+                new Position(variable.getLine() - 1, textHelper.getEndingCharOfStartingChar(variable.getLine() - 1, variable.getCharPosition(), textDocumentService.getFileOfUri(fileUri)))    // Endposition
+        );
+        Diagnostic diagnostic = new Diagnostic(
+                errorRange,
+                //TODO: REMOVE! Temporary Fix because GTV, like TPH can be thrown away in the TypeResolver
+                cleanType(type.getType().replaceAll("GTV ", "")),
+                DiagnosticSeverity.Hint,
+                "JavaTX Language Server"
+        );
+        diagnostic.setCode(type.isGeneric() ? "GENERIC" : "TYPE");
+
+        return diagnostic;
+    }
+
+    public Diagnostic getDiagnosticWithInput(LSPVariable variable, String input, Type type) {
+        Range errorRange = new Range(
+                new Position(variable.getLine() - 1, variable.getCharPosition()),               // Startposition
+                new Position(variable.getLine() - 1, textHelper.getEndingCharOfStartingChar(variable.getLine() - 1, variable.getCharPosition(), input))    // Endposition
+        );
+        Diagnostic diagnostic = new Diagnostic(
+                errorRange,
+                //TODO: REMOVE! Temporary Fix because GTV, like TPH can be thrown away in the TypeResolver
+                cleanType(type.getType().replaceAll("GTV ", "")),
+                DiagnosticSeverity.Hint,
+                "JavaTX Language Server"
+        );
+        diagnostic.setCode(type.isGeneric() ? "GENERIC" : "TYPE");
+
+        return diagnostic;
+    }
+
+    public List<Diagnostic> parseErrorToDiagnostic(List<ParserError> parserErrors) {
+        return parserErrors.stream().map(el -> {
+            Range errorRange = new Range(
+                    new Position(el.getLine() - 1, el.getCharPositionInLine()),        // Startposition
+                    new Position(el.getLine() - 1, el.getEndCharPosition())            // Endposition
+            );
+            return new Diagnostic(
+                    errorRange,
+                    el.getMsg(),
+                    DiagnosticSeverity.Error,
+                    "JavaTX Language Server"
+            );
+        }).toList();
+    }
+
+    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehints(ArrayList<LSPVariable> typesOfMethodAndParameters, String uri) {
+        List<InlayHint> typeHint = new ArrayList<>();
+        ArrayList<Diagnostic> diagnostics = new ArrayList<>();
+
+        for (var variable : typesOfMethodAndParameters) {
+
+            InlayHint inlayHint = getInlayHint(variable);
+            typeHint.add(inlayHint);
+
+            for (var type : variable.getPossibleTypes()) {
+                Diagnostic diagnostic = getDiagnostic(variable, uri, type);
+                diagnostics.add(diagnostic);
+            }
+        }
+
+        return new DiagnosticsAndTypehints(diagnostics, typeHint);
+    }
+
+    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehintsWithInput(ArrayList<LSPVariable> typesOfMethodAndParameters, String input) {
+        List<InlayHint> typeHint = new ArrayList<>();
+        ArrayList<Diagnostic> diagnostics = new ArrayList<>();
+
+        for (var variable : typesOfMethodAndParameters) {
+
+            InlayHint inlayHint = getInlayHint(variable);
+            typeHint.add(inlayHint);
+
+            for (var type : variable.getPossibleTypes()) {
+                Diagnostic diagnostic = getDiagnosticWithInput(variable, input, type);
+                diagnostics.add(diagnostic);
+            }
+        }
+
+        return new DiagnosticsAndTypehints(diagnostics, typeHint);
+    }
+}

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

@@ -0,0 +1,34 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.Type;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class DuplicationUtils {
+    public ArrayList<Type> filterOutDuplicates(List<Type> typeListOne, List<Type> typeListTwo) {
+
+        ArrayList<Type> filteredArrayList = new ArrayList<>();
+
+        typeListOne.forEach(el -> {
+            boolean found = false;
+            for (Type typeInListTwo : typeListTwo) {
+                found = found || typeInListTwo.getType().equals(el.getType());
+            }
+            if (!found) {
+                filteredArrayList.add(el);
+            }
+        });
+
+        return filteredArrayList;
+    }
+
+    public ArrayList<Type> filterOutDuplicates(List<Type> typeListOne) {
+        HashMap<String, Type> hashMap = new HashMap<>();
+        typeListOne.forEach(el -> {
+            hashMap.put(el.getType(), el);
+        });
+        return new ArrayList<>(hashMap.values());
+    }
+}

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

@@ -0,0 +1,32 @@
+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);
+        inserts.forEach(el -> el.reducePackage());
+        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/TextHelper.java

@@ -2,8 +2,6 @@ package de.dhbw.helper;
 
 import org.apache.log4j.Logger;
 
-import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 
 public class TextHelper {
@@ -59,7 +57,7 @@ public class TextHelper {
 
         if(lines.length < line){
             log.warn("Returning hardcoded Value because the requested Line [" + line + "] does not exist in Text Document.");
-            return startChar+3;
+            return startChar;
         }
 
         String[] linesInChar = lines[line].split("");

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

@@ -2,81 +2,66 @@ 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;
-import de.dhbwstuttgart.syntaxtree.ClassOrInterface;
-import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.parser.scope.JavaClassName;
 import de.dhbwstuttgart.syntaxtree.SourceFile;
-import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+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.typeinference.result.ResultSet;
 import org.apache.log4j.LogManager;
 import org.apache.log4j.Logger;
-import org.eclipse.lsp4j.MessageParams;
-import org.eclipse.lsp4j.MessageType;
-import org.eclipse.lsp4j.Range;
-import org.eclipse.lsp4j.TextDocumentContentChangeEvent;
-import org.eclipse.lsp4j.services.LanguageClient;
 
+import java.io.File;
 import java.io.IOException;
+import java.io.OutputStream;
+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.*;
-import java.util.stream.Collectors;
 
 
 /**
  * Helper-Class for finding the Type of a selected Word
  */
 public class TypeResolver {
-
-    HashMap<Integer, LanguageServerTransferObject> dataCache = new HashMap<>();
-
     private static final Logger logger = LogManager.getLogger(TypeResolver.class);
 
-    private final boolean ENABLE_GENERICS = false;
+    private final TypeUtils typeUtils;
+    private final DuplicationUtils duplicationUtils;
+    private final boolean ENABLE_GENERICS = true;
+    private List<GenericsResult> generatedGenerics = null;
+    private HashMap<String, List<PlaceholderVariable>> inserts;
+
+
+    public HashMap<String, List<PlaceholderVariable>> getInserts() {
+        return inserts;
+    }
+
+    //Somehow you have to reset to the Letter N to keep the naming of the TPHs consistent
+    private final String RESET_TO_LETTER = "A";
 
     private LanguageServerTransferObject current;
 
-    public LanguageServerTransferObject getCurrent() {
-        return current;
+    public void reset() {
+        HashMap<String, List<TypeInsert>> inserts = null;
+        List<GenericsResult> generatedGenerics = null;
+        current = null;
     }
 
-    public void reduceCurrent() {
-        current.getResultSets().removeFirst();
-    }
-
-    private List<ResultSet> currentResults = new ArrayList<>();
-
-    public List<ResultSet> getCurrentResults() {
-        return currentResults;
-    }
-
-    public void setCurrentResults(List<ResultSet> currentResults) {
-        this.currentResults = currentResults;
-    }
-
-    public void addToCurrentResults(List<ResultSet> additionalResults) {
-        this.currentResults.addAll(additionalResults);
-    }
 
     public TypeResolver() {
+        this.typeUtils = new TypeUtils();
+        this.duplicationUtils = new DuplicationUtils();
     }
 
 
-    private LanguageServerTransferObject getCacheOrCalculate(String input, String path) throws IOException, ClassNotFoundException, URISyntaxException {
-        logger.info("Trying to find cached Compiler-Answer for input with key [" + input.hashCode() + "].");
-        LanguageServerInterface languageServer = new LanguageServerInterface();
-        if (dataCache.containsKey(input.hashCode())) {
-            logger.info("Found Cache for the Input with key [" + input.hashCode() + "].");
-            return dataCache.get(input.hashCode());
-        } else {
-            logger.info("Could not find Cache for Input with key [" + input.hashCode() + "]. Using Compiler Interface and Saving the Answer in Cache.");
-            var transferObject = languageServer.getResultSetAndAbstractSyntax(path, input);
-            dataCache.put(input.hashCode(), transferObject);
-            return transferObject;
-        }
-    }
-
     public boolean isTypeImported(String input, String type) {
 //        try {
 //            var transferObject = getCacheOrCalculate(input);
@@ -95,214 +80,143 @@ public class TypeResolver {
         return true;
     }
 
-    public ArrayList<Type> getAvailableTypes(List<ResultSet> resultSets, Method method) {
-        logger.info("Searching for resulting Types of Placeholder [" + method.getReturnType().toString() + "].");
-        ArrayList<String> normalType = new ArrayList<>();
-
-        resultSets.forEach(conSet -> {
-            if (method.getReturnType().toString().toLowerCase().contains("tph ")) {
-                normalType.add(conSet.resolveType(method.getReturnType()).resolvedType.toString());
-            }
-        });
-
-
-        return new ArrayList<>(normalType.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, false)).toList());
-
-    }
-
-    public ArrayList<Type> getAvailableGenericTypes(List<GenericsResult> genericsResult, Method method) {
-        logger.info("Searching for resulting Types of Placeholder [" + method.getReturnType().toString() + "].");
-        ArrayList<String> genericTypes = new ArrayList<>();
-
-        genericsResult.forEach(conSet -> {
-            if (method.getReturnType().toString().toLowerCase().contains("tph ")) {
-                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());
-
-    }
-
-    public ArrayList<Type> getAvailableGenericTypes(List<GenericsResult> genericsResult, RefTypeOrTPHOrWildcardOrGeneric parameter) {
-        logger.info("Searching for resulting Types of Placeholder [" + parameter.toString() + "].");
-
-        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> getAvailableTypes(List<ResultSet> resultSets, RefTypeOrTPHOrWildcardOrGeneric parameter) {
-        logger.info("Searching for resulting Types of Placeholder [" + parameter.toString() + "].");
-
-        ArrayList<String> paramTypes = new ArrayList<>();
-        resultSets.forEach(conSet -> {
-            if (parameter.toString().toLowerCase().contains("tph ")) {
-                paramTypes.add(conSet.resolveType(parameter).resolvedType.toString());
-            }
-        });
-
-        return new ArrayList<>(paramTypes.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, false)).toList());
-    }
-
-    public ArrayList<Type> filterOutDuplicates(List<Type> typeListOne, List<Type> typeListTwo) {
-
-        ArrayList<Type> filteredArrayList = new ArrayList<>();
-
-        typeListOne.forEach(el -> {
-            boolean found = false;
-            for (Type typeInListTwo : typeListTwo) {
-                found = found || typeInListTwo.getType().equals(el.getType());
-            }
-            if (!found) {
-                filteredArrayList.add(el);
-            }
-        });
-
-        return filteredArrayList;
-    }
-
-    public ArrayList<Type> filterOutDuplicates(List<Type> typeListOne) {
-        HashMap<String, Type> hashMap = new HashMap<>();
-        typeListOne.forEach(el -> {
-            hashMap.put(el.getType(), el);
-        });
-        return new ArrayList<>(hashMap.values());
-    }
-
-    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 void getCompilerInput(String path, String input) throws IOException, URISyntaxException, ClassNotFoundException {
         LanguageServerInterface languageServer = new LanguageServerInterface();
-        var transferObj = languageServer.getResultSetAndAbstractSyntax(path, input);
+        var transferObj = languageServer.getResultSetAndAbastractSyntax(path, RESET_TO_LETTER);
         current = transferObj;
     }
 
-    /**
-     * Zum Erhalt für sowohl Parameter als auch Methoden.
-     */
-    public ArrayList<LSPVariable> infereInput(String input, String path) throws IOException, ClassNotFoundException, URISyntaxException {
-        logger.info("Infering Types for Input.");
-
-        LanguageServerTransferObject transferObj;
-
+    public LanguageServerTransferObject updateIfNotPresent(String path, String input) throws IOException, URISyntaxException, ClassNotFoundException {
         if (current == null) {
             LanguageServerInterface languageServer = new LanguageServerInterface();
-            transferObj = languageServer.getResultSetAndAbstractSyntax(path, input);
-            current = transferObj;
-        } else {
-            transferObj = current;
+            LanguageServerTransferObject transferObj = languageServer.getResultSetAndAbstractSyntax(path);
+            return transferObj;
         }
-
-        ArrayList<LSPVariable> methodsWithParametersLSPVariableList = new ArrayList<>();
-
-
-        if (!transferObj.getResultSets().isEmpty()) {
-            //TODO: Hier noch irgendwie die Klasse rausfinden oder durchgehen.
-
-            if (ENABLE_GENERICS) {
-                //GENERICS OF CLASS
-                for (var method : transferObj.getAst().getAllMethods()) {
-
-
-                    for (var clazz : transferObj.getAst().getClasses()) {
-                        ArrayList<Type> genericTypes = getClassGenerics(transferObj.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()));
-                        }
-                    }
-
-                }
-
-            }
-
-            for (var method : transferObj.getAst().getAllMethods()) {
-                var types = getAvailableTypes(transferObj.getResultSets(), method);
-                var generics = getAvailableGenericTypes(transferObj.getGeneratedGenerics().values().stream().flatMap(List::stream).collect(Collectors.toList()), method);
-
-                if (!filterOutDuplicates(types).isEmpty()) {
-                    methodsWithParametersLSPVariableList.add(new LSPMethod(method.name, filterOutDuplicates(types), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-                }
-
-                if (ENABLE_GENERICS) {
-                    if (!generics.isEmpty()) {
-                        ArrayList<Type> typesThatAreGeneric = 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 (!filterOutDuplicates(typesThatAreGeneric).isEmpty()) {
-                            methodsWithParametersLSPVariableList.add(new LSPMethod(method.name, filterOutDuplicates(typesThatAreGeneric), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-                        }
-                    }
-                }
-
-                for (var param : method.getParameterList()) {
-                    ArrayList<Type> typeParam = getAvailableTypes(transferObj.getResultSets(), param.getType());
-                    ArrayList<Type> genericParam = getAvailableGenericTypes(transferObj.getGeneratedGenerics().values().stream().flatMap(List::stream).collect(Collectors.toList()), param.getType());
-
-                    if (!typeParam.isEmpty()) {
-                        methodsWithParametersLSPVariableList.add(new LSPParameter(method.name, filterOutDuplicates(typeParam), param.getOffset().getLine(), param.getOffset().getCharPositionInLine(), param.getOffset().getStopIndex(), param.getType()));
-                    }
-
-                    if (ENABLE_GENERICS) {
-                        if (!genericParam.isEmpty()) {
-                            ArrayList<Type> typesThatAreGeneric = filterOutDuplicates(genericParam, typeParam);
-
-
-                            if (!filterOutDuplicates(typesThatAreGeneric).isEmpty()) {
-                                methodsWithParametersLSPVariableList.add(new LSPParameter(method.name, filterOutDuplicates(typesThatAreGeneric), method.getOffset().getLine(), param.getOffset().getCharPositionInLine(), param.getOffset().getStopIndex(), param.getType()));
-                                methodsWithParametersLSPVariableList.add(new LSPParameter(method.name, new ArrayList<>(filterOutDuplicates(typesThatAreGeneric).stream().map(el -> new Type("<" + el.getType() + ">", true)).toList()), method.getOffset().getLine(), method.getOffset().getCharPositionInLine(), method.getOffset().getStopIndex(), method.getReturnType()));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        return methodsWithParametersLSPVariableList;
+        return current;
     }
 
+    public ArrayList<LSPVariable> infereChangeInput() throws IOException, ClassNotFoundException, URISyntaxException {
+
+        Set<PlaceholderVariable> tips = new HashSet<>();
+
+        for (int i = 0; i < current.getResultSets().size(); i++) {
+            ResultSet tiResult = current.getResultSets().get(i);
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(current.getAst(), tiResult, generatedGenerics.get(i)));
+
+        }
+
+        HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
+
+        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 {
+                insertsOnLines.get(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine()).add(insert);
+            }
+        }
+
+        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) {
+
+            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 ArrayList<LSPVariable> infereInput(String pathString, String input, boolean a) throws IOException, ClassNotFoundException, URISyntaxException {
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+
+        LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+        LanguageServerTransferObject lsTransfer = languageServerInterface.getResultSetAndAbstractSyntax(pathString);
+
+        var parsedSource = lsTransfer.getAst();
+        var tiResults =  lsTransfer.getResultSets();
+        Set<PlaceholderVariable> tips = new HashSet<>();
+
+        generatedGenerics = lsTransfer.getGeneratedGenerics().get(lsTransfer.getAst());
+        for (int i = 0; i < tiResults.size(); i++) {
+            ResultSet tiResult = tiResults.get(i);
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, lsTransfer.getGeneratedGenerics().get(lsTransfer.getAst()).get(i)));
+        }
+        System.setOut(System.out);
+        this.current = lsTransfer;
+
+        HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
+
+        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 {
+                insertsOnLines.get(insert.point.point.getLine() + " " + insert.point.point.getCharPositionInLine()).add(insert);
+            }
+        }
+
+        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) {
 
-    public void reduceCurrent(HashMap<LineCharPosition, String> combinedList, List<LSPVariable> variables, LanguageClient client) {
-        client.logMessage(new MessageParams(MessageType.Info, "Lenght is: " + combinedList.size()));
         for (var lines : combinedList.entrySet()) {
             var contentChange = lines.getValue();
             for (LSPVariable variable : variables) {
                 for (Type typeOfVariable : variable.getPossibleTypes()) {
-                    client.logMessage(new MessageParams(MessageType.Info, "\"" + typeOfVariable.getType() + " : " + variable.getLine() + "\"<          > \"" + contentChange + " : " + lines.getKey() + "\""));
+
                     if (typeOfVariable.getType().equalsIgnoreCase(contentChange.replaceAll(" ", ""))) {
                         if (variable.getLine() - 1 == lines.getKey().line && variable.getCharPosition() == lines.getKey().charPosition) {
                             current.getResultSets().removeIf(el -> !el.resolveType(variable.getOriginalTphName()).resolvedType.toString().equalsIgnoreCase(contentChange.replaceAll(" ", "")));
-                            client.logMessage(new MessageParams(MessageType.Info, "Removing Resultset"));
+
                             return;
                         }
                     }
@@ -310,4 +224,19 @@ public class TypeResolver {
             }
         }
     }
+
+    public SourceFile getNewAst(String uri) throws IOException, URISyntaxException, ClassNotFoundException {
+        LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+        return languageServerInterface.getAst(uri, RESET_TO_LETTER);
+    }
+
+    public void updateAst(String uri) throws IOException, URISyntaxException, ClassNotFoundException {
+        logger.info("Old AST:");
+        logger.info(ASTPrinter.print(this.current.getAst()));
+        this.current = new LanguageServerTransferObject(current.getResultSets(), getNewAst(uri), "", current.getGeneratedGenerics());
+
+        logger.info("NEW AST:");
+        logger.info(ASTPrinter.print(current.getAst()));
+    }
+
 }

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

@@ -0,0 +1,39 @@
+package de.dhbw.helper;
+
+import de.dhbw.model.Type;
+import de.dhbwstuttgart.syntaxtree.Method;
+import de.dhbwstuttgart.syntaxtree.type.RefTypeOrTPHOrWildcardOrGeneric;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TypeUtils {
+
+    public ArrayList<Type> getAvailableTypes(List<ResultSet> resultSets, RefTypeOrTPHOrWildcardOrGeneric parameter) {
+
+        ArrayList<String> paramTypes = new ArrayList<>();
+        resultSets.forEach(conSet -> {
+            if (parameter.toString().toLowerCase().contains("tph ")) {
+                paramTypes.add(conSet.resolveType(parameter).resolvedType.toString());
+            }
+        });
+
+        return new ArrayList<>(paramTypes.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, false)).toList());
+    }
+
+    public ArrayList<Type> getAvailableTypes(List<ResultSet> resultSets, Method method) {
+        ArrayList<String> normalType = new ArrayList<>();
+
+        resultSets.forEach(conSet -> {
+            if (method.getReturnType().toString().toLowerCase().contains("tph ")) {
+                normalType.add(conSet.resolveType(method.getReturnType()).resolvedType.toString());
+            }
+        });
+
+
+        return new ArrayList<>(normalType.stream().filter(el -> !el.contains("TPH ")).map(el -> new Type(el, false)).toList());
+
+    }
+
+}

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

@@ -0,0 +1,33 @@
+package de.dhbw.model;
+
+import org.eclipse.lsp4j.Diagnostic;
+import org.eclipse.lsp4j.InlayHint;
+
+import java.util.List;
+
+public class DiagnosticsAndTypehints {
+    private List<Diagnostic> diagnostics;
+    private List<InlayHint> inlayHints;
+
+    public List<Diagnostic> getDiagnostics() {
+        return diagnostics;
+    }
+
+    public List<InlayHint> getInlayHints() {
+        return inlayHints;
+    }
+
+    public void setDiagnostics(List<Diagnostic> diagnostics) {
+        this.diagnostics = diagnostics;
+    }
+
+    public void setInlayHints(List<InlayHint> inlayHints) {
+        this.inlayHints = inlayHints;
+    }
+
+    public DiagnosticsAndTypehints(List<Diagnostic> diagnostics, List<InlayHint> inlayHints){
+        this.diagnostics = diagnostics;
+        this.inlayHints = inlayHints;
+    }
+
+}

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

@@ -0,0 +1,41 @@
+package de.dhbw.model;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class DocumentChanges {
+    HashMap<LineCharPosition, String> preciseChanges = new HashMap<>();
+    ArrayList<Integer> offsetPerLine = new ArrayList<>();
+    HashMap<Integer, List<String>> textChanges = new HashMap<>();
+
+    public ArrayList<Integer> getOffsetPerLine() {
+        return offsetPerLine;
+    }
+
+    public HashMap<Integer, List<String>> getTextChanges() {
+        return textChanges;
+    }
+
+    public HashMap<LineCharPosition, String> getPreciseChanges() {
+        return preciseChanges;
+    }
+
+    public void setOffsetPerLine(ArrayList<Integer> offsetPerLine) {
+        this.offsetPerLine = offsetPerLine;
+    }
+
+    public void setPreciseChanges(HashMap<LineCharPosition, String> preciseChanges) {
+        this.preciseChanges = preciseChanges;
+    }
+
+    public void setTextChanges(HashMap<Integer, List<String>> textChanges) {
+        this.textChanges = textChanges;
+    }
+
+    public DocumentChanges(HashMap<LineCharPosition, String> preciseChanges, ArrayList<Integer> offsetPerLine, HashMap<Integer, List<String>> textChanges){
+        this.preciseChanges = preciseChanges;
+        this.offsetPerLine = offsetPerLine;
+        this.textChanges = textChanges;
+    }
+}

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

@@ -0,0 +1,92 @@
+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 void setInsertString(String insertString){
+        this.insertString = insertString;
+    }
+
+    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; 
+    }
+
+    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,73 @@
+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 void reducePackage(){point.setInsertString(point.getInsertString().replaceAll("java\\.lang\\.", "").replaceAll("java\\.util\\.", ""));
+    }
+
+    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/model/Type.java

@@ -24,4 +24,15 @@ public class Type {
     public boolean isGeneric() {
         return generic;
     }
+
+
+    @Override
+    public boolean equals(Object obj) {
+        return type.equals(obj.toString());
+    }
+
+    @Override
+    public String toString() {
+        return type;
+    }
 }

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

@@ -0,0 +1,155 @@
+package de.dhbw.service;
+
+import de.dhbw.helper.CodeSnippetOptions;
+import de.dhbw.helper.TextHelper;
+import de.dhbw.helper.TypeResolver;
+import de.dhbw.model.LSPVariable;
+import de.dhbwstuttgart.typedeployment.TypeInsert;
+import org.eclipse.lsp4j.Diagnostic;
+import org.eclipse.lsp4j.InlayHint;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class CacheService {
+    private HashMap<String, List<InlayHint>> globalInlayHintMap = new HashMap<>();
+    private HashMap<String, String> lastSavedFiles = new HashMap<>();
+    private Boolean currentlyCalculating = false;
+    private HashMap<String, List<Diagnostic>> globalDiagnosticsMap = new HashMap<>();
+    private HashMap<String, String> textDocuments = new HashMap<>();
+    private CodeSnippetOptions codeSnippetOptions = new CodeSnippetOptions();
+    private TextHelper textHelper = new TextHelper();
+    private Boolean dontShowHints = false;
+    private TypeResolver typeResolver = new TypeResolver();
+    private Path fileRoot = null;
+    private Boolean singleFileOpened = false;
+    private List<LSPVariable> variables = new ArrayList<>();
+    private List<TypeInsert> typeInserts;
+
+    public List<TypeInsert> getTypeInserts() {
+        return typeInserts;
+    }
+
+    public void setTypeInserts(List<TypeInsert> typeInserts) {
+        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);
+    }
+
+    public Boolean getCurrentlyCalculating() {
+        return currentlyCalculating;
+    }
+
+    public Boolean getDontShowHints() {
+        return dontShowHints;
+    }
+
+    public Boolean getSingleFileOpened() {
+        return singleFileOpened;
+    }
+
+    public HashMap<String, String> getLastSavedFiles() {
+        return lastSavedFiles;
+    }
+
+    public void setLastSavedFiles(HashMap<String, String> lastSavedFiles) {
+        this.lastSavedFiles = lastSavedFiles;
+    }
+
+    public CodeSnippetOptions getCodeSnippetOptions() {
+        return codeSnippetOptions;
+    }
+
+    public HashMap<String, List<Diagnostic>> getGlobalDiagnosticsMap() {
+        return globalDiagnosticsMap;
+    }
+
+    public HashMap<String, List<InlayHint>> getGlobalInlayHintMap() {
+        return globalInlayHintMap;
+    }
+
+    public HashMap<String, String> getTextDocuments() {
+        return textDocuments;
+    }
+
+    public List<LSPVariable> getVariables() {
+        return variables;
+    }
+
+    public Path getFileRoot() {
+        return fileRoot;
+    }
+
+    public TextHelper getTextHelper() {
+        return textHelper;
+    }
+
+    public TypeResolver getTypeResolver() {
+        return typeResolver;
+    }
+
+    public void setCodeSnippetOptions(CodeSnippetOptions codeSnippetOptions) {
+        this.codeSnippetOptions = codeSnippetOptions;
+    }
+
+    public void setCurrentlyCalculating(Boolean currentlyCalculating) {
+        this.currentlyCalculating = currentlyCalculating;
+    }
+
+    public void setDontShowHints(Boolean dontShowHints) {
+        this.dontShowHints = dontShowHints;
+    }
+
+    public void setFileRoot(Path fileRoot) {
+        this.fileRoot = fileRoot;
+    }
+
+    public void setGlobalDiagnosticsMap(HashMap<String, List<Diagnostic>> globalDiagnosticsMap) {
+        this.globalDiagnosticsMap = globalDiagnosticsMap;
+    }
+
+    public void setGlobalInlayHintMap(HashMap<String, List<InlayHint>> globalInlayHintMap) {
+        this.globalInlayHintMap = globalInlayHintMap;
+    }
+
+    public void setSingleFileOpened(Boolean singleFileOpened) {
+        this.singleFileOpened = singleFileOpened;
+    }
+
+    public void setTextDocuments(HashMap<String, String> textDocuments) {
+        this.textDocuments = textDocuments;
+    }
+
+    public void setTextHelper(TextHelper textHelper) {
+        this.textHelper = textHelper;
+    }
+
+    public void setTypeResolver(TypeResolver typeResolver) {
+        this.typeResolver = typeResolver;
+    }
+
+    public void setVariables(List<LSPVariable> variables) {
+        this.variables = variables;
+    }
+}

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

@@ -0,0 +1,79 @@
+package de.dhbw.service;
+
+import org.eclipse.lsp4j.*;
+import org.eclipse.lsp4j.jsonrpc.messages.Either;
+import org.eclipse.lsp4j.services.LanguageClient;
+
+import java.util.List;
+
+public class ClientService {
+
+    private LanguageClient client;
+
+    public ClientService(LanguageClient client) {
+        this.client = client;
+    }
+
+    public void publishDiagnostics(String uri, List<Diagnostic> diagnostics){
+        PublishDiagnosticsParams diagnosticsParams = new PublishDiagnosticsParams(uri, diagnostics);
+        client.publishDiagnostics(diagnosticsParams);
+    }
+
+    public void sendClientLog(MessageType type, String message){
+        client.logMessage(new MessageParams(type, message));
+    }
+
+    public void sendClientLog(String message){
+        client.logMessage(new MessageParams(MessageType.Info, message));
+    }
+
+    public void showMessage(MessageType type, String message) {
+        client.showMessage(new MessageParams(type, message));
+    }
+
+    public void showMessage(String message) {
+        client.showMessage(new MessageParams(MessageType.Info, message));
+    }
+
+    public void setClient(LanguageClient client) {
+        this.client = client;
+    }
+
+    public void updateClient(LanguageClient client) {
+        client.refreshInlayHints();
+        client.refreshDiagnostics();
+    }
+
+    public void updateClient() {
+        client.refreshInlayHints();
+        client.refreshDiagnostics();
+    }
+
+    public LanguageClient getClient() {
+        return client;
+    }
+
+    public void startLoading(String taskName, String title, LanguageClient client) {
+        Either<String, Integer> token = Either.forLeft(taskName);
+        client.createProgress(new WorkDoneProgressCreateParams(token));
+
+        WorkDoneProgressBegin begin = new WorkDoneProgressBegin();
+        begin.setTitle(title);
+        begin.setCancellable(false);
+        begin.setPercentage(0);
+
+        ProgressParams beginParams = new ProgressParams(token, Either.forLeft(begin));
+        client.notifyProgress(beginParams);
+
+    }
+
+    public void stopLoading(String taskName, String title, LanguageClient client) {
+        Either<String, Integer> token = Either.forLeft(taskName);
+        WorkDoneProgressEnd end = new WorkDoneProgressEnd();
+        end.setMessage(title);
+
+        ProgressParams endParams = new ProgressParams(token, Either.forLeft(end));
+        client.notifyProgress(endParams);
+    }
+
+}

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

@@ -0,0 +1,31 @@
+package de.dhbw.service;
+
+import org.apache.log4j.LogManager;
+import org.apache.log4j.Logger;
+import org.eclipse.lsp4j.MessageType;
+
+public class LogService {
+
+    private final Logger logger = LogManager.getLogger(LogService.class);
+    private final ClientService clientService;
+
+    public LogService(ClientService clientService) {
+        this.clientService = clientService;
+    }
+
+    public void log(String message, MessageType type) {
+        clientService.sendClientLog(type, message);
+        switch (type) {
+            case Error -> logger.error(message);
+            case Warning -> logger.warn(message);
+            case Info -> logger.info(message);
+            default -> logger.debug(message);
+        }
+    }
+
+    public void log(String message) {
+        clientService.sendClientLog(MessageType.Info, message);
+        logger.info(message);
+    }
+
+}

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

@@ -0,0 +1,35 @@
+package de.dhbw.service;
+
+import de.dhbw.helper.ConversionHelper;
+import de.dhbwstuttgart.languageServerInterface.ParserInterface;
+import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import org.eclipse.lsp4j.Diagnostic;
+
+import java.util.List;
+
+public class ParserService {
+
+    private final ConversionHelper conversionHelper;
+    private final ClientService clientService;
+
+
+    public ParserService(ConversionHelper conversionHelper, ClientService clientService, CacheService cacheService) {
+        this.conversionHelper = conversionHelper;
+        this.clientService = clientService;
+    }
+
+    public List<ParserError> getParserErrors(String input){
+        ParserInterface parserInterface = new ParserInterface();
+        return parserInterface.getParseErrors(input);
+    }
+
+    public void checkParser(String input, String uri) {
+        List<Diagnostic> diagnosticsList = conversionHelper.parseErrorToDiagnostic(getParserErrors(input));
+        clientService.publishDiagnostics(uri, diagnosticsList);
+    }
+
+    public List<Diagnostic> getDiagnosticsOfErrors(String input, String uri) {
+        return conversionHelper.parseErrorToDiagnostic(getParserErrors(input));
+
+    }
+}

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

@@ -0,0 +1,121 @@
+package de.dhbw.service;
+
+import de.dhbw.model.DocumentChanges;
+import de.dhbw.model.LineCharPosition;
+import org.eclipse.lsp4j.Range;
+
+import java.util.*;
+
+public class TextDocumentService {
+
+    private final HashMap<String, String> files = new HashMap<>();
+
+    public TextDocumentService(){
+
+    }
+
+    public void reset(){
+        files.clear();
+    }
+
+
+    public String getFileOfUri(String uri) {
+        return files.get(uri);
+    }
+
+    public void saveFileWithUri(String uri, String input) {
+        files.put(uri, input);
+    }
+
+    public DocumentChanges calculateDifference(String currentText, String newText){
+        ArrayList<String> currentTextLines = new ArrayList<>(Arrays.stream(currentText.split("\n")).toList());
+        ArrayList<String> newTextLines = new ArrayList<>(Arrays.stream(newText.split("\n")).toList());
+        HashMap<LineCharPosition, String> preciseChanges = new HashMap<>();
+        ArrayList<Integer> offsetPerLine = new ArrayList<>();
+        HashMap<Integer, List<String>> textChanges = new HashMap<>();
+        int index = 0;
+        for (String newTextLine : newTextLines) {
+            if (!(currentTextLines.size() > index)) {
+                offsetPerLine.add(0);
+            } else {
+                Map<LineCharPosition, String> lineDiffs = differenceLinePos(currentTextLines.get(index), newTextLine, index);
+                preciseChanges.putAll(lineDiffs);
+                textChanges.put(index, difference(currentTextLines.get(index), newTextLine).stream().map(el -> el.replaceAll(" ", "")).toList());
+                offsetPerLine.add(newTextLine.length() - currentTextLines.get(index).length());
+            }
+
+            index++;
+        }
+
+        return new DocumentChanges(preciseChanges, offsetPerLine, textChanges);
+    }
+
+    public Map<LineCharPosition, String> differenceLinePos(String first, String second, int line) {
+        Map<LineCharPosition, String> result = new HashMap<>();
+
+        int i = 0, j = 0;
+        int startDiff = -1;
+
+        while (j < second.length()) {
+            if (i < first.length() && first.charAt(i) == second.charAt(j)) {
+                if (startDiff != -1) {
+                    String diff = second.substring(startDiff, j);
+                    result.put(new LineCharPosition(line, startDiff), diff);
+                    startDiff = -1;
+                }
+                i++;
+                j++;
+            } else {
+                if (startDiff == -1) {
+                    startDiff = j;
+                }
+                j++;
+            }
+        }
+
+        if (startDiff != -1) {
+            String diff = second.substring(startDiff);
+            result.put(new LineCharPosition(line, startDiff), diff);
+        }
+
+        return result;
+    }
+
+    public ArrayList<String> difference(String first, String second) {
+        ArrayList<String> result = new ArrayList<>();
+
+        int i = 0, j = 0;
+        int startDiff = -1;
+
+        while (j < second.length()) {
+            if (i < first.length() && first.charAt(i) == second.charAt(j)) {
+                if (startDiff != -1) {
+                    result.add(second.substring(startDiff, j));
+                    startDiff = -1;
+                }
+                i++;
+                j++;
+            } else {
+                if (startDiff == -1) {
+                    startDiff = j;
+                }
+                j++;
+            }
+        }
+
+        if (startDiff != -1) {
+            result.add(second.substring(startDiff));
+        }
+
+        return result;
+    }
+
+    public boolean rangesOverlap(Range range1, Range range2) {
+        int start1 = range1.getStart().getLine() * 1000 + range1.getStart().getCharacter();
+        int end1 = range1.getEnd().getLine() * 1000 + range1.getEnd().getCharacter();
+        int start2 = range2.getStart().getLine() * 1000 + range2.getStart().getCharacter();
+        int end2 = range2.getEnd().getLine() * 1000 + range2.getEnd().getCharacter();
+
+        return start1 <= end2 && start2 <= end1;
+    }
+}

LanguageServer/src/test/java/CodeSnippetOptionsTest.java

@@ -1,6 +1,5 @@
 
 import de.dhbw.helper.CodeSnippetOptions;
-import de.dhbw.model.SnippetWithName;
 import org.junit.jupiter.api.Test;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;

LanguageServer/src/test/java/CompilerInterfaceTest.java

@@ -1,6 +1,7 @@
 
 import de.dhbw.helper.TextHelper;
 import de.dhbw.helper.TypeResolver;
+import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -11,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<>();
 //
@@ -49,18 +27,16 @@ public class CompilerInterfaceTest {
     }
 
     @Test
-    public void testConstraintTypes() throws IOException, ClassNotFoundException {
-//        LanguageServerInterface languageServer = new LanguageServerInterface();
-//        TypeResolver typeResolver = new TypeResolver();
-//
-//
-//        var res = typeResolver.infereInput("import java.lang.Integer; public class test{\n" +
-//                "    \n" +
-//                "    public main(testa){\n" +
-//                "   return testa;\n" +
-//                "    }\n" +
-//                "}");
-//        res.forEach(el -> el.getPossibleTypes().forEach(el2 -> System.out.println(el2.getType() + " " + (el2.isGeneric() ? "GENERIC" : "NO GENERIC"))));
+    public void testConstraintTypes() throws IOException, ClassNotFoundException, URISyntaxException {
+        LanguageServerInterface languageServer = new LanguageServerInterface();
+        TypeResolver typeResolver = new TypeResolver();
+
+
+        var res = languageServer.getResultSetAndAbstractSyntax("/home/ruben/Documents/JavaTXLanguageServer/test/test.jav");
+
+        var res2 = languageServer.getResultSetAndAbstractSyntax("/home/ruben/Documents/JavaTXLanguageServer/test/test.jav");
+
+        System.out.println("");
     }
 
     @Test

LanguageServer/src/test/java/JavaTXLanguageDocumentServiceTest.java

@@ -1,7 +1,3 @@
-import de.dhbw.JavaTXTextDocumentService;
-import de.dhbw.helper.CodeSnippetOptions;
-import org.eclipse.lsp4j.DidSaveTextDocumentParams;
-import org.eclipse.lsp4j.TextDocumentIdentifier;
 import org.junit.Ignore;
 import org.junit.jupiter.api.Test;
 

README.md

@@ -55,6 +55,10 @@ The Language Server in itself can be used for any Client. The Clients task is to
 
 ![Diagram](docs/diagram.png)
 
+## Additional Information
+
+- Uses the [LSP-Interface](https://gitea.hb.dhbw-stuttgart.de/JavaTX/JavaCompilerCore/src/branch/LSP-Interface) Branch of the Java-TX Compiler Repository
+
 ## Update JavaTX Compiler Dependency as Maven Package
 If you make changes in the Compiler Interface, you have to change the jar and therefore the Dependency in the Java TX Language Server
 You can follow this steps:

test/test.jav

@@ -0,0 +1,5 @@
+public class t{
+    public test(){
+        return 1;
+    }
+}