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.9",
+  "version": "0.0.5",
   "engines": {
     "vscode": "^1.94.0"
   },

Clients/VisualStudioCode/src/extension.ts

@@ -13,12 +13,12 @@ function createClient(context: vscode.ExtensionContext): LanguageClient {
   const serverOptions: ServerOptions = {
     run: {
       command: 'java',
-      args: ['-Xss10m', '-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"],
+      args: ['-Xss2m', '-jar', workspaceFolder + "/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar"],
     },
     debug: {
       command: 'java',
       args: [
-      '-Xss10m',
+      '-Xss2m',
       '-jar',
       workspaceFolder + '/JavaTXLanguageServer-1.0-SNAPSHOT-jar-with-dependencies.jar',
     ],
@@ -26,7 +26,7 @@ function createClient(context: vscode.ExtensionContext): LanguageClient {
   };
 
   const clientOptions: LanguageClientOptions = {
-    documentSelector: [{ scheme: 'file', pattern: '**/*.jav' }],
+    documentSelector: [{ scheme: 'file', language: 'java' }],
     synchronize: {
       fileEvents: vscode.workspace.createFileSystemWatcher('**/*.jav')
     },

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);
     }
@@ -155,7 +155,7 @@ public class JavaTXTextDocumentService implements org.eclipse.lsp4j.services.Tex
     public void didSave(DidSaveTextDocumentParams didSaveTextDocumentParams) {
         logService.log("[didSave] Client triggered didSave-Event.");
         clientService.startLoading("compile-task", "Inferring types...", client);
-        saveHandler.handleSave(didSaveTextDocumentParams);
+        saveHandler.asyncHandle(didSaveTextDocumentParams);
         clientService.stopLoading("compile-task", "Types successfully inferred", client);
         clientService.updateClient(client);
     }

LanguageServer/src/main/java/de/dhbw/handler/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) {
@@ -106,7 +103,7 @@ public class CodeActionHandler {
         Range rangeOfInsert = params.getRange();
 
         //All Diagnostics that are in range of the hover -> All Diagnostics of the selected Variable and thus all Types of the Variable
-        Map<String, List<PlaceholderVariable>> typeInsertsOverlapping = getOverlapping(typeResolver.getInserts(), rangeOfInsert.getStart().getLine() + 1, rangeOfInsert.getStart().getCharacter(), rangeOfInsert.getEnd().getCharacter());
+        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());
@@ -116,8 +113,6 @@ public class CodeActionHandler {
         for (var typeInsertList : typeInsertsOverlapping.values()) {
             for (var typeInsert : typeInsertList) {
                 try {
-                    logService.log("NEW TEXT OF FILE BEFORE INSERT IS:");
-                    logService.log(textDocumentService.getFileOfUri(documentUri));
                     String typeWithReplacedVariable = typeInsert.insert(textDocumentService.getFileOfUri(documentUri));
 
                     ArrayList<TextEdit> listOfChanges = new ArrayList<>();
@@ -132,7 +127,7 @@ public class CodeActionHandler {
                     WorkspaceEdit edit = new WorkspaceEdit();
                     edit.setChanges(changes);
 
-                    CodeAction action = new CodeAction("Insert " + conversionHelper.cleanType(typeInsert.getInsertString()));
+                    CodeAction action = new CodeAction("Insert " + typeInsert.getInsertString());
                     action.setKind(CodeActionKind.QuickFix);
                     action.setEdit(edit);
                     actions.add(Either.forRight(action));

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

@@ -1,16 +1,27 @@
 package de.dhbw.handler;
 
 import com.google.common.base.Stopwatch;
+import de.dhbw.helper.ResultListener;
 import de.dhbw.model.DiagnosticsAndTypehints;
 import de.dhbw.service.*;
 import de.dhbw.helper.ConversionHelper;
 import de.dhbw.helper.TypeResolver;
 import de.dhbw.model.LSPVariable;
+import de.dhbwstuttgart.core.JavaTXCompiler;
 import de.dhbwstuttgart.languageServerInterface.LanguageServerInterface;
 import de.dhbwstuttgart.languageServerInterface.model.ParserError;
+import de.dhbwstuttgart.syntaxtree.SourceFile;
+import de.dhbwstuttgart.target.generate.GenerateGenerics;
+import de.dhbwstuttgart.target.generate.GenericsResult;
+import de.dhbwstuttgart.typeinference.result.ResultSet;
+import org.apache.commons.io.output.NullOutputStream;
 import org.eclipse.lsp4j.*;
 
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
 import java.net.URI;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
@@ -93,4 +104,28 @@ public class SaveHandler {
             logService.log("[didSave] Finished Calculating in [" + sWatch.elapsed().toSeconds() + "s]", MessageType.Info);
         }
     }
+
+
+
+
+
+    public void asyncHandle(DidSaveTextDocumentParams didSaveTextDocumentParams) {
+        var sWatch = Stopwatch.createUnstarted();
+        sWatch.start();
+
+        try {
+            ResultListener resultListener = new ResultListener(typeResolver, didSaveTextDocumentParams, cacheService, conversionHelper, clientService);
+            resultListener.init(didSaveTextDocumentParams);
+
+        } catch (Exception e) {
+            logService.log("[didSave] Error trying to get Inlay-Hints and Diagnostics for Client: " + e.getMessage(), MessageType.Error);
+
+            for (StackTraceElement elem : e.getStackTrace()) {
+                logService.log(elem.toString());
+            }
+            clientService.showMessage(MessageType.Error, e.getMessage() == null ? "null" : e.getMessage());
+            cacheService.updateGlobalMaps(new ArrayList<>(), new ArrayList<>(), didSaveTextDocumentParams.getTextDocument().getUri());
+
+        }
+    }
 }

LanguageServer/src/main/java/de/dhbw/helper/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

@@ -143,20 +143,102 @@ public class TypeResolver {
     public ArrayList<LSPVariable> infereInput(String pathString, String input, boolean a) throws IOException, ClassNotFoundException, URISyntaxException {
         System.setOut(new PrintStream(OutputStream.nullOutputStream()));
 
-        LanguageServerInterface languageServerInterface = new LanguageServerInterface();
+        var uri = new URI(pathString);
-        LanguageServerTransferObject lsTransfer = languageServerInterface.getResultSetAndAbstractSyntax(pathString);
+        var path = Path.of(uri);
 
-        var parsedSource = lsTransfer.getAst();
+        logger.info("Path is for calculation: " + path.toString());
-        var tiResults =  lsTransfer.getResultSets();
+        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;
@@ -42,6 +38,11 @@ public class PlaceholderPoint {
     	return point.getStartIndex() + extraOffset; 
     }
     
+    /* PL 2018-06-19
+     * Zwei TypeInsertPoint's sind gleich, wenn ihre point's gleich sind 
+     * eingefuegt damit man TypeReplaceMarker vergleichen kann
+     * @see java.lang.Object#equals(java.lang.Object)
+     */
     public boolean equals(Object obj) {
     	return this == obj;
     	/*

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

@@ -12,8 +12,6 @@ public class PlaceholderVariable {
     Set<PlaceholderPoint> inserts;
     ResultPair<?, ?> resultPair;
 
-
-
     public PlaceholderVariable(PlaceholderPoint point, Set<PlaceholderPoint> additionalPoints, ResultPair<?, ?> resultPair) {
         this.point = point;
         inserts = additionalPoints;
@@ -40,9 +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;
     }

README.md

@@ -55,10 +55,6 @@ 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: