feat: [NOT WORKING] maybe slowly starts working

Clients/VisualStudioCode/README.md

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

Clients/VisualStudioCode/package.json

@@ -3,7 +3,7 @@
   "name": "java-tx-language-extension",
   "displayName": "Java-TX Language Extension",
   "description": "The Language Extension for Java-TX with Typehints and Syntax Checks",
-  "version": "0.0.19",
+  "version": "0.0.5",
   "engines": {
     "vscode": "^1.94.0"
   },
@@ -20,18 +20,6 @@
         "command": "tx.restartLanguageServer",
         "title": "TX: Restart Language Server"
       }
-    ],
-    "configuration": [
-      {
-        "title": "JavaTX Language Server Plugin",
-        "properties": {
-          "tx.compilerLocation": {
-            "type": "string",
-            "format": "file",
-            "description": "JavaTX Compiler Location"
-          }
-        }
-      }
     ]
   },
   "scripts": {
@@ -54,7 +42,6 @@
     "typescript": "^5.6.2"
   },
   "dependencies": {
-    "@vscode/vsce": "^3.6.1",
     "vscode-languageclient": "^9.0.1"
   }
 }

Clients/VisualStudioCode/src/extension.ts

@@ -1,71 +1,32 @@
-import path from 'path';
-import os from "os";
 import * as vscode from 'vscode';
 import {
-  Executable,
   LanguageClient,
   LanguageClientOptions,
   ServerOptions
 } from 'vscode-languageclient/node';
 
-let homeDirectory: string;
-let currentUser: string;
-
-function untildify(pathWithTilde: string) {
-	if (homeDirectory === undefined) {
-		homeDirectory = os.homedir();
-	}
-
-	// Handle regular ~ expansion (current user)
-	if (homeDirectory && /^~(?=$|\/|\\)/.test(pathWithTilde)) {
-		return pathWithTilde.replace(/^~/, homeDirectory);
-	}
-
-	// Handle ~username expansion (only for current user)
-	const userMatch = pathWithTilde.match(/^~([^/\\]+)(.*)/);
-	if (userMatch) {
-		if (currentUser === undefined) {
-			currentUser = os.userInfo().username;
-		}
-
-		if (currentUser) {
-			const username = userMatch[1];
-			const rest = userMatch[2];
-			if (username === currentUser) {
-				return homeDirectory + rest;
-			}
-		}
-	}
-
-	// Return unchanged if no expansion occurred
-	return pathWithTilde;
-}
-
 let client: LanguageClient | undefined;   // <— global, damit wir neu starten können
 
