refactor: rename package

Reviewed-on: #36

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/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/vsc-extension-quickstart.md

@@ -1 +1,44 @@
-LSP-Client for Java-TX
+# Welcome to your VS Code Extension
+
+## What's in the folder
+
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+  * The sample plugin registers a command and defines its title and command name. With this information VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `src/extension.ts` - this is the main file where you will provide the implementation of your command.
+  * The file exports one function, `activate`, which is called the very first time your extension is activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+  * We pass the function containing the implementation of the command as the second parameter to `registerCommand`.
+
+## Get up and running straight away
+
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `src/extension.ts` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+
+* You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+## Explore the API
+
+* You can open the full set of our API when you open the file `node_modules/@types/vscode/index.d.ts`.
+
+## Run tests
+
+* Install the [Extension Test Runner](https://marketplace.visualstudio.com/items?itemName=ms-vscode.extension-test-runner)
+* Run the "watch" task via the **Tasks: Run Task** command. Make sure this is running, or tests might not be discovered.
+* Open the Testing view from the activity bar and click the Run Test" button, or use the hotkey `Ctrl/Cmd + ; A`
+* See the output of the test result in the Test Results view.
+* Make changes to `src/test/extension.test.ts` or create new test files inside the `test` folder.
+  * The provided test runner will only consider files matching the name pattern `**.test.ts`.
+  * You can create folders inside the `test` folder to structure your tests any way you want.
+
+## Go further
+
+* [Follow UX guidelines](https://code.visualstudio.com/api/ux-guidelines/overview) to create extensions that seamlessly integrate with VS Code's native interface and patterns.
+* Reduce the extension size and improve the startup time by [bundling your extension](https://code.visualstudio.com/api/working-with-extensions/bundling-extension).
+* [Publish your extension](https://code.visualstudio.com/api/working-with-extensions/publishing-extension) on the VS Code extension marketplace.
+* Automate builds by setting up [Continuous Integration](https://code.visualstudio.com/api/working-with-extensions/continuous-integration).
+* Integrate to the [report issue](https://code.visualstudio.com/api/get-started/wrapping-up#issue-reporting) flow to get issue and feature requests reported by users.

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/JavaTXTextDocumentService.java

@@ -1,42 +1,48 @@
 package de.dhbw;
 
 import com.google.common.base.Stopwatch;
-import de.dhbw.handler.UpdatePositionHandler;
+import de.dhbw.service.CacheService;
+import de.dhbw.service.ClientService;
+import de.dhbw.service.LogService;
+import de.dhbw.handler.SaveHandler;
 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 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 SaveHandler saveHandler;
+    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;
+    TextHelper textHelper = new TextHelper();
+
     private static final Logger logger = LogManager.getLogger(JavaTXTextDocumentService.class);
     LanguageClient client;
     HashMap<String, List<InlayHint>> globalInlayHintMap = new HashMap<>();
@@ -44,15 +50,24 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     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.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.saveHandler = new SaveHandler(typeResolver, textDocumentService, logService, cacheService, conversionHelper, clientService);
+    }
+
     public void setClient(LanguageClient client) {
         this.client = client;
+        clientService.setClient(client);
     }
 
     public void setFileRoot(List<WorkspaceFolder> root) {
@@ -84,6 +99,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
             completions.add(item);
         }
 
+
         return CompletableFuture.completedFuture(Either.forLeft(completions));
     }
 
@@ -97,6 +113,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     @Override
     public void didOpen(DidOpenTextDocumentParams params) {
         textDocuments.put(params.getTextDocument().getUri(), params.getTextDocument().getText());
+        textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), params.getTextDocument().getText());
     }
 
 
@@ -131,6 +148,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
 
     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;
 
@@ -179,8 +197,6 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
         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;
@@ -194,7 +210,6 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
                 preciseChanges.putAll(lineDiffs);
 
                 textChanges.put(index, difference(currentTextLines.get(index), newTextLine).stream().map(el -> el.replaceAll(" ", "")).toList());
-                client.logMessage(new MessageParams(MessageType.Info, "For Line " + index + " difference of " + (newTextLine.length() - currentTextLines.get(index).length())));
                 offsetPerLine.add(newTextLine.length() - currentTextLines.get(index).length());
             }
 
@@ -205,6 +220,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
         AtomicReference<String> summedUp = new AtomicReference<>("");
         params.getContentChanges().forEach(el -> summedUp.set(summedUp.get() + el.getText()));
         textDocuments.put(params.getTextDocument().getUri(), summedUp.get());
+        textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), summedUp.get());
 
         String input = summedUp.get();
 
