Merge pull request #956 from usethesource/feature/dynamic-file-filters

Register file filters dynamically from parametric server

Author: toinehartman

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

@@ -45,9 +45,6 @@
 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.FileOperationsServerCapabilities;
 import org.eclipse.lsp4j.RenameFilesParams;
 import org.eclipse.lsp4j.ServerCapabilities;
 import org.eclipse.lsp4j.WorkspaceFolder;
@@ -72,13 +69,11 @@ public abstract class BaseWorkspaceService implements WorkspaceService, Language
 
     private final IBaseTextDocumentService documentService;
     private final CopyOnWriteArrayList<WorkspaceFolder> workspaceFolders = new CopyOnWriteArrayList<>();
-    private final List<FileOperationFilter> interestedInFiles;
 
 
-    protected BaseWorkspaceService(ExecutorService exec, IBaseTextDocumentService documentService, List<FileOperationFilter> interestedInFiles) {
+    protected BaseWorkspaceService(ExecutorService exec, IBaseTextDocumentService documentService) {
         this.documentService = documentService;
         this.exec = exec;
-        this.interestedInFiles = interestedInFiles;
     }
 
     public void initialize(ClientCapabilities clientCap, @Nullable List<WorkspaceFolder> currentWorkspaceFolders, ServerCapabilities capabilities) {
@@ -89,32 +84,17 @@ public void initialize(ClientCapabilities clientCap, @Nullable List<WorkspaceFol
 
         var clientWorkspaceCap = clientCap.getWorkspace();
 
-        WorkspaceServerCapabilities workspaceCapabilities = new WorkspaceServerCapabilities();
-        if (clientWorkspaceCap != null) {
-            if (clientWorkspaceCap.getWorkspaceFolders().booleanValue()) {
-                var folderOptions = new WorkspaceFoldersOptions();
-                folderOptions.setSupported(true);
-                folderOptions.setChangeNotifications(true);
-                workspaceCapabilities.setWorkspaceFolders(folderOptions);
-            }
-
-            var fileOperationCapabilities = new FileOperationsServerCapabilities();
-            var whichFiles = new FileOperationOptions(interestedInFiles);
-            boolean watchesSet = false;
-            if (clientWorkspaceCap.getFileOperations().getDidRename().booleanValue()) {
-                fileOperationCapabilities.setDidRename(whichFiles);
-                watchesSet = true;
-            }
-            if (clientWorkspaceCap.getFileOperations().getDidDelete().booleanValue()) {
-                fileOperationCapabilities.setDidDelete(whichFiles);
-                watchesSet = true;
-            }
-            if (watchesSet) {
-                workspaceCapabilities.setFileOperations(fileOperationCapabilities);
-            }
+        if (capabilities.getWorkspace() == null) {
+            capabilities.setWorkspace(new WorkspaceServerCapabilities());
         }
 
-        capabilities.setWorkspace(workspaceCapabilities);
+        var workspaceCapabilities = capabilities.getWorkspace();
+        if (clientWorkspaceCap != null && clientWorkspaceCap.getWorkspaceFolders().booleanValue()) {
+            var folderOptions = new WorkspaceFoldersOptions();
+            folderOptions.setSupported(true);
+            folderOptions.setChangeNotifications(true);
+            workspaceCapabilities.setWorkspaceFolders(folderOptions);
+        }
     }
 
     public List<WorkspaceFolder> workspaceFolders() {

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

@@ -31,6 +31,7 @@
 import java.time.Duration;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
@@ -140,6 +141,8 @@
 import org.rascalmpl.vscode.lsp.parametric.LanguageRegistry.LanguageParameter;
 import org.rascalmpl.vscode.lsp.parametric.capabilities.CapabilityRegistration;
 import org.rascalmpl.vscode.lsp.parametric.capabilities.CompletionCapability;
+import org.rascalmpl.vscode.lsp.parametric.capabilities.FileOperationCapability;
+import org.rascalmpl.vscode.lsp.parametric.capabilities.ICapabilityParams;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricFileFacts;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricSummary;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricSummary.SummaryLookup;
@@ -154,6 +157,7 @@
 import org.rascalmpl.vscode.lsp.rascal.conversion.SelectionRanges;
 import org.rascalmpl.vscode.lsp.rascal.conversion.SemanticTokenizer;
 import org.rascalmpl.vscode.lsp.uri.FallbackResolver;
+import org.rascalmpl.vscode.lsp.util.Maps;
 import org.rascalmpl.vscode.lsp.util.Versioned;
 import org.rascalmpl.vscode.lsp.util.concurrent.CompletableFutureUtils;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
@@ -258,7 +262,10 @@ private CapabilityRegistration availableCapabilities() {
     public void initializeServerCapabilities(ClientCapabilities clientCapabilities, final ServerCapabilities result) {
         // Since the initialize request is the very first request after connecting, we can initialize the capabilities here
         // https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#initialize
-        dynamicCapabilities = new CapabilityRegistration(availableClient(), exec, Set.of(new CompletionCapability()), clientCapabilities);
+        dynamicCapabilities = new CapabilityRegistration(availableClient(), exec, clientCapabilities
+            , new CompletionCapability()
+            , /* new FileOperationCapability.DidCreateFiles(exec), */ new FileOperationCapability.DidRenameFiles(exec), new FileOperationCapability.DidDeleteFiles(exec)
+        );
         dynamicCapabilities.registerStaticCapabilities(result);
 
         result.setDefinitionProvider(true);
@@ -994,18 +1001,18 @@ public synchronized void registerLanguage(LanguageParameter lang) {
         multiplexer.addContributor(buildContributionKey(lang),
             new InterpretedLanguageContributions(lang, this, availableWorkspaceService(), (IBaseLanguageClient)clientCopy, exec));
 
-        // `CapabilityRegistration::update` should never be called asynchronously, since that might re-order incoming updates.
-        // Since `registerLanguage` is called from a single-threaded pool, calling it here is safe.
-        // Note: `CapabilityRegistration::update` returns a void future, which we do not have to wait on.
-        availableCapabilities().update(Collections.unmodifiableCollection(contributions.values()));
-
         fact.reloadContributions();
         fact.setClient(clientCopy);
 
         for (var extension: lang.getExtensions()) {
             this.registeredExtensions.put(extension, lang.getName());
         }
 
+        // `CapabilityRegistration::update` should never be called asynchronously, since that might re-order incoming updates.
+        // Since `registerLanguage` is called from a single-threaded pool, calling it here is safe.
+        // Note: `CapabilityRegistration::update` returns a void future, which we do not have to wait on.
+        availableCapabilities().update(buildLanguageParams());
+
         // If we opened any files with this extension before, now associate them with contributions
         var extensions = Arrays.asList(lang.getExtensions());
         for (var f : files.keySet()) {
@@ -1015,6 +1022,25 @@ public synchronized void registerLanguage(LanguageParameter lang) {
         }
     }
 
+    /**
+     * Works iff `contributions` and `registeredExtensions` are in sync.
+     * As long as this in only called from synchronized {@link registerLanguage}/{@link unregisterLanguage}, this should work fine.
+     */
+    private Collection<ICapabilityParams> buildLanguageParams() {
+        var extensionsByLang = Maps.invert(registeredExtensions);
+        return contributions.entrySet().stream().map(e -> new ICapabilityParams() {
+            @Override
+            public ILanguageContributions contributions() {
+                return e.getValue();
+            }
+
+            @Override
+            public Set<String> fileExtensions() {
+                return extensionsByLang.getOrDefault(e.getKey(), Collections.emptySet());
+            }
+        }).collect(Collectors.toSet());
+    }
+
     private void updateFileState(LanguageParameter lang, ISourceLocation f) {
         f = f.top();
         logger.trace("File of language {} - updating state: {}", lang.getName(), f);
@@ -1062,7 +1088,7 @@ public synchronized void unregisterLanguage(LanguageParameter lang) {
             contributions.remove(lang.getName());
         }
 
-        availableCapabilities().update(Collections.unmodifiableCollection(contributions.values()));
+        availableCapabilities().update(buildLanguageParams());
     }
 
     @Override

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

@@ -26,15 +26,12 @@
  */
 package org.rascalmpl.vscode.lsp.parametric;
 
-import java.util.List;
 import java.util.concurrent.ExecutorService;
-import org.eclipse.lsp4j.FileOperationFilter;
-import org.eclipse.lsp4j.FileOperationPattern;
 import org.rascalmpl.vscode.lsp.BaseWorkspaceService;
 import org.rascalmpl.vscode.lsp.IBaseTextDocumentService;
 
 public class ParametricWorkspaceService extends BaseWorkspaceService {
     ParametricWorkspaceService(ExecutorService exec, IBaseTextDocumentService docService) {
-        super(exec, docService, List.of(new FileOperationFilter(new FileOperationPattern("**/*"))));
+        super(exec, docService);
     }
 }

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

@@ -91,14 +91,14 @@ protected final boolean preferStaticRegistration() {
      * @param contribs The {@link ILanguageContributions} that this capability reflects.
      * @return A future resolving to the options.
      */
-    protected abstract CompletableFuture<@Nullable O> options(ILanguageContributions contribs);
+    protected abstract CompletableFuture<@Nullable O> options(ICapabilityParams language);
 
     /**
      * Checks whether the given language contributions contain a contribution that provides this capability.
      * @param contribs The {@link ILanguageContributions} that this capability reflects.
      * @return A future resolving to `true` if there is such a contribution, or `false` otherwise.
      */
-    protected abstract CompletableFuture<Boolean> isProvidedBy(ILanguageContributions contribs);
+    protected abstract CompletableFuture<Boolean> isProvidedBy(ICapabilityParams language);
 
     /**
      * Merges two non-null option objects.

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

@@ -53,7 +53,6 @@
 import org.eclipse.lsp4j.UnregistrationParams;
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
 import org.eclipse.lsp4j.services.LanguageClient;
-import org.rascalmpl.vscode.lsp.parametric.ILanguageContributions;
 import org.rascalmpl.vscode.lsp.util.concurrent.CompletableFutureUtils;
 
 /**
@@ -71,7 +70,7 @@ public class CapabilityRegistration {
     private final Set<AbstractDynamicCapability<?>> dynamicCapabilities;
     private final Set<AbstractDynamicCapability<?>> staticCapabilities;
 
-    private final AtomicReference<Collection<ILanguageContributions>> lastContributions = new AtomicReference<>(Collections.emptyList());
+    private final AtomicReference<Collection<ICapabilityParams>> lastParams = new AtomicReference<>(Collections.emptyList());
     // Map of method names with current registration values
     private final Map<String, Registration> currentRegistrations = new ConcurrentHashMap<>();
 
@@ -80,7 +79,7 @@ public class CapabilityRegistration {
      * @param supportedCapabilities The capabilities to register with the client.
      * @param clientCapabilities The capabilities of the client. Determine whether dynamic registration is supported at all.
      */
-    public CapabilityRegistration(LanguageClient client, Executor exec, Set<AbstractDynamicCapability<?>> supportedCapabilities, ClientCapabilities clientCapabilities) {
+    public CapabilityRegistration(LanguageClient client, Executor exec, ClientCapabilities clientCapabilities, AbstractDynamicCapability<?>... supportedCapabilities) {
         this.client = client;
         this.exec = exec;
         this.noop = CompletableFutureUtils.completedFuture(null, exec);
@@ -113,11 +112,11 @@ public void registerStaticCapabilities(ServerCapabilities result) {
 
     /**
      * Update capabilities for language contributions.
-     * @param contribs The contributions to represent.
+     * @param languages The contributions to represent.
      * @return A future that completes with a boolean that is false when any registration failed, and true otherwise.
      */
-    public CompletableFuture<Void> update(Collection<ILanguageContributions> contribs) {
-        logger.debug("Updating {} dynamic capabilities from {} contributions", dynamicCapabilities.size(), contribs.size());
+    public CompletableFuture<Void> update(Collection<ICapabilityParams> languages) {
+        logger.debug("Updating {} dynamic capabilities for {} languages", dynamicCapabilities.size(), languages.size());
         // Copy the contributions so we know we are looking at a stable collection of elements.
 
         /*
@@ -126,7 +125,7 @@ public CompletableFuture<Void> update(Collection<ILanguageContributions> contrib
             Therefore, we need to set this reference before delegating any work to futures, where we lose guaranteed execution order.
             Additionally, this function should be called from a thread pool with predictable execution order.
         */
-        lastContributions.set(List.copyOf(contribs));
+        lastParams.set(List.copyOf(languages));
         return CompletableFutureUtils.reduce(dynamicCapabilities.stream().map(this::updateRegistration), exec)
             .thenAccept(_v -> logger.debug("Done updating dynamic capabilities"));
     }
@@ -157,16 +156,16 @@ public CompletableFuture<Void> update(Collection<ILanguageContributions> contrib
      * @return A future completing with `true` when successful, or `false` otherwise.
      */
     private <T> CompletableFuture<Void> updateRegistration(AbstractDynamicCapability<T> cap) {
-        var contribs = lastContributions.get();
+        var params = lastParams.get();
         var method = cap.methodName();
 
-        return tryBuildRegistration(cap, contribs).thenCompose(registration -> {
+        return tryBuildRegistration(cap, params).thenCompose(registration -> {
             // Synchronize on `currentRegistrations`, so we can reliable compute the required registration
             // and update the current registration without interference from other threads.
             synchronized (currentRegistrations) {
                 // If someone else modified the contributions in the meantime, we need to restart.
                 // Since we took a read-only copy of the contributions, instance comparison can be used everywhere
-                if (lastContributions.get() != contribs) {
+                if (lastParams.get() != params) {
                     return updateRegistration(cap);
                 }
 
@@ -204,7 +203,7 @@ private <T> CompletableFuture<Void> updateRegistration(AbstractDynamicCapability
                     }
 
                     // Ensure that the registration is eventually consistent.
-                    if (Objects.equals(currentRegistrations.get(method), registration) && lastContributions.get() == contribs) {
+                    if (Objects.equals(currentRegistrations.get(method), registration) && lastParams.get() == params) {
                         // Our update persisted and the contributions did not change in the meantime. Success!
                         return noop;
                     }
@@ -282,13 +281,13 @@ private <T> void handleError(@Nullable Throwable t, AbstractDynamicCapability<T>
         logger.error("Unexpected error while (un)registering capability {}", cap.methodName(), t);
     }
 
-    private <T> CompletableFuture<@Nullable Registration> tryBuildRegistration(AbstractDynamicCapability<T> cap, Collection<ILanguageContributions> contribs) {
-        if (contribs.isEmpty()) {
+    private <T> CompletableFuture<@Nullable Registration> tryBuildRegistration(AbstractDynamicCapability<T> cap, Collection<ICapabilityParams> languages) {
+        if (languages.isEmpty()) {
             return CompletableFutureUtils.completedFuture(null, exec);
         }
 
         // Filter contributions by providing this capability
-        return CompletableFutureUtils.filter(contribs, cap::isProvidedBy).<@Nullable Registration>thenCompose(cs -> {
+        return CompletableFutureUtils.filter(languages, cap::isProvidedBy).<@Nullable Registration>thenCompose(cs -> {
             if (cs.isEmpty()) {
                 return CompletableFutureUtils.completedFuture(null, exec);
             }

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

@@ -34,7 +34,6 @@
 import org.eclipse.lsp4j.CompletionOptions;
 import org.eclipse.lsp4j.CompletionRegistrationOptions;
 import org.eclipse.lsp4j.ServerCapabilities;
-import org.rascalmpl.vscode.lsp.parametric.ILanguageContributions;
 
 import io.usethesource.vallang.IString;
 
@@ -54,8 +53,8 @@ public CompletionCapability(boolean preferStaticRegistration) {
     }
 
     @Override
-    protected CompletableFuture<@Nullable CompletionRegistrationOptions> options(ILanguageContributions contribs) {
-        return contribs.completionTriggerCharacters()
+    protected CompletableFuture<@Nullable CompletionRegistrationOptions> options(ICapabilityParams params) {
+        return params.contributions().completionTriggerCharacters()
             .thenApply(triggers -> {
                 var trigList = triggers.stream()
                     .map(IString.class::cast)
@@ -66,8 +65,8 @@ public CompletionCapability(boolean preferStaticRegistration) {
     }
 
     @Override
-    protected CompletableFuture<Boolean> isProvidedBy(ILanguageContributions contribs) {
-        return contribs.hasCompletion();
+    protected CompletableFuture<Boolean> isProvidedBy(ICapabilityParams params) {
+        return params.contributions().hasCompletion();
     }
 
     @Override