-function createClient(context: vscode.ExtensionContext): LanguageClient | null {
+function createClient(context: vscode.ExtensionContext): LanguageClient {
   const workspaceFolder = context.extensionPath;
-  const config = vscode.workspace.getConfiguration("tx");
-
-  let compiler = config.get<string>("compilerLocation");
-  if (!compiler || compiler.trim() === "") {
-    vscode.window.showErrorMessage("Bitte konfiguriere den Pfad des Java-TX Compilers in den Einstellungen!");
-    return null;
-  }
-  compiler = path.resolve(untildify(compiler));
-
-  const cmd: Executable = {
-    command: 'java',
-    args: ['-Xss10m', '-cp', `${compiler}${path.delimiter}${workspaceFolder}/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar`, "de.dhbw.JavaTXLanguageServerLauncher"],
-  };
 
   const serverOptions: ServerOptions = {
-    run: cmd,
-    debug: cmd
+    run: {
+      command: 'java',
+      args: ['-Xss2m', '-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"],
+    },
+    debug: {
+      command: 'java',
+      args: [
+      '-Xss2m',
+      '-jar',
+      workspaceFolder + '/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar',
+    ],
+    }
   };
 
   const clientOptions: LanguageClientOptions = {
-    documentSelector: [{ scheme: 'file', pattern: '**/*.jav' }],
+    documentSelector: [{ scheme: 'file', language: 'java' }],
     synchronize: {
       fileEvents: vscode.workspace.createFileSystemWatcher('**/*.jav')
     },
@@ -81,9 +42,7 @@ function createClient(context: vscode.ExtensionContext): LanguageClient | null {
 }
 
 export async function activate(context: vscode.ExtensionContext) {
-  const c = createClient(context);
-  if (!c) return;
-  client = c;
+  client = createClient(context);
 
   client.start()
     .then(() => console.log("Language Client erfolgreich gestartet"))
@@ -91,6 +50,12 @@ export async function activate(context: vscode.ExtensionContext) {
 
   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) {
@@ -103,9 +68,7 @@ export async function activate(context: vscode.ExtensionContext) {
     } catch (e) {
       console.error('Fehler beim Stoppen des Language Clients:', e);
     }
-    const c = createClient(context); // komplett neu erzeugen
-    if (!c) return;
-    client = c;
+    client = createClient(context); // komplett neu erzeugen
     try {
       await client.start();
       vscode.window.showInformationMessage('Java-TX Language Server neu gestartet.');

Clients/emacs/README.md

@@ -1,11 +0,0 @@
-## Install emacs plugin:
-
-Edit your .emacs file and add the following:
-
-```
-(use-package javatx-mode
-  :custom
-  (javatx-compiler-path "$PATH_TO_COMPILER$")
-  (javatx-lsp-server-path "$PATH_TO_LSP$")
-  :load-path "~/.emacs.d/lisp")
-```

Clients/emacs/javatx-mode.el

@@ -1,84 +0,0 @@
-;;; javatx-mode.el --- Major mode for .jav files -*- lexical-binding: t; -*-
-
-(defvar javatx-mode-hook nil
-  "Hook called when entering `javatx-mode`.")
-
-;; Define the mode
-(define-derived-mode javatx-mode java-mode "Javatx"
-  "Major mode for editing `.jav` files.")
-
-;; Automatically use javatx-mode for .jav files
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.jav\\'" . javatx-mode))
-
-(provide 'javatx-mode)
-;;; javatx-mode.el ends here
-
-;; Initialize package sources
-(require 'package)
-(setq package-archives
-      '(("melpa" . "https://melpa.org/packages/")
-        ("gnu" . "https://elpa.gnu.org/packages/")))
-(package-initialize)
-
-;; Refresh package contents if needed
-(unless package-archive-contents
-  (package-refresh-contents))
-
-;; Install use-package if not installed
-(unless (package-installed-p 'use-package)
-  (package-install 'use-package))
-
-(require 'use-package)
-(setq use-package-always-ensure t) ;; automatically install packages if missing
-
-(use-package lsp-mode
-  :hook (prog-mode . lsp)
-  :commands lsp
-  :config
-  (setq lsp-prefer-flymake nil)) ;; use flycheck instead of flymake
-
-(use-package lsp-ui
-  :commands lsp-ui-mode
-  :hook (lsp-mode . lsp-ui-mode)
-  :config
-  (setq lsp-ui-sideline-show-hover t
-        lsp-ui-sideline-show-code-actions t
-        lsp-ui-sideline-show-diagnostics t))
-
-(defcustom javatx-compiler-path nil
-  "Path to the JavaTX Compiler jar."
-  :type 'string
-  :group 'javatx)
-
-(defcustom javatx-lsp-server-path nil
-  "Path to the JavaTX Language Server jar."
-  :type 'string
-  :group 'javatx)
-
-;;register javatx-mode lsp
-(with-eval-after-load 'lsp-mode
-  (message "Compiler path: %s" javatx-compiler-path)
-  (message "Server path: %s" javatx-lsp-server-path)
-  (add-to-list 'lsp-language-id-configuration '(javatx-mode . "Java-TX"))
-  (lsp-register-client
-   (make-lsp-client
-    :new-connection (lsp-stdio-connection (lambda () `("java" "-cp" ,(format "%s:%s" (expand-file-name javatx-compiler-path) (expand-file-name javatx-lsp-server-path)) "de.dhbw.JavaTXLanguageServerLauncher")))
-    :major-modes '(javatx-mode)
-    :server-id 'javatx-lsp-proxy)))
-
-(add-hook 'javatx-mode-hook #'lsp) ;; start LSP automatically for .jav files
-
-;; Automatically enable inlay hints for javatx-mode
-(add-hook 'javatx-mode-hook
-          (lambda ()
-            ;; Replace 'lsp-inlay-hints-mode' with whatever inlay hints function you use
-            (when (fboundp 'lsp-inlay-hints-mode)
-              (lsp-inlay-hints-mode 1))))
-
-
-(setq lsp-log-io t)  ;; enable logging of LSP messages
-
-(with-eval-after-load 'lsp-mode
-  (define-key lsp-mode-map (kbd "C-c a") 'lsp-execute-code-action))
-

LanguageServer/pom.xml

@@ -14,17 +14,61 @@
             <version>4.11</version>
             <scope>test</scope>
         </dependency>
+        <!-- https://mvnrepository.com/artifact/org.antlr/antlr4 -->
+        <dependency>
+            <groupId>org.antlr</groupId>
+            <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>
             <version>1.2.17</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>2.20.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-core</artifactId>
+            <version>2.20.0</version>
+        </dependency>
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter</artifactId>
-            <version>5.14.0</version>
+            <version>5.10.0</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>commons-io</groupId>
+            <artifactId>commons-io</artifactId>
+            <version>2.6</version>
+        </dependency>
+        <dependency>
+            <groupId>io.github.classgraph</groupId>
+            <artifactId>classgraph</artifactId>
+            <version>4.8.172</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>33.2.0-jre</version>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.ow2.asm/asm -->
+        <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+            <version>9.5</version>
+        </dependency>
         <dependency>
             <groupId>org.eclipse.lsp4j</groupId>
             <artifactId>org.eclipse.lsp4j</artifactId>
@@ -34,7 +78,6 @@
             <groupId>de.dhbwstuttgart</groupId>
             <artifactId>JavaTXcompiler</artifactId>
             <version>0.1</version>
-            <scope>provided</scope>
         </dependency>
     </dependencies>
     <properties>

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

@@ -17,7 +17,6 @@ import java.util.concurrent.CompletableFuture;
  * */
 public class JavaTXLanguageServer implements LanguageServer {
     private static final Logger logger = LogManager.getLogger(JavaTXLanguageServer.class);
-    public static ClientCapabilities capabilities;
     private LanguageClient client;
 
     public void connect(LanguageClient client) {
@@ -49,7 +48,6 @@ public class JavaTXLanguageServer implements LanguageServer {
         if(params.getWorkspaceFolders() != null && !params.getWorkspaceFolders().isEmpty()) {
             textDocumentService.setFileRoot(params.getWorkspaceFolders());
         }
-        JavaTXLanguageServer.capabilities = params.getCapabilities();
 
         return CompletableFuture.supplyAsync(() -> new InitializeResult(capabilities));
     }

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

@@ -55,7 +55,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
         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.codeActionHandler = new CodeActionHandler(textHelper, textDocumentService, cacheService, typeResolver, logService);
         this.saveHandler = new SaveHandler(typeResolver, textDocumentService, logService, cacheService, conversionHelper, clientService, parserService);
         this.changeHandler = new ChangeHandler(textDocumentService, parserService, conversionHelper, clientService, typeResolver, cacheService, logService);
     }
@@ -113,7 +113,8 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
         if (!syntaxErrors.isEmpty()) {
             clientService.publishDiagnostics(params.getTextDocument().getUri(), syntaxErrors);
         }
-        clientService.updateClient();
+        client.refreshDiagnostics();
+        client.refreshInlayHints();
         textDocuments.put(params.getTextDocument().getUri(), params.getTextDocument().getText());
         textDocumentService.saveFileWithUri(params.getTextDocument().getUri(), params.getTextDocument().getText());
     }
@@ -153,10 +154,10 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     @Override
     public void didSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
         logService.log("[didSave] Client triggered didSave-Event.");
-        clientService.startLoading("compile-task", "Inferring types...");
-        saveHandler.handleSave(didSaveTextDocumentParams);
-        clientService.stopLoading("compile-task", "Types successfully inferred");
-        clientService.updateClient();
+        clientService.startLoading("compile-task", "Inferring types...", client);
+        saveHandler.asyncHandle(didSaveTextDocumentParams);
+        clientService.stopLoading("compile-task", "Types successfully inferred", client);
+        clientService.updateClient(client);
     }
 
     @Override
@@ -297,9 +298,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
 
         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);
 
-        var triggerKind = params.getContext().getTriggerKind();
-        if (triggerKind != null)
-            logService.log("Code-Action Context was: " + triggerKind.name(), MessageType.Info);
+        logService.log("Code-Action Context was: " + params.getContext().getTriggerKind().name(), MessageType.Info);
 
         return CompletableFuture.supplyAsync(() -> {
             return codeActionHandler.handleNewCodeAction(params);

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

@@ -13,8 +13,6 @@ import org.eclipse.lsp4j.*;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileWriter;
-import java.net.URI;
-import java.nio.file.Path;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
@@ -80,8 +78,6 @@ public class ChangeHandler {
 
         if (!syntaxErrors.isEmpty()) {
             clientService.publishDiagnostics(params.getTextDocument().getUri(), syntaxErrors);
-        }else {
-            clientService.updateClient();
         }
         logService.log("Found [" + syntaxErrors.size() + "] Syntax Errors in Document.");
 
@@ -97,7 +93,7 @@ public class ChangeHandler {
             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(" ", "")));
+                    logService.log(variableType.getType() + " <> "+ type.replaceAll(" ", "") + ": " + type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", "")));
                     shouldCalculate = shouldCalculate || type.replaceAll(" ", "").contains(variableType.getType().replaceAll(" ", ""));
                     if (shouldCalculate) {
                         break;
@@ -158,39 +154,35 @@ public class ChangeHandler {
 
                 try {
                     try {
-                        File tempDir2 = Path.of(new URI(params.getTextDocument().getUri())).getParent().toFile();
-                        File tempFile2 = File.createTempFile("jtx_temp", ".tmp", tempDir2);
+                        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();
 
-                        try {
-                            ArrayList<LSPVariable> variables = typeResolver.infereInput(tempFile2.toURI().toString(), input);
-                            cacheService.setVariables(variables);
+                        ArrayList<LSPVariable> variables = typeResolver.infereInput(tempFile2.toURI().toString(), input, false);
+                        cacheService.setVariables(variables);
 
-                            DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehintsWithInput(variables, input);
+                        DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehintsWithInput(variables, input);
 
-                            List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
-                            List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
+                        List<InlayHint> typeHint = diagnosticsAndTypehints.getInlayHints();
+                        List<Diagnostic> diagnostics = diagnosticsAndTypehints.getDiagnostics();
 
-                            cacheService.updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
+                        cacheService.updateGlobalMaps(diagnostics, typeHint, params.getTextDocument().getUri());
 
-                            List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
+                        List<Diagnostic> allDiagnostics = new ArrayList<>(diagnostics);
+                        allDiagnostics.addAll(parserService.getDiagnosticsOfErrors(input, params.getTextDocument().getUri()));
 
-                            clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
-                        } catch (Exception | VerifyError f) {
-                            logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + f.getMessage(), MessageType.Error);
+                        clientService.publishDiagnostics(params.getTextDocument().getUri(), allDiagnostics);
 
-                            for (StackTraceElement elem : f.getStackTrace()) {
-                                logService.log(elem.toString());
-                            }
-                            clientService.showMessage(MessageType.Error, f.getMessage() == null ? "null" : f.getMessage());
-                            cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), params.getTextDocument().getUri());
-                        }
                         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());
 

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

@@ -1,6 +1,5 @@
 package de.dhbw.handler;
 
-import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TextHelper;
 import de.dhbw.helper.TypeResolver;
 import de.dhbw.service.CacheService;
@@ -23,15 +22,13 @@ public class CodeActionHandler {
     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) {
+    public CodeActionHandler(TextHelper textHelper, TextDocumentService textDocumentService, CacheService cacheService, TypeResolver typeResolver, LogService logService) {
         this.textHelper = textHelper;
         this.textDocumentService = textDocumentService;
         this.cacheService = cacheService;
         this.typeResolver = typeResolver;
         this.logService = logService;
-        this.conversionHelper = conversionHelper;
     }
 
     public static Range wholeDocumentRange(String text) {
@@ -105,50 +102,41 @@ public class CodeActionHandler {
         String documentUri = params.getTextDocument().getUri();
         Range rangeOfInsert = params.getRange();
 
-        if (typeResolver.getInserts() != null) {
-            //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<>();
+        //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));
+        for (var typeInsertList : typeInsertsOverlapping.values()) {
+            for (var typeInsert : typeInsertList) {
+                try {
+                    String typeWithReplacedVariable = typeInsert.insert(textDocumentService.getFileOfUri(documentUri));
 
-                        ArrayList<TextEdit> listOfChanges = new ArrayList<>();
+                    ArrayList<TextEdit> listOfChanges = new ArrayList<>();
 
-                        listOfChanges.add(new TextEdit(wholeDocumentRange(textDocumentService.getFileOfUri(documentUri)), typeWithReplacedVariable));
+                    listOfChanges.add(new TextEdit(wholeDocumentRange(textDocumentService.getFileOfUri(documentUri)), typeWithReplacedVariable));
 
-                        var isTypeImported = false;
+                    var isTypeImported = false;
 
-                        Map<String, List<TextEdit>> changes = new HashMap<>();
-                        changes.put(documentUri, listOfChanges);
+                    Map<String, List<TextEdit>> changes = new HashMap<>();
+                    changes.put(documentUri, listOfChanges);
 
-                        WorkspaceEdit edit = new WorkspaceEdit();
-                        edit.setChanges(changes);
+                    WorkspaceEdit edit = new WorkspaceEdit();
+                    edit.setChanges(changes);
 
-                        CodeAction action = new CodeAction("Insert " + conversionHelper.cleanType(typeInsert.getInsertString()));
-                        action.setKind(CodeActionKind.QuickFix);
-                        action.setEdit(edit);
-
-                        if(!actions.stream().map(el -> el.getRight().getTitle()).toList().contains(action.getTitle())){
-                            actions.add(Either.forRight(action));
-                        }
-                    } catch (Exception e) {
-                        logService.log("Error creating Actions, returning empty List. The Error was: " + e.getMessage(), MessageType.Error);
-                    }
+                    CodeAction action = new CodeAction("Insert " + 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;
         }
-
-        return new ArrayList<>();
+        return actions;
     }
 
     public List<Either<Command, CodeAction>> handleCodeAction(CodeActionParams params) {

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

@@ -1,17 +1,27 @@
 package de.dhbw.handler;
 
 import com.google.common.base.Stopwatch;
-import com.google.common.base.Verify;
+import de.dhbw.helper.ResultListener;
 import de.dhbw.model.DiagnosticsAndTypehints;
 import de.dhbw.service.*;
 import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TypeResolver;
 import de.dhbw.model.LSPVariable;
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
 import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.target.generate.GenerateGenerics;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import org.apache.commons.io.output.NullOutputStream;
 import org.eclipse.lsp4j.*;
 
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
 import java.net.URI;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -52,20 +62,19 @@ public class SaveHandler {
             List<Diagnostic> syntaxErrors = parserService.getDiagnosticsOfErrors(fileInput, didSaveTextDocumentParams.getTextDocument().getUri());
             if (!syntaxErrors.isEmpty()) {
                 clientService.publishDiagnostics(didSaveTextDocumentParams.getTextDocument().getUri(), syntaxErrors);
-            }else {
-                clientService.updateClient();
             }
             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);
+                ArrayList<LSPVariable> variables = typeResolver.infereInput(didSaveTextDocumentParams.getTextDocument().getUri(), fileInput, false);
                 cacheService.setVariables(variables);
 
                 DiagnosticsAndTypehints diagnosticsAndTypehints = conversionHelper.variablesToDiagnosticsAndTypehints(variables, didSaveTextDocumentParams.getTextDocument().getUri());
@@ -81,15 +90,42 @@ public class SaveHandler {
 
             }
 
-        } catch (Exception | VerifyError e) {
+        } 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 {
+
+        } finally {
             sWatch.stop();
             logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
         }
     }
+
+
+
+
+
+    public void asyncHandle(DidSaveTextDocumentParams didSaveTextDocumentParams) {
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+        try {
+            ResultListener resultListener = new ResultListener(typeResolver, didSaveTextDocumentParams, cacheService, conversionHelper, clientService);
+            resultListener.init(didSaveTextDocumentParams);
+
+        } catch (Exception e) {
+            logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+
+            for (StackTraceElement elem : e.getStackTrace()) {
+                logService.log(elem.toString());
+            }
+            clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+            cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), didSaveTextDocumentParams.getTextDocument().getUri());
+
+        }
+    }
 }

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

@@ -20,16 +20,12 @@ public class ConversionHelper {
         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 ", ""));
+            typeDisplay += " | " + type.getType().replaceAll("GTV ", "");
         }
 
 
@@ -49,7 +45,7 @@ public class ConversionHelper {
         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 ", "")),
+                type.getType().replaceAll("GTV ", ""),
                 DiagnosticSeverity.Hint,
                 "JavaTX Language Server"
         );
@@ -66,7 +62,7 @@ public class ConversionHelper {
         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 ", "")),
+                type.getType().replaceAll("GTV ", ""),
                 DiagnosticSeverity.Hint,
                 "JavaTX Language Server"
         );
@@ -75,7 +71,7 @@ public class ConversionHelper {
         return diagnostic;
     }
 
-    public List<Diagnostic> parseErrorToDiagnostic(List<ParserError> parserErrors) {
+    public List<Diagnostic> parseErrorToDiagnostic(List<ParserError> parserErrors){
         return parserErrors.stream().map(el -> {
             Range errorRange = new Range(
                     new Position(el.getLine() - 1, el.getCharPositionInLine()),        // Startposition
@@ -90,7 +86,7 @@ public class ConversionHelper {
         }).toList();
     }
 
-    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehints(ArrayList<LSPVariable> typesOfMethodAndParameters, String uri) {
+    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehints(ArrayList<LSPVariable> typesOfMethodAndParameters, String uri){
         List<InlayHint> typeHint = new ArrayList<>();
         ArrayList<Diagnostic> diagnostics = new ArrayList<>();
 
@@ -107,8 +103,7 @@ public class ConversionHelper {
 
         return new DiagnosticsAndTypehints(diagnostics, typeHint);
     }
-
-    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehintsWithInput(ArrayList<LSPVariable> typesOfMethodAndParameters, String input) {
+    public DiagnosticsAndTypehints variablesToDiagnosticsAndTypehintsWithInput(ArrayList<LSPVariable> typesOfMethodAndParameters, String input){
         List<InlayHint> typeHint = new ArrayList<>();
         ArrayList<Diagnostic> diagnostics = new ArrayList<>();
 

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

@@ -19,7 +19,6 @@ public class PlaceholderPlacer extends AbstractASTWalker {
         this.genericsResult = genericsResult;
         pkgName = forSourceFile.getPkgName();
         forSourceFile.accept(this);
-        inserts.forEach(el -> el.reducePackage());
         return inserts;
     }
 

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

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

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

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

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

@@ -140,23 +140,105 @@ public class TypeResolver {
         return variables;
     }
 
-    public ArrayList<LSPVariable> infereInput(String pathString, String input) throws IOException, ClassNotFoundException, URISyntaxException {
+    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 uri = new URI(pathString);
+        var path = Path.of(uri);
 
-        var parsedSource = lsTransfer.getAst();
-        var tiResults =  lsTransfer.getResultSets();
+        logger.info("Path is for calculation: " + path.toString());
+        var file = path.toFile();
+        Files.createDirectories(path.getParent().resolve("out"));
+        JavaTXCompiler compiler = new JavaTXCompiler(List.of(file), List.of(path.getParent().toFile()), path.getParent().resolve("out").toFile());
+        var parsedSource = compiler.sourceFiles.get(file);
+        var tiResults = compiler.typeInference(file);
         Set<PlaceholderVariable> tips = new HashSet<>();
 
-        generatedGenerics = lsTransfer.getGeneratedGenerics().get(lsTransfer.getAst());
+//        for (var sf : compiler.sourceFiles.values()) {
+//            Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(sf, tiResults);
+//            logger.info("Path for Class-File is: " + path.getParent().resolve("out").toFile());
+//            Files.createDirectories(path.getParent().resolve("out"));
+//            compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
+//
+//        }
+
+        Map<JavaClassName, byte[]> bytecode = compiler.generateBytecode(parsedSource, tiResults);
+        logger.info("Path for Class-File is: " + path.getParent().resolve("out").toFile());
+        Files.createDirectories(path.getParent().resolve("out"));
+        compiler.writeClassFile(bytecode, path.getParent().resolve("out").toFile(), false);
+
+        generatedGenerics = compiler.getGeneratedGenerics().get(compiler.sourceFiles.get(file));
         for (int i = 0; i < tiResults.size(); i++) {
             ResultSet tiResult = tiResults.get(i);
-            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, lsTransfer.getGeneratedGenerics().get(lsTransfer.getAst()).get(i)));
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, compiler.getGeneratedGenerics().get(compiler.sourceFiles.get(file)).get(i)));
         }
         System.setOut(System.out);
-        this.current = lsTransfer;
+        this.current = new LanguageServerTransferObject(tiResults, parsedSource, "", compiler.getGeneratedGenerics());
+
+        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 ArrayList<LSPVariable> infereIncremental(List<ResultSet> newResultSet,  List<GenericsResult> generatedGenerics, SourceFile ast) throws IOException, ClassNotFoundException, URISyntaxException {
+        System.setOut(new PrintStream(OutputStream.nullOutputStream()));
+        logger.info("HMMMMMMMMMMMMM");
+        var parsedSource = ast;
+        var tiResults = newResultSet;
+        Set<PlaceholderVariable> tips = new HashSet<>();
+
+
+        for (int i = 0; i < tiResults.size(); i++) {
+            ResultSet tiResult = tiResults.get(i);
+            tips.addAll(ASTTransformationHelper.createTypeInsertPoints(parsedSource, tiResult, null));
+        }
+
+        logger.info("OKI DOKI ALLES ERSTELLT");
+        System.setOut(System.out);
 
         HashMap<String, List<PlaceholderVariable>> insertsOnLines = new HashMap<>();
 
@@ -239,4 +321,8 @@ public class TypeResolver {
         logger.info(ASTPrinter.print(current.getAst()));
     }
 
+    public void updateCurrent(List<ResultSet> resultSets){
+        current.getResultSets().addAll(resultSets);
+    }
+
 }

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

@@ -12,10 +12,6 @@ public class PlaceholderPoint {
     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;
@@ -41,12 +37,12 @@ public class PlaceholderPoint {
     public int getPositionInCode() {
     	return point.getStartIndex() + extraOffset; 
     }
-
-
-    public PlaceholderType getKind() {
-        return kind;
-    }
-
+    
+    /* PL 2018-06-19
+     * Zwei TypeInsertPoint's sind gleich, wenn ihre point's gleich sind 
+     * eingefuegt damit man TypeReplaceMarker vergleichen kann
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
     public boolean equals(Object obj) {
     	return this == obj;
     	/*

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

@@ -12,7 +12,6 @@ public class PlaceholderVariable {
     Set<PlaceholderPoint> inserts;
     ResultPair<?, ?> resultPair;
 
-
     public PlaceholderVariable(PlaceholderPoint point, Set<PlaceholderPoint> additionalPoints, ResultPair<?, ?> resultPair) {
         this.point = point;
         inserts = additionalPoints;
@@ -25,10 +24,7 @@ public class PlaceholderVariable {
 
         List<PlaceholderPoint> insertsSorted = new ArrayList<>();
         insertsSorted.add(point);
-
-        if (!point.getInsertString().contains("void")) {
-            insertsSorted.addAll(inserts);
-        }
+        insertsSorted.addAll(inserts);
         Collections.sort(insertsSorted, new PlaceholderPoint.TypeInsertPointPositionComparator().reversed());
 
         for (PlaceholderPoint insertPoint : insertsSorted) {
@@ -42,10 +38,6 @@ public class PlaceholderVariable {
         return point.getInsertString();
     }
 
-    public void reducePackage() {
-        point.setInsertString(point.getInsertString().replaceAll("java\\.lang\\.", "").replaceAll("java\\.util\\.", ""));
-    }
-
     public ResultPair<?, ?> getResultPair() {
         return this.resultPair;
     }

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

@@ -3,12 +3,8 @@ package de.dhbw.service;
 import org.eclipse.lsp4j.*;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.services.LanguageClient;
-import org.eclipse.lsp4j.services.LanguageServer;
-
-import de.dhbw.JavaTXLanguageServer;
 
 import java.util.List;
-import java.util.Map;
 
 public class ClientService {
 
@@ -43,18 +39,21 @@ public class ClientService {
         this.client = client;
     }
 
+    public void updateClient(LanguageClient client) {
+        client.refreshInlayHints();
+        client.refreshDiagnostics();
+    }
+
     public void updateClient() {
-        if (JavaTXLanguageServer.capabilities.getWorkspace().getInlayHint() != null)
-            client.refreshInlayHints();
-        if (JavaTXLanguageServer.capabilities.getWorkspace().getDiagnostics() != null)
-            client.refreshDiagnostics();
+        client.refreshInlayHints();
+        client.refreshDiagnostics();
     }
 
     public LanguageClient getClient() {
         return client;
     }
 
-    public void startLoading(String taskName, String title) {
+    public void startLoading(String taskName, String title, LanguageClient client) {
         Either<String, Integer> token = Either.forLeft(taskName);
         client.createProgress(new WorkDoneProgressCreateParams(token));
 
@@ -68,7 +67,7 @@ public class ClientService {
 
     }
 
-    public void stopLoading(String taskName, String title) {
+    public void stopLoading(String taskName, String title, LanguageClient client) {
         Either<String, Integer> token = Either.forLeft(taskName);
         WorkDoneProgressEnd end = new WorkDoneProgressEnd();
         end.setMessage(title);

README.md

@@ -55,16 +55,11 @@ 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:
 1. package the JavaTX Compiler
-2. create a lib Folder at ./LangaugeServer -> ./LanguageServer/lib
-2. take the Jar-File and copy it into the /lib Folder at 
+2. take the Jar-File and copy it into the /lib Folder
 3. execute this Maven command to add the Jar in your local Repository: ```mvn install:install-file   -Dfile=lib/JavaTXcompiler-0.1-jar-with-dependencies.jar   -DgroupId=de.dhbwstuttgart   -DartifactId=JavaTXcompiler   -Dversion=0.1   -Dpackaging=jar```
 4. run ```maven clean```, ```validate``` and ```install``` to load the new Dependency
 5. you can now package the Language Server or change the code accordingly.