@@ -225,12 +241,22 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
             );
         }).toList();
 
-        client.publishDiagnostics(new PublishDiagnosticsParams(params.getTextDocument().getUri(), diagnosticsList));
 
+//        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();
@@ -247,23 +273,17 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
                 for (var variable : typesOfMethodAndParameters) {
 
                     InlayHint inlayHint = getInlayHint(variable);
-                inlayHint.getPosition().setCharacter(inlayHint.getPosition().getCharacter() + offsetPerLine.get(inlayHint.getPosition().getLine()));
                     typeHint.add(inlayHint);
 
 
                     //Diagnostics of Types
                     for (var type : variable.getPossibleTypes()) {
                         Diagnostic diagnostic = getDiagnostic(variable, params.getTextDocument().getUri(), type);
-                    diagnostic.getRange().getStart().setCharacter(diagnostic.getRange().getStart().getCharacter() + offsetPerLine.get(diagnostic.getRange().getStart().getLine()));
-                    diagnostic.getRange().getEnd().setCharacter(diagnostic.getRange().getEnd().getCharacter() + offsetPerLine.get(diagnostic.getRange().getEnd().getLine()));
                         diagnostics.add(diagnostic);
                     }
                 }
 
-
-            globalDiagnosticsMap.put(params.getTextDocument().getUri(), diagnostics);
-            globalInlayHintMap.put(params.getTextDocument().getUri(), typeHint);
-//            updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
+                updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
 
 
             } catch (Exception e) {
@@ -276,6 +296,21 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
                 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.
@@ -288,8 +323,6 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
             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())));
     }
@@ -404,74 +437,11 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
 
     @Override
     public void didSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
-        log("[didSave] Client triggered didSave-Event.", MessageType.Info);
-
+        logService.log("[didSave] Client triggered didSave-Event.");
         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);
-            }
-
-
-        }
-
+        saveHandler.handleSave(didSaveTextDocumentParams);
         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) {
-            }
-        }
+        clientService.updateClient(client);
     }
 
     @Override

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

@@ -0,0 +1,55 @@
+package de.dhbw.handler;
+
+import com.github.difflib.DiffUtils;
+import com.github.difflib.patch.AbstractDelta;
+import com.github.difflib.patch.DeltaType;
+import com.github.difflib.patch.Patch;
+
+import org.eclipse.lsp4j.InlayHint;
+import org.eclipse.lsp4j.Position;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class InlayHintAdjusterDiffUtils {
+
+    public static List<InlayHint> adjustInlayHintsByLineDiff(String oldText, String newText, List<InlayHint> oldHints) {
+        List<String> oldLines = Arrays.asList(oldText.split("\n", -1));
+        List<String> newLines = Arrays.asList(newText.split("\n", -1));
+
+        Patch<String> patch = DiffUtils.diff(oldLines, newLines);
+        List<AbstractDelta<String>> deltas = patch.getDeltas();
+
+        List<InlayHint> adjusted = new ArrayList<>();
+        for (InlayHint hint : oldHints) {
+            int oldLine = hint.getPosition().getLine();
+            int lineShift = calculateLineShift(deltas, oldLine);
+            int newLine = Math.max(0, oldLine + lineShift);
+
+            adjusted.add(new InlayHint(new Position(newLine, hint.getPosition().getCharacter()), hint.getLabel()));
+        }
+
+        return adjusted;
+    }
+
+    private static int calculateLineShift(List<AbstractDelta<String>> deltas, int oldLine) {
+        int shift = 0;
+        for (AbstractDelta<String> delta : deltas) {
+            int deltaLine = delta.getSource().getPosition();
+            int linesRemoved = delta.getSource().size();
+            int linesAdded = delta.getTarget().size();
+
+            if (oldLine > deltaLine) {
+                if (delta.getType() == DeltaType.INSERT) {
+                    shift += linesAdded;
+                } else if (delta.getType() == DeltaType.DELETE) {
+                    shift -= linesRemoved;
+                } else if (delta.getType() == DeltaType.CHANGE) {
+                    shift += linesAdded - linesRemoved;
+                }
+            }
+        }
+        return shift;
+    }
+}

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

@@ -0,0 +1,79 @@
+package de.dhbw.handler;
+
+import com.google.common.base.Stopwatch;
+import de.dhbw.service.CacheService;
+import de.dhbw.service.ClientService;
+import de.dhbw.service.LogService;
+import de.dhbw.service.TextDocumentService;
+import de.dhbw.helper.ConversionHelper;
+import de.dhbw.helper.TypeResolver;
+import de.dhbw.model.LSPVariable;
+import org.eclipse.lsp4j.*;
+
+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;
+
+    public SaveHandler(TypeResolver typeResolver, TextDocumentService textDocumentService, LogService logService, CacheService cacheService, ConversionHelper conversionHelper, ClientService clientService){
+        this.typeResolver = typeResolver;
+        this.textDocumentService = textDocumentService;
+        this.logService = logService;
+        this.cacheService = cacheService;
+        this.conversionHelper = conversionHelper;
+        this.clientService = clientService;
+    }
+
+    public void handleSave(DidSaveTextDocumentParams didSaveTextDocumentParams){
+        ArrayList<Diagnostic> diagnostics = new ArrayList<>();
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+        try {
+
+            String fileInput = textDocumentService.getFileOfUri(didSaveTextDocumentParams.getTextDocument().getUri());
+            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(fileInput, didSaveTextDocumentParams.getTextDocument().getUri());
+            cacheService.setVariables(variables);
+
+
+            List<InlayHint> typeHint = new ArrayList<>();
+            for (var variable : variables) {
+
+                InlayHint inlayHint = conversionHelper.getInlayHint(variable);
+                typeHint.add(inlayHint);
+
+                for (var type : variable.getPossibleTypes()) {
+                    Diagnostic diagnostic = conversionHelper.getDiagnostic(variable, didSaveTextDocumentParams.getTextDocument().getUri(), type);
+                    diagnostics.add(diagnostic);
+                }
+
+            }
+
+            cacheService.updateGlobalMaps(diagnostics, typeHint, didSaveTextDocumentParams.getTextDocument().getUri());
+            clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), diagnostics);
+
+
+        } catch (Exception e) {
+            logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+            clientService.showMessage(MessageType.Error, 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/handler/UpdatePositionHandler.java

@@ -1,96 +0,0 @@
-package de.dhbw.handler;
-
-import de.dhbw.model.LSPVariable;
-import de.dhbwstuttgart.syntaxtree.SourceFile;
-import org.eclipse.lsp4j.Diagnostic;
-import org.eclipse.lsp4j.InlayHint;
-import org.eclipse.lsp4j.Position;
-import org.eclipse.lsp4j.Range;
-
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class UpdatePositionHandler {
-
-    public static List<InlayHint> adjustInlayHintPositions(List<InlayHint> oldHints, List<String> newTextLines) {
-        List<InlayHint> adjusted = new ArrayList<>();
-
-        for (InlayHint hint : oldHints) {
-            Position oldPos = hint.getPosition();
-            int oldLine = oldPos.getLine();
-            String variableName = extractVariableNameFromHint(hint); // z. B. durch .getLabel()
-
-            int searchStart = Math.max(0, oldLine - 3);
-            int searchEnd = Math.min(newTextLines.size(), oldLine + 3);
-
-            boolean found = false;
-
-            for (int i = searchStart; i < searchEnd; i++) {
-                String lineText = newTextLines.get(i);
-                int column = lineText.indexOf(variableName);
-                if (column >= 0) {
-                    Position newPos = new Position(i, column + variableName.length());
-                    InlayHint adjustedHint = new InlayHint(newPos, hint.getLabel());
-                    adjustedHint.setKind(hint.getKind());
-                    adjustedHint.setPaddingLeft(false);
-                    adjustedHint.setPaddingRight(true);
-                    adjusted.add(adjustedHint);
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found) {
-                adjusted.add(hint); // fallback: alte Position beibehalten
-            }
-        }
-
-        return adjusted;
-    }
-
-    private static String extractVariableNameFromHint(InlayHint hint) {
-        // Beispiel: wenn dein Hint-Label z. B. "String ↤" ist, brauchst du Logik, um den Namen zu bestimmen
-        // Wenn du nur Typen zeigst, kannst du Position - Name aus anderer Quelle kombinieren
-        // Temporär: nutze z. B. eine Custom-Property
-        return hint.getLabel().getLeft(); // Pseudocode, je nach Labelstruktur anpassen
-    }
-
-    public static List<Diagnostic> adjustDiagnosticPositions(List<Diagnostic> oldDiagnostics, List<String> newTextLines) {
-        List<Diagnostic> adjusted = new ArrayList<>();
-
-        for (Diagnostic diag : oldDiagnostics) {
-            String keyword = extractKeywordFromDiagnostic(diag); // z. B. "inferred type"
-
-            int oldLine = diag.getRange().getStart().getLine();
-            int searchStart = Math.max(0, oldLine - 3);
-            int searchEnd = Math.min(newTextLines.size(), oldLine + 3);
-
-            boolean found = false;
-            for (int i = searchStart; i < searchEnd; i++) {
-                String lineText = newTextLines.get(i);
-                int col = lineText.indexOf(keyword);
-                if (col >= 0) {
-                    Range newRange = new Range(new Position(i, col), new Position(i, col + keyword.length()));
-                    Diagnostic adjustedDiag = new Diagnostic(newRange, diag.getMessage(), diag.getSeverity(), diag.getCode().getLeft(), diag.getSource());
-                    adjusted.add(adjustedDiag);
-                    found = true;
-                    break;
-                }
-            }
-
-            if (!found) {
-                adjusted.add(diag); // fallback
-            }
-        }
-
-        return adjusted;
-    }
-
-    private static String extractKeywordFromDiagnostic(Diagnostic diag) {
-        // z. B. mit Regex oder fixer Konvention aus message
-        return "type"; // Beispiel
-    }
-
-}
-

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

@@ -0,0 +1,51 @@
+package de.dhbw.helper;
+
+import de.dhbw.service.TextDocumentService;
+import de.dhbw.model.LSPVariable;
+import de.dhbw.model.Type;
+import org.eclipse.lsp4j.*;
+
+public class ConversionHelper {
+
+    private final TextHelper textHelper;
+    private final TextDocumentService textDocumentService;
+
+    public ConversionHelper(TextHelper textHelper, TextDocumentService textDocumentService) {
+        this.textHelper = textHelper;
+        this.textDocumentService = textDocumentService;
+    }
+
+    public 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;
+    }
+
+    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
+                type.getType().replaceAll("GTV ", ""),
+                DiagnosticSeverity.Hint,
+                "JavaTX Language Server"
+        );
+        diagnostic.setCode(type.isGeneric() ? "GENERIC" : "TYPE");
+
+        return diagnostic;
+    }
+}

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

