Merge remote-tracking branch 'origin/migrate-dap' into feature/lsp-formatting

Author: toinehartman

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/BaseWorkspaceService.java

@@ -31,23 +31,37 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.ExecutorService;
+import java.util.stream.Collectors;
 
 import com.google.gson.JsonPrimitive;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.eclipse.lsp4j.ClientCapabilities;
+import org.eclipse.lsp4j.DeleteFilesParams;
 import org.eclipse.lsp4j.DidChangeConfigurationParams;
 import org.eclipse.lsp4j.DidChangeWatchedFilesParams;
 import org.eclipse.lsp4j.DidChangeWorkspaceFoldersParams;
 import org.eclipse.lsp4j.ExecuteCommandParams;
+import org.eclipse.lsp4j.FileDelete;
+import org.eclipse.lsp4j.FileOperationFilter;
+import org.eclipse.lsp4j.FileOperationOptions;
+import org.eclipse.lsp4j.FileOperationPattern;
+import org.eclipse.lsp4j.FileOperationsServerCapabilities;
+import org.eclipse.lsp4j.RenameFilesParams;
 import org.eclipse.lsp4j.ServerCapabilities;
 import org.eclipse.lsp4j.WorkspaceFolder;
 import org.eclipse.lsp4j.WorkspaceFoldersOptions;
 import org.eclipse.lsp4j.WorkspaceServerCapabilities;
 import org.eclipse.lsp4j.services.LanguageClient;
 import org.eclipse.lsp4j.services.LanguageClientAware;
 import org.eclipse.lsp4j.services.WorkspaceService;
+import org.rascalmpl.vscode.lsp.util.locations.Locations;
 
 public class BaseWorkspaceService implements WorkspaceService, LanguageClientAware {
+    private static final Logger logger = LogManager.getLogger(BaseWorkspaceService.class);
+
     public static final String RASCAL_LANGUAGE = "Rascal";
     public static final String RASCAL_META_COMMAND = "rascal-meta-command";
     public static final String RASCAL_COMMAND = "rascal-command";
@@ -57,10 +71,13 @@ public class BaseWorkspaceService implements WorkspaceService, LanguageClientAwa
     private final IBaseTextDocumentService documentService;
     private final CopyOnWriteArrayList<WorkspaceFolder> workspaceFolders = new CopyOnWriteArrayList<>();
 
+    private final List<FileOperationPattern> interestedInFiles;
+
 
-    protected BaseWorkspaceService(ExecutorService exec, IBaseTextDocumentService documentService) {
+    protected BaseWorkspaceService(ExecutorService exec, IBaseTextDocumentService documentService, List<FileOperationPattern> interestedInFiles) {
         this.documentService = documentService;
         this.ownExecuter = exec;
+        this.interestedInFiles = interestedInFiles;
     }
 
 
@@ -72,13 +89,35 @@ public void initialize(ClientCapabilities clientCap, @Nullable List<WorkspaceFol
 
         var clientWorkspaceCap = clientCap.getWorkspace();
 
-        if (clientWorkspaceCap != null && Boolean.TRUE.equals(clientWorkspaceCap.getWorkspaceFolders())) {
-            var workspaceCap = new WorkspaceFoldersOptions();
-            workspaceCap.setSupported(true);
-            workspaceCap.setChangeNotifications(true);
-            capabilities.setWorkspace(new WorkspaceServerCapabilities(workspaceCap));
+        WorkspaceServerCapabilities workspaceCapabilities = new WorkspaceServerCapabilities();
+        if (clientWorkspaceCap != null) {
+            if (clientWorkspaceCap.getWorkspaceFolders()) {
+                var folderOptions = new WorkspaceFoldersOptions();
+                folderOptions.setSupported(true);
+                folderOptions.setChangeNotifications(true);
+                workspaceCapabilities.setWorkspaceFolders(folderOptions);
+            }
+
+            var fileOperationCapabilities = new FileOperationsServerCapabilities();
+            var whichFiles = new FileOperationOptions(interestedInFiles.stream()
+                .map(FileOperationFilter::new)
+                .collect(Collectors.toList())
+            );
+            boolean watchesSet = false;
+            if (clientWorkspaceCap.getFileOperations().getDidRename()) {
+                fileOperationCapabilities.setDidRename(whichFiles);
+                watchesSet = true;
+            }
+            if (clientWorkspaceCap.getFileOperations().getDidDelete()) {
+                fileOperationCapabilities.setDidDelete(whichFiles);
+                watchesSet = true;
+            }
+            if (watchesSet) {
+                workspaceCapabilities.setFileOperations(fileOperationCapabilities);
+            }
         }
 
+        capabilities.setWorkspace(workspaceCapabilities);
     }
 
     public List<WorkspaceFolder> workspaceFolders() {
@@ -112,6 +151,33 @@ public void didChangeWorkspaceFolders(DidChangeWorkspaceFoldersParams params) {
         }
     }
 
+    @Override
+    public void didRenameFiles(RenameFilesParams params) {
+        logger.debug("workspace/didRenameFiles: {}", params.getFiles());
+
+        ownExecuter.submit(() -> {
+            documentService.didRenameFiles(params, workspaceFolders());
+        });
+
+        ownExecuter.submit(() -> {
+            // cleanup the old files (we do not get a `didDelete` event)
+            var oldFiles = params.getFiles().stream()
+                .map(f -> f.getOldUri())
+                .map(FileDelete::new)
+                .collect(Collectors.toList());
+            documentService.didDeleteFiles(new DeleteFilesParams(oldFiles));
+        });
+    }
+
+    @Override
+    public void didDeleteFiles(DeleteFilesParams params) {
+        logger.debug("workspace/didDeleteFiles: {}", params.getFiles());
+
+        ownExecuter.submit(() -> {
+            documentService.didDeleteFiles(params);
+        });
+    }
+
     @Override
     public CompletableFuture<Object> executeCommand(ExecuteCommandParams params) {
         if (params.getCommand().startsWith(RASCAL_META_COMMAND) || params.getCommand().startsWith(RASCAL_COMMAND)) {
@@ -120,7 +186,7 @@ public CompletableFuture<Object> executeCommand(ExecuteCommandParams params) {
             return documentService.executeCommand(languageName, command).thenApply(v -> v);
         }
 
-        return CompletableFuture.supplyAsync(() -> params.getCommand() + " was ignored.");
+        return CompletableFuture.supplyAsync(() -> params.getCommand() + " was ignored.", ownExecuter);
     }
 
 

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/IBaseTextDocumentService.java

@@ -27,11 +27,13 @@
 package org.rascalmpl.vscode.lsp;
 
 import java.time.Duration;
-import java.util.Set;
+import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
+import org.eclipse.lsp4j.DeleteFilesParams;
 import org.eclipse.lsp4j.RenameFilesParams;
 import org.eclipse.lsp4j.ServerCapabilities;
+import org.eclipse.lsp4j.WorkspaceFolder;
 import org.eclipse.lsp4j.services.LanguageClient;
 import org.eclipse.lsp4j.services.TextDocumentService;
 import org.rascalmpl.vscode.lsp.terminal.ITerminalIDEServer.LanguageParameter;
@@ -56,6 +58,7 @@ public interface IBaseTextDocumentService extends TextDocumentService {
 
     boolean isManagingFile(ISourceLocation file);
 
-    default void didRenameFiles(RenameFilesParams params, Set<ISourceLocation> workspaceFolders) {}
+    void didRenameFiles(RenameFilesParams params, List<WorkspaceFolder> workspaceFolders);
+    void didDeleteFiles(DeleteFilesParams params);
     void cancelProgress(String progressId);
 }

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/parametric/ILanguageContributions.java

@@ -39,6 +39,7 @@
 import io.usethesource.vallang.IList;
 import io.usethesource.vallang.ISet;
 import io.usethesource.vallang.ISourceLocation;
+import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 import io.usethesource.vallang.type.Type;
 import io.usethesource.vallang.type.TypeFactory;
@@ -62,19 +63,25 @@ public interface ILanguageContributions {
     public InterruptibleFuture<IList> selectionRange(IList focus);
     public InterruptibleFuture<IList> formatting(ITree input, ISourceLocation loc, IConstructor formattingOptions);
 
+    public InterruptibleFuture<ISourceLocation> prepareRename(IList focus);
+    public InterruptibleFuture<ITuple> rename(IList focus, String name);
+    public InterruptibleFuture<ITuple> didRenameFiles(IList fileRenames);
+
     public CompletableFuture<IList> parseCodeActions(String command);
 
     public CompletableFuture<Boolean> hasAnalysis();
     public CompletableFuture<Boolean> hasBuild();
     public CompletableFuture<Boolean> hasDocumentSymbol();
     public CompletableFuture<Boolean> hasCodeLens();
     public CompletableFuture<Boolean> hasInlayHint();
+    public CompletableFuture<Boolean> hasRename();
     public CompletableFuture<Boolean> hasExecution();
     public CompletableFuture<Boolean> hasHover();
     public CompletableFuture<Boolean> hasDefinition();
     public CompletableFuture<Boolean> hasReferences();
     public CompletableFuture<Boolean> hasImplementation();
     public CompletableFuture<Boolean> hasCodeAction();
+    public CompletableFuture<Boolean> hasDidRenameFiles();
     public CompletableFuture<Boolean> hasSelectionRange();
     public CompletableFuture<Boolean> hasFormatting();
 

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/parametric/InterpretedLanguageContributions.java

@@ -59,6 +59,7 @@
 import io.usethesource.vallang.IList;
 import io.usethesource.vallang.ISet;
 import io.usethesource.vallang.ISourceLocation;
+import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
 import io.usethesource.vallang.IValueFactory;
 import io.usethesource.vallang.exceptions.FactTypeUseException;
@@ -90,6 +91,9 @@ public class InterpretedLanguageContributions implements ILanguageContributions
     private final CompletableFuture<@Nullable IFunction> references;
     private final CompletableFuture<@Nullable IFunction> implementation;
     private final CompletableFuture<@Nullable IFunction> codeAction;
+    private final CompletableFuture<@Nullable IFunction> prepareRename;
+    private final CompletableFuture<@Nullable IFunction> rename;
+    private final CompletableFuture<@Nullable IFunction> didRenameFiles;
     private final CompletableFuture<@Nullable IFunction> selectionRange;
     private final CompletableFuture<@Nullable IFunction> formatting;
 
@@ -104,6 +108,8 @@ public class InterpretedLanguageContributions implements ILanguageContributions
     private final CompletableFuture<Boolean> hasReferences;
     private final CompletableFuture<Boolean> hasImplementation;
     private final CompletableFuture<Boolean> hasCodeAction;
+    private final CompletableFuture<Boolean> hasRename;
+    private final CompletableFuture<Boolean> hasDidRenameFiles;
     private final CompletableFuture<Boolean> hasSelectionRange;
     private final CompletableFuture<Boolean> hasFormatting;
 
@@ -148,6 +154,9 @@ public InterpretedLanguageContributions(LanguageParameter lang, IBaseTextDocumen
             this.references = getFunctionFor(contributions, LanguageContributions.REFERENCES);
             this.implementation = getFunctionFor(contributions, LanguageContributions.IMPLEMENTATION);
             this.codeAction = getFunctionFor(contributions, LanguageContributions.CODE_ACTION);
+            this.prepareRename = getKeywordParamFunctionFor(contributions, LanguageContributions.RENAME, LanguageContributions.PREPARE_RENAME_SERVICE);
+            this.rename = getFunctionFor(contributions, LanguageContributions.RENAME);
+            this.didRenameFiles = getFunctionFor(contributions, LanguageContributions.DID_RENAME_FILES);
             this.selectionRange = getFunctionFor(contributions, LanguageContributions.SELECTION_RANGE);
             this.formatting = getFunctionFor(contributions, LanguageContributions.FORMATTING);
 
@@ -163,6 +172,8 @@ public InterpretedLanguageContributions(LanguageParameter lang, IBaseTextDocumen
             this.hasReferences = nonNull(this.references);
             this.hasImplementation = nonNull(this.implementation);
             this.hasCodeAction = nonNull(this.codeAction);
+            this.hasRename = nonNull(this.rename);
+            this.hasDidRenameFiles = nonNull(this.didRenameFiles);
             this.hasSelectionRange = nonNull(this.selectionRange);
             this.hasFormatting = nonNull(this.formatting);
 
@@ -266,19 +277,29 @@ private CompletableFuture<IConstructor> parseCommand(String command) {
         });
     }
 
-    private static CompletableFuture<@Nullable IFunction> getFunctionFor(CompletableFuture<ISet> contributions, String cons) {
+    private static CompletableFuture<@Nullable IConstructor> getContribution(CompletableFuture<ISet> contributions, String cons) {
         return contributions.thenApply(conts -> {
             for (IValue elem : conts) {
                 IConstructor contrib = (IConstructor) elem;
                 if (cons.equals(contrib.getConstructorType().getName())) {
-                    return (IFunction) contrib.get(0);
+                    return contrib;
                 }
             }
             logger.debug("No {} defined", cons);
             return null;
         });
     }
 
+    private static CompletableFuture<@Nullable IFunction> getFunctionFor(CompletableFuture<ISet> contributions, String cons) {
+        return getContribution(contributions, cons).thenApply(contribution -> (IFunction) contribution.get(0));
+    }
+
+    private static CompletableFuture<@Nullable IFunction> getKeywordParamFunctionFor(CompletableFuture<ISet> contributions, String cons, String kwParam) {
+        return getContribution(contributions, cons).thenApply(contribution ->
+            (IFunction) contribution.asWithKeywordParameters().getParameter(kwParam)
+        );
+    }
+
     @Override
     public String getName() {
         return name;
@@ -320,6 +341,24 @@ public InterruptibleFuture<IList> inlayHint(@Nullable ITree input) {
         return execFunction(LanguageContributions.INLAY_HINT, inlayHint, VF.list(), input);
     }
 
+    @Override
+    public InterruptibleFuture<ISourceLocation> prepareRename(IList focus) {
+        debug(LanguageContributions.PREPARE_RENAME_SERVICE, focus.isEmpty() ? "" : focus.get(0));
+        return execFunction(LanguageContributions.PREPARE_RENAME_SERVICE, prepareRename, URIUtil.unknownLocation(), focus);
+    }
+
+    @Override
+    public InterruptibleFuture<ITuple> rename(IList focus, String newName) {
+        debug(LanguageContributions.RENAME_SERVICE, newName, focus.isEmpty() ? "" : focus.get(0));
+        return execFunction(LanguageContributions.RENAME_SERVICE, rename, VF.tuple(VF.list(), VF.list()), focus, VF.string(newName));
+    }
+
+    @Override
+    public InterruptibleFuture<ITuple> didRenameFiles(IList fileRenames) {
+        debug(LanguageContributions.DID_RENAME_FILES, fileRenames);
+        return execFunction(LanguageContributions.DID_RENAME_FILES, didRenameFiles, VF.tuple(VF.list(), VF.list()), fileRenames);
+    }
+
     @Override
     public InterruptibleFuture<ISet> hover(IList focus) {
         debug(LanguageContributions.HOVER, focus.length());
@@ -400,6 +439,16 @@ public CompletableFuture<Boolean> hasInlayHint() {
         return hasInlayHint;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasRename() {
+        return hasRename;
+    }
+
+    @Override
+    public CompletableFuture<Boolean> hasDidRenameFiles() {
+        return hasDidRenameFiles;
+    }
+
     @Override
     public CompletableFuture<Boolean> hasCodeLens() {
         return hasCodeLens;