Merge remote-tracking branch 'origin/main' into feature/132-lsp-call-hierarchy

Author: toinehartman

rascal-lsp/pom.xml

@@ -35,7 +35,7 @@
     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     <junit.version>4.13.2</junit.version>
     <maven-surefire-plugin.version>3.5.3</maven-surefire-plugin.version>
-    <log4j2.version>2.25.0</log4j2.version>
+    <log4j2.version>2.25.1</log4j2.version>
     <lsp4j.version>0.24.0</lsp4j.version>
     <sonar.organization>usethesource</sonar.organization>
     <sonar.host.url>https://sonarcloud.io</sonar.host.url>
@@ -331,7 +331,7 @@
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-enforcer-plugin</artifactId>
-        <version>3.5.0</version>
+        <version>3.6.1</version>
         <executions>
           <execution>
             <id>enforce-maven</id>

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

@@ -58,6 +58,7 @@ public interface ILanguageContributions {
     public InterruptibleFuture<ISet> references(IList focus);
     public InterruptibleFuture<ISet> implementation(IList focus);
     public InterruptibleFuture<IList> codeAction(IList focus);
+    public InterruptibleFuture<IList> selectionRange(IList focus);
 
     public CompletableFuture<IList> parseCodeActions(String command);
 
@@ -72,6 +73,7 @@ public interface ILanguageContributions {
     public CompletableFuture<Boolean> hasReferences();
     public CompletableFuture<Boolean> hasImplementation();
     public CompletableFuture<Boolean> hasCodeAction();
+    public CompletableFuture<Boolean> hasSelectionRange();
 
     public CompletableFuture<Boolean> specialCaseHighlighting();
 

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

@@ -88,6 +88,7 @@ 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> selectionRange;
 
     private final CompletableFuture<Boolean> hasAnalysis;
     private final CompletableFuture<Boolean> hasBuild;
@@ -100,6 +101,7 @@ public class InterpretedLanguageContributions implements ILanguageContributions
     private final CompletableFuture<Boolean> hasReferences;
     private final CompletableFuture<Boolean> hasImplementation;
     private final CompletableFuture<Boolean> hasCodeAction;
+    private final CompletableFuture<Boolean> hasSelectionRange;
 
     private final CompletableFuture<Boolean> specialCaseHighlighting;
 
@@ -142,6 +144,7 @@ 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.selectionRange = getFunctionFor(contributions, LanguageContributions.SELECTION_RANGE);
 
             // assign boolean properties once instead of wasting futures all the time
             this.hasAnalysis = nonNull(this.analysis);
@@ -155,6 +158,7 @@ public InterpretedLanguageContributions(LanguageParameter lang, IBaseTextDocumen
             this.hasReferences = nonNull(this.references);
             this.hasImplementation = nonNull(this.implementation);
             this.hasCodeAction = nonNull(this.codeAction);
+            this.hasSelectionRange = nonNull(this.selectionRange);
 
             this.specialCaseHighlighting = getContributionParameter(contributions,
                 LanguageContributions.PARSING,
@@ -340,6 +344,12 @@ public InterruptibleFuture<IList> codeAction(IList focus) {
         return execFunction(LanguageContributions.CODE_ACTION, codeAction, VF.list(), focus);
     }
 
+    @Override
+    public InterruptibleFuture<IList> selectionRange(IList focus) {
+        debug(LanguageContributions.SELECTION_RANGE, focus.length());
+        return execFunction(LanguageContributions.SELECTION_RANGE, selectionRange, VF.list(), focus);
+    }
+
     private void debug(String name, Object param) {
         logger.debug("{}({})", name, param);
     }
@@ -393,6 +403,11 @@ public CompletableFuture<Boolean> hasCodeAction() {
         return hasCodeAction;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasSelectionRange() {
+        return hasSelectionRange;
+    }
+
     @Override
     public CompletableFuture<Boolean> hasAnalysis() {
         return hasAnalysis;

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

@@ -64,6 +64,7 @@ private static final <T> CompletableFuture<T> failedInitialization() {
     private volatile CompletableFuture<ILanguageContributions> references = failedInitialization();
     private volatile CompletableFuture<ILanguageContributions> implementation = failedInitialization();
     private volatile CompletableFuture<ILanguageContributions> codeAction = failedInitialization();
+    private volatile CompletableFuture<ILanguageContributions> selectionRange = failedInitialization();
 
     private volatile CompletableFuture<Boolean> hasAnalysis = failedInitialization();
     private volatile CompletableFuture<Boolean> hasBuild = failedInitialization();
@@ -76,6 +77,7 @@ private static final <T> CompletableFuture<T> failedInitialization() {
     private volatile CompletableFuture<Boolean> hasReferences = failedInitialization();
     private volatile CompletableFuture<Boolean> hasImplementation = failedInitialization();
     private volatile CompletableFuture<Boolean> hasCodeAction = failedInitialization();
+    private volatile CompletableFuture<Boolean> hasSelectionRange = failedInitialization();
 
     private volatile CompletableFuture<Boolean> specialCaseHighlighting = failedInitialization();
 
@@ -149,6 +151,7 @@ private synchronized void calculateRouting() {
         references = findFirstOrDefault(ILanguageContributions::hasReferences);
         implementation = findFirstOrDefault(ILanguageContributions::hasImplementation);
         codeAction = findFirstOrDefault(ILanguageContributions::hasCodeAction);
+        selectionRange = findFirstOrDefault(ILanguageContributions::hasSelectionRange);
 
         hasAnalysis = anyTrue(ILanguageContributions::hasAnalysis);
         hasBuild = anyTrue(ILanguageContributions::hasBuild);
@@ -160,6 +163,8 @@ private synchronized void calculateRouting() {
         hasDefinition = anyTrue(ILanguageContributions::hasDefinition);
         hasReferences = anyTrue(ILanguageContributions::hasReferences);
         hasImplementation = anyTrue(ILanguageContributions::hasImplementation);
+        hasCodeAction = anyTrue(ILanguageContributions::hasCodeAction);
+        hasSelectionRange = anyTrue(ILanguageContributions::hasSelectionRange);
 
         // Always use the special-case highlighting status of *the first*
         // contribution (possibly using the default value in the Rascal ADT if
@@ -295,6 +300,16 @@ public InterruptibleFuture<IList> codeAction(IList focus) {
         return flatten(codeAction, c -> c.codeAction(focus));
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasSelectionRange() {
+        return hasSelectionRange;
+    }
+
+    @Override
+    public InterruptibleFuture<IList> selectionRange(IList focus) {
+        return flatten(selectionRange, c -> c.selectionRange(focus));
+    }
+
     @Override
     public CompletableFuture<Boolean> hasCodeAction() {
         return hasCodeAction;

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

@@ -79,6 +79,8 @@
 import org.eclipse.lsp4j.LocationLink;
 import org.eclipse.lsp4j.Position;
 import org.eclipse.lsp4j.ReferenceParams;
+import org.eclipse.lsp4j.SelectionRange;
+import org.eclipse.lsp4j.SelectionRangeParams;
 import org.eclipse.lsp4j.SemanticTokens;
 import org.eclipse.lsp4j.SemanticTokensDelta;
 import org.eclipse.lsp4j.SemanticTokensDeltaParams;
@@ -112,6 +114,7 @@
 import org.rascalmpl.vscode.lsp.util.Diagnostics;
 import org.rascalmpl.vscode.lsp.util.DocumentSymbols;
 import org.rascalmpl.vscode.lsp.util.FoldingRanges;
+import org.rascalmpl.vscode.lsp.util.SelectionRanges;
 import org.rascalmpl.vscode.lsp.util.SemanticTokenizer;
 import org.rascalmpl.vscode.lsp.util.Versioned;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
@@ -199,6 +202,7 @@ public void initializeServerCapabilities(ServerCapabilities result) {
         result.setCodeActionProvider(true);
         result.setCodeLensProvider(new CodeLensOptions(false));
         result.setExecuteCommandProvider(new ExecuteCommandOptions(Collections.singletonList(getRascalMetaCommandName())));
+        result.setSelectionRangeProvider(true);
 
         result.setFoldingRangeProvider(true);
         result.setInlayHintProvider(true);
@@ -476,7 +480,7 @@ public CompletableFuture<SemanticTokens> semanticTokensRange(SemanticTokensRange
     }
 
     @Override
-    public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>>documentSymbol(DocumentSymbolParams params) {
+    public CompletableFuture<List<Either<SymbolInformation, DocumentSymbol>>> documentSymbol(DocumentSymbolParams params) {
         logger.debug("Outline/documentSymbol: {}", params.getTextDocument());
 
         final TextDocumentState file = getFile(params.getTextDocument());
@@ -608,6 +612,29 @@ public CompletableFuture<List<CallHierarchyItem>> prepareCallHierarchy(CallHiera
         return IBaseTextDocumentService.super.prepareCallHierarchy(params);
     }
 
+    @Override
+    public CompletableFuture<List<SelectionRange>> selectionRange(SelectionRangeParams params) {
+        logger.debug("Selection range: {} at {}", params.getTextDocument(), params.getPositions());
+        final ILanguageContributions contrib = contributions(params.getTextDocument());
+        final TextDocumentState file = getFile(params.getTextDocument());
+
+        return recoverExceptions(file.getCurrentTreeAsync()
+                .thenApply(Versioned::get)
+                .thenCompose(t -> params.getPositions().stream()
+                    .map(p -> Locations.toRascalPosition(params.getTextDocument(), p, columns))
+                    .map(p -> TreeSearch.computeFocusList(t, p.getLine(), p.getCharacter()))
+                    .map(focus -> contrib.hasSelectionRange().thenCompose(hasDef -> hasDef.booleanValue()
+                        ? contrib.selectionRange(focus).get()
+                        : CompletableFuture.completedFuture(SelectionRanges.defaultImplementation(focus))))
+                    .map(rangeFut -> rangeFut.thenApply(range -> Collections.singletonList(SelectionRanges.toSelectionRange(range, columns)))) // produce singleton lists here to simplify reduction later
+                    .reduce((lf, rf) -> lf.thenCombine(rf, (l, r) -> {
+                        l.addAll(r);
+                        return l;
+                    }))
+                    .orElse(CompletableFuture.completedFuture(Collections.emptyList()))),
+            Collections::emptyList);
+    }
+
     @Override
     public synchronized void registerLanguage(LanguageParameter lang) {
         logger.info("registerLanguage({})", lang.getName());

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

@@ -176,6 +176,11 @@ public InterruptibleFuture<ISet> implementation(IList focus) {
         return InterruptibleFuture.completedFuture(VF.set());
     }
 
+    @Override
+    public InterruptibleFuture<IList> selectionRange(IList focus) {
+        return InterruptibleFuture.completedFuture(VF.list());
+    }
+
     @Override
     public CompletableFuture<Boolean> hasHover() {
         return CompletableFuture.completedFuture(false);
@@ -231,6 +236,11 @@ public CompletableFuture<Boolean> hasInlayHint() {
         return CompletableFuture.completedFuture(false);
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasSelectionRange() {
+        return CompletableFuture.completedFuture(false);
+    }
+
     @Override
     public CompletableFuture<Boolean> specialCaseHighlighting() {
         return specialCaseHighlighting;

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

@@ -46,6 +46,7 @@ private LanguageContributions () {}
         public static final String REFERENCES = "references";
         public static final String IMPLEMENTATION = "implementation";
         public static final String CODE_ACTION = "codeAction";
+        public static final String SELECTION_RANGE = "selectionRange";
 
         public static class Parameters {
             private Parameters() {}

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/DocumentSymbols.java

@@ -29,15 +29,19 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
+
 import org.eclipse.lsp4j.DocumentSymbol;
 import org.eclipse.lsp4j.Range;
 import org.eclipse.lsp4j.SymbolInformation;
 import org.eclipse.lsp4j.SymbolKind;
+import org.eclipse.lsp4j.SymbolTag;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.rascalmpl.vscode.lsp.util.locations.LineColumnOffsetMap;
 import org.rascalmpl.vscode.lsp.util.locations.Locations;
+
 import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IList;
+import io.usethesource.vallang.ISet;
 import io.usethesource.vallang.ISourceLocation;
 import io.usethesource.vallang.IString;
 import io.usethesource.vallang.IWithKeywordParameters;
@@ -87,7 +91,18 @@ public static DocumentSymbol toLSP(IConstructor symbol, final LineColumnOffsetMa
             ? Locations.toRange(((ISourceLocation) kwp.getParameter("selection")), om)
             : range;
         String detail = kwp.hasParameter("detail") ? ((IString) kwp.getParameter("detail")).getValue() : null;
+        List<SymbolTag> tags = kwp.hasParameter("tags") ?
+            ((ISet) kwp.getParameter("tags"))
+                .stream()
+                .map(IConstructor.class::cast)
+                .map(IConstructor::getName)
+                .map(DocumentSymbols::capitalize)
+                .map(SymbolTag::valueOf)
+                .collect(Collectors.toList())
+            : Collections.emptyList();
 
-        return new  DocumentSymbol(symbolName, kind, range, selection, detail, children);
+        var lspSymbol = new DocumentSymbol(symbolName, kind, range, selection, detail, children);
+        lspSymbol.setTags(tags); // since 3.16
+        return lspSymbol;
     }
 }

rascal-lsp/src/main/java/org/rascalmpl/vscode/lsp/util/SelectionRanges.java

@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2018-2025, NWO-I CWI and Swat.engineering
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+package org.rascalmpl.vscode.lsp.util;
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.eclipse.lsp4j.Range;
+import org.eclipse.lsp4j.SelectionRange;
+import org.rascalmpl.values.IRascalValueFactory;
+import org.rascalmpl.values.parsetrees.ITree;
+import org.rascalmpl.values.parsetrees.TreeAdapter;
+import org.rascalmpl.vscode.lsp.util.locations.ColumnMaps;
+import org.rascalmpl.vscode.lsp.util.locations.Locations;
+
+import io.usethesource.vallang.IList;
+import io.usethesource.vallang.ISourceLocation;
+
+public class SelectionRanges {
+    private SelectionRanges() { /* hide implicit constructor */ }
+
+    /**
+     * Folds a {@link IList} of {@link ISourceLocation}s into a single, nested {@link SelectionRange}.
+     * @param ranges The range hierarchy. Should be ordered child-before-parent, where any source location is contained by the next.
+     * @param columns The editor's column map.
+     * @return A range with optional parent ranges.
+     */
+    public static @Nullable SelectionRange toSelectionRange(IList ranges, ColumnMaps columns) {
+        return toSelectionRange(ranges.stream()
+            .map(ISourceLocation.class::cast)
+            .map(l -> Locations.toRange(l, columns))
+            .collect(Collectors.toList()));
+    }
+
+    /**
+     * Folds a {@link List} of {@link Range}s into a single, nested {@link SelectionRange}.
+     * @param ranges The range hierarchy. Should be ordered child-before-parent, where any range is contained by the next.
+     * @return A range with optional parent ranges
+     */
+    public static @Nullable SelectionRange toSelectionRange(List<Range> ranges) {
+        // assumes child-before-parent ordering
+        SelectionRange selectionRange = null;
+        for (var r : reverse(ranges)) {
+            selectionRange = new SelectionRange(r, selectionRange);
+        }
+        return selectionRange;
+    }
+
+    private static <T> Iterable<T> reverse(List<T> list) {
+        return () -> new Iterator<T>() {
+            int current = list.size() - 1;
+
+            @Override
+            public boolean hasNext() {
+                return current >= 0;
+            }
+
+            @Override
+            public T next() {
+                try {
+                    return list.get(current--);
+                } catch (IndexOutOfBoundsException e) {
+                    throw new NoSuchElementException();
+                }
+            }
+        };
+    }
+
+    public static IList defaultImplementation(IList focus) {
+        return focus.stream()
+            .filter(Objects::nonNull)
+            .filter(ITree.class::isInstance)
+            .map(ITree.class::cast)
+            .map(TreeAdapter::getLocation)
+            .distinct()
+            .collect(IRascalValueFactory.getInstance().listWriter());
+    }
+}