@@ -29,6 +29,7 @@ public class TextHelper {
 
         for (int i = startChar; i < linesInChar.length; i++) {
 
+
             if(linesInChar[i].contains("{")){
                 index = i;
                 found = true;
@@ -74,6 +75,7 @@ public class TextHelper {
             }
         }
 
+
         return index-1;
     }
 

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

@@ -33,8 +33,6 @@ public class TypeResolver {
 
     private static final Logger logger = LogManager.getLogger(TypeResolver.class);
 
-    private List<LSPVariable> currentTypes = new ArrayList<>();
-
     private final boolean ENABLE_GENERICS = false;
 
     private LanguageServerTransferObject current;
@@ -64,8 +62,19 @@ public class TypeResolver {
     public TypeResolver() {
     }
 
-    public void updatePositions(String path, String input){
-        LanguageServerTransferObject obj = new LanguageServerInterface().getResultSetAndAbstractSyntax(path, input);
+
+    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) {
@@ -216,6 +225,17 @@ public class TypeResolver {
 
         ArrayList<LSPVariable> methodsWithParametersLSPVariableList = new ArrayList<>();
 
+        for (var constructor : transferObj.getAst().KlassenVektor.getFirst().getConstructors()) {
+            for (var constructorParam : constructor.getParameterList().getFormalparalist()) {
+                var types = getAvailableTypes(transferObj.getResultSets(), constructorParam.getType());
+                methodsWithParametersLSPVariableList.add(new LSPParameter("", types, constructorParam.getOffset().getLine(), constructorParam.getOffset().getCharPositionInLine(), constructorParam.getOffset().getStopIndex(), constructorParam.getType()));
+            }
+        }
+
+        for (var fieldDecl : transferObj.getAst().KlassenVektor.getFirst().getFieldDecl()) {
+            var types = getAvailableTypes(transferObj.getResultSets(), fieldDecl.getReturnType());
+            methodsWithParametersLSPVariableList.add(new LSPParameter("", types, fieldDecl.getOffset().getLine(), fieldDecl.getOffset().getCharPositionInLine(), fieldDecl.getOffset().getStopIndex(), fieldDecl.getReturnType()));
+        }
 
         if (!transferObj.getResultSets().isEmpty()) {
             //TODO: Hier noch irgendwie die Klasse rausfinden oder durchgehen.
@@ -279,21 +299,10 @@ public class TypeResolver {
             }
         }
 
-        currentTypes.addAll(methodsWithParametersLSPVariableList);
         return methodsWithParametersLSPVariableList;
     }
 
 
-    public void updateTypehints(String input, String path) throws IOException, URISyntaxException, ClassNotFoundException {
-        LanguageServerTransferObject transferObj;
-        LanguageServerInterface languageServer = new LanguageServerInterface();
-        transferObj = languageServer.getResultSetAndAbstractSyntax(path, input);
-        var ast = transferObj.getAst();
-
-
-
-    }
-
     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()) {

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

@@ -0,0 +1,120 @@
+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 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 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<>();
+
+    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 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,48 @@
+package de.dhbw.service;
+
+import org.eclipse.lsp4j.Diagnostic;
+import org.eclipse.lsp4j.MessageParams;
+import org.eclipse.lsp4j.MessageType;
+import org.eclipse.lsp4j.PublishDiagnosticsParams;
+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();
+    }
+}

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/TextDocumentService.java

@@ -0,0 +1,22 @@
+package de.dhbw.service;
+
+import java.util.HashMap;
+
+public class TextDocumentService {
+
+    private final HashMap<String, String> files = new HashMap<>();
+
+    public TextDocumentService(){
+
+    }
+
+    public String getFileOfUri(String uri) {
+        return files.get(uri);
+    }
+
+    public void saveFileWithUri(String uri, String input) {
+        files.put(uri, input);
+    }
+
+
+}