Parametric LSP: call hierarchy API

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

@@ -29,9 +29,11 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.BiFunction;
 import java.util.function.Function;
+import org.apache.commons.lang3.tuple.Pair;
 import org.rascalmpl.values.IRascalValueFactory;
 import org.rascalmpl.values.parsetrees.ITree;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
+
 import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IList;
 import io.usethesource.vallang.ISet;
@@ -58,6 +60,8 @@ public interface ILanguageContributions {
     public InterruptibleFuture<ISet> implementation(IList focus);
     public InterruptibleFuture<IList> codeAction(IList focus);
     public InterruptibleFuture<IList> selectionRange(IList focus);
+    public InterruptibleFuture<Pair<IList, TypeStore>> prepareCallHierarchy(IList focus);
+    public InterruptibleFuture<Pair<IList, TypeStore>> incomingOutgoingCalls(Function<TypeStore, IConstructor> hierarchyItem, Function<TypeStore, IConstructor> direction);
 
     public InterruptibleFuture<ISourceLocation> prepareRename(IList focus);
     public InterruptibleFuture<ITuple> rename(IList focus, String name);
@@ -79,6 +83,7 @@ public interface ILanguageContributions {
     public CompletableFuture<Boolean> hasCodeAction();
     public CompletableFuture<Boolean> hasDidRenameFiles();
     public CompletableFuture<Boolean> hasSelectionRange();
+    public CompletableFuture<Boolean> hasCallHierarchy();
 
     public CompletableFuture<Boolean> specialCaseHighlighting();
 

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

@@ -31,10 +31,12 @@
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
+import java.util.function.Function;
+import org.apache.commons.lang3.tuple.Pair;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.rascalmpl.interpreter.Evaluator;
 import org.rascalmpl.interpreter.env.ModuleEnvironment;
 import org.rascalmpl.library.util.PathConfig;
@@ -53,6 +55,7 @@
 import org.rascalmpl.vscode.lsp.util.EvaluatorUtil;
 import org.rascalmpl.vscode.lsp.util.EvaluatorUtil.LSPContext;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
+
 import io.usethesource.vallang.IBool;
 import io.usethesource.vallang.IConstructor;
 import io.usethesource.vallang.IList;
@@ -94,6 +97,8 @@ public class InterpretedLanguageContributions implements ILanguageContributions
     private final CompletableFuture<@Nullable IFunction> rename;
     private final CompletableFuture<@Nullable IFunction> didRenameFiles;
     private final CompletableFuture<@Nullable IFunction> selectionRange;
+    private final CompletableFuture<@Nullable IFunction> prepareCallHierarchy;
+    private final CompletableFuture<@Nullable IFunction> callHierarchyService;
 
     private final CompletableFuture<Boolean> hasAnalysis;
     private final CompletableFuture<Boolean> hasBuild;
@@ -109,6 +114,7 @@ public class InterpretedLanguageContributions implements ILanguageContributions
     private final CompletableFuture<Boolean> hasRename;
     private final CompletableFuture<Boolean> hasDidRenameFiles;
     private final CompletableFuture<Boolean> hasSelectionRange;
+    private final CompletableFuture<Boolean> hasCallHierarchy;
 
     private final CompletableFuture<Boolean> specialCaseHighlighting;
 
@@ -155,6 +161,8 @@ public InterpretedLanguageContributions(LanguageParameter lang, IBaseTextDocumen
             this.rename = getFunctionFor(contributions, LanguageContributions.RENAME);
             this.didRenameFiles = getFunctionFor(contributions, LanguageContributions.DID_RENAME_FILES);
             this.selectionRange = getFunctionFor(contributions, LanguageContributions.SELECTION_RANGE);
+            this.prepareCallHierarchy = getFunctionFor(contributions, LanguageContributions.CALL_HIERARCHY, 0);
+            this.callHierarchyService = getFunctionFor(contributions, LanguageContributions.CALL_HIERARCHY, 1);
 
             // assign boolean properties once instead of wasting futures all the time
             this.hasAnalysis = nonNull(this.analysis);
@@ -171,6 +179,7 @@ public InterpretedLanguageContributions(LanguageParameter lang, IBaseTextDocumen
             this.hasRename = nonNull(this.rename);
             this.hasDidRenameFiles = nonNull(this.didRenameFiles);
             this.hasSelectionRange = nonNull(this.selectionRange);
+            this.hasCallHierarchy = nonNull(this.prepareCallHierarchy);
 
             this.specialCaseHighlighting = getContributionParameter(contributions,
                 LanguageContributions.PARSING,
@@ -301,7 +310,11 @@ private static CompletableFuture<IFunction> requireFunction(CompletableFuture<IS
     }
 
     private static CompletableFuture<@Nullable IFunction> getFunctionFor(CompletableFuture<ISet> contributions, String cons) {
-        return getContribution(contributions, cons).thenApply(contribution -> contribution != null ? (IFunction) contribution.get(0) : null);
+        return getFunctionFor(contributions, cons, 0);
+    }
+
+    private static CompletableFuture<@Nullable IFunction> getFunctionFor(CompletableFuture<ISet> contributions, String cons, int argumentPos) {
+        return getContribution(contributions, cons).thenApply(contribution -> contribution != null ? (IFunction) contribution.get(argumentPos) : null);
     }
 
     private static CompletableFuture<@Nullable IFunction> getKeywordParamFunctionFor(CompletableFuture<ISet> contributions, String cons, String kwParam) {
@@ -405,6 +418,26 @@ public InterruptibleFuture<IList> selectionRange(IList focus) {
         return execFunction(LanguageContributions.SELECTION_RANGE, selectionRange, VF.list(), focus);
     }
 
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> prepareCallHierarchy(IList focus) {
+        debug(LanguageContributions.CALL_HIERARCHY, "prepare", focus.length());
+        return withStore(execFunction(LanguageContributions.CALL_HIERARCHY, prepareCallHierarchy, VF.list(), focus));
+    }
+
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> incomingOutgoingCalls(Function<TypeStore, IConstructor> computeHierarchyItem, Function<TypeStore, IConstructor> computeDirection) {
+        return withStore(InterruptibleFuture.flatten(store.thenApply(store -> {
+            var hierarchyItem = computeHierarchyItem.apply(store);
+            var direction = computeDirection.apply(store);
+            debug(LanguageContributions.CALL_HIERARCHY, hierarchyItem.has("name") ? hierarchyItem.get("name") : "?", direction.getName());
+            return execFunction(LanguageContributions.CALL_HIERARCHY, callHierarchyService, VF.list(), hierarchyItem, direction);
+        }), exec));
+    }
+
+    private <V> InterruptibleFuture<Pair<V, TypeStore>> withStore(InterruptibleFuture<V> contrib) {
+        return contrib.thenCombineAsync(store, Pair::of, exec);
+    }
+
     private void debug(String name, Object param) {
         logger.debug("{}({})", name, param);
     }
@@ -473,6 +506,11 @@ public CompletableFuture<Boolean> hasSelectionRange() {
         return hasSelectionRange;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasCallHierarchy() {
+        return hasCallHierarchy;
+    }
+
     @Override
     public CompletableFuture<Boolean> hasAnalysis() {
         return hasAnalysis;

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

@@ -31,16 +31,19 @@
 import java.util.concurrent.ExecutorService;
 import java.util.function.BinaryOperator;
 import java.util.function.Function;
+import org.apache.commons.lang3.tuple.Pair;
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.rascalmpl.values.parsetrees.ITree;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
+
 import io.usethesource.vallang.IConstructor;
 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.TypeStore;
 
 @SuppressWarnings("java:S3077") // Fields in this class are read/written sequentially
 public class LanguageContributionsMultiplexer implements ILanguageContributions {
@@ -69,6 +72,8 @@ private static final <T> CompletableFuture<T> failedInitialization() {
     private volatile CompletableFuture<ILanguageContributions> rename = failedInitialization();
     private volatile CompletableFuture<ILanguageContributions> didRenameFiles = failedInitialization();
     private volatile CompletableFuture<ILanguageContributions> selectionRange = failedInitialization();
+    private volatile CompletableFuture<ILanguageContributions> prepareCallHierarchy = failedInitialization();
+    private volatile CompletableFuture<ILanguageContributions> incomingOutgoingCalls = failedInitialization();
 
     private volatile CompletableFuture<Boolean> hasAnalysis = failedInitialization();
     private volatile CompletableFuture<Boolean> hasBuild = failedInitialization();
@@ -84,6 +89,7 @@ private static final <T> CompletableFuture<T> failedInitialization() {
     private volatile CompletableFuture<Boolean> hasRename = failedInitialization();
     private volatile CompletableFuture<Boolean> hasDidRenameFiles = failedInitialization();
     private volatile CompletableFuture<Boolean> hasSelectionRange = failedInitialization();
+    private volatile CompletableFuture<Boolean> hasCallHierarchy = failedInitialization();
 
     private volatile CompletableFuture<Boolean> specialCaseHighlighting = failedInitialization();
 
@@ -161,6 +167,8 @@ private synchronized void calculateRouting() {
         prepareRename = findFirstOrDefault(ILanguageContributions::hasRename);
         didRenameFiles = findFirstOrDefault(ILanguageContributions::hasDidRenameFiles);
         selectionRange = findFirstOrDefault(ILanguageContributions::hasSelectionRange);
+        prepareCallHierarchy = findFirstOrDefault(ILanguageContributions::hasCallHierarchy);
+        incomingOutgoingCalls = findFirstOrDefault(ILanguageContributions::hasCallHierarchy);
 
         hasAnalysis = anyTrue(ILanguageContributions::hasAnalysis);
         hasBuild = anyTrue(ILanguageContributions::hasBuild);
@@ -172,10 +180,11 @@ private synchronized void calculateRouting() {
         hasDefinition = anyTrue(ILanguageContributions::hasDefinition);
         hasReferences = anyTrue(ILanguageContributions::hasReferences);
         hasImplementation = anyTrue(ILanguageContributions::hasImplementation);
+        hasCodeAction = anyTrue(ILanguageContributions::hasCodeAction);
         hasRename = anyTrue(ILanguageContributions::hasRename);
         hasDidRenameFiles = anyTrue(ILanguageContributions::hasDidRenameFiles);
-        hasCodeAction = anyTrue(ILanguageContributions::hasCodeAction);
         hasSelectionRange = anyTrue(ILanguageContributions::hasSelectionRange);
+        hasCallHierarchy = anyTrue(ILanguageContributions::hasCallHierarchy);
 
         // Always use the special-case highlighting status of *the first*
         // contribution (possibly using the default value in the Rascal ADT if
@@ -336,6 +345,16 @@ public InterruptibleFuture<IList> selectionRange(IList focus) {
         return flatten(selectionRange, c -> c.selectionRange(focus));
     }
 
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> prepareCallHierarchy(IList focus) {
+        return flatten(prepareCallHierarchy, c -> c.prepareCallHierarchy(focus));
+    }
+
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> incomingOutgoingCalls(Function<TypeStore, IConstructor> hierarchyItem, Function<TypeStore, IConstructor> direction) {
+        return flatten(incomingOutgoingCalls, c -> c.incomingOutgoingCalls(hierarchyItem, direction));
+    }
+
     @Override
     public CompletableFuture<Boolean> hasCodeAction() {
         return hasCodeAction;
@@ -401,6 +420,11 @@ public CompletableFuture<Boolean> hasDidRenameFiles() {
         return hasDidRenameFiles;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasCallHierarchy() {
+        return hasCallHierarchy;
+    }
+
     @Override
     public CompletableFuture<Boolean> specialCaseHighlighting() {
         return specialCaseHighlighting;
@@ -425,4 +449,5 @@ public CompletableFuture<SummaryConfig> getOndemandSummaryConfig() {
     public void cancelProgress(String progressId) {
         contributions.forEach(klc -> klc.contrib.cancelProgress(progressId));
     }
+
 }

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

@@ -32,11 +32,13 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
@@ -48,6 +50,12 @@
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.eclipse.lsp4j.ApplyWorkspaceEditParams;
+import org.eclipse.lsp4j.CallHierarchyIncomingCall;
+import org.eclipse.lsp4j.CallHierarchyIncomingCallsParams;
+import org.eclipse.lsp4j.CallHierarchyItem;
+import org.eclipse.lsp4j.CallHierarchyOutgoingCall;
+import org.eclipse.lsp4j.CallHierarchyOutgoingCallsParams;
+import org.eclipse.lsp4j.CallHierarchyPrepareParams;
 import org.eclipse.lsp4j.CodeAction;
 import org.eclipse.lsp4j.CodeActionParams;
 import org.eclipse.lsp4j.CodeLens;
@@ -123,11 +131,13 @@
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricSummary.SummaryLookup;
 import org.rascalmpl.vscode.lsp.terminal.ITerminalIDEServer.LanguageParameter;
 import org.rascalmpl.vscode.lsp.uri.FallbackResolver;
+import org.rascalmpl.vscode.lsp.util.CallHierarchy;
 import org.rascalmpl.vscode.lsp.util.CodeActions;
 import org.rascalmpl.vscode.lsp.util.Diagnostics;
 import org.rascalmpl.vscode.lsp.util.DocumentChanges;
 import org.rascalmpl.vscode.lsp.util.DocumentSymbols;
 import org.rascalmpl.vscode.lsp.util.FoldingRanges;
+import org.rascalmpl.vscode.lsp.util.Lists;
 import org.rascalmpl.vscode.lsp.util.SelectionRanges;
 import org.rascalmpl.vscode.lsp.util.SemanticTokenizer;
 import org.rascalmpl.vscode.lsp.util.Versioned;
@@ -239,6 +249,7 @@ public void initializeServerCapabilities(ServerCapabilities result) {
         result.setInlayHintProvider(true);
         result.setSelectionRangeProvider(true);
         result.setFoldingRangeProvider(true);
+        result.setCallHierarchyProvider(true);
     }
 
     private String getRascalMetaCommandName() {
@@ -828,6 +839,66 @@ public CompletableFuture<List<SelectionRange>> selectionRange(SelectionRangePara
             Collections::emptyList);
     }
 
+    @Override
+    public CompletableFuture<List<CallHierarchyItem>> prepareCallHierarchy(CallHierarchyPrepareParams params) {
+        final var loc = Locations.toLoc(params.getTextDocument());
+        final var contrib = contributions(loc);
+        final var file = getFile(loc);
+
+        return recoverExceptions(file.getCurrentTreeAsync(true)
+            .thenApply(Versioned::get)
+            .thenCompose(t -> {
+                final var pos = Locations.toRascalPosition(loc, params.getPosition(), columns);
+                final var focus = TreeSearch.computeFocusList(t, pos.getLine(), pos.getCharacter());
+                return contrib.prepareCallHierarchy(focus)
+                    .get()
+                    .thenApply(p -> {
+                        var items = p.getLeft();
+                        var store = p.getRight();
+                        var ch = new CallHierarchy(store);
+                        return items.stream()
+                            .map(IConstructor.class::cast)
+                            .map(ci -> ch.toLSP(ci, columns))
+                            .collect(Collectors.toList());
+                    });
+            }), Collections::emptyList);
+    }
+
+    private <T> CompletableFuture<List<T>> incomingOutgoingCalls(BiFunction<CallHierarchyItem, List<Range>, T> constructor, CallHierarchyItem source, CallHierarchy.Direction direction) {
+        final var contrib = contributions(Locations.toLoc(source.getUri()));
+        return contrib.incomingOutgoingCalls(
+                    store -> CallHierarchy.toRascal(store, source, columns),
+                    store -> CallHierarchy.direction(store, direction)
+                ).get()
+                .thenApply(res -> {
+                    var callRel = res.getLeft();
+                    var store = res.getRight();
+                    var ch = new CallHierarchy(store);
+                    return callRel.stream()
+                        .map(ITuple.class::cast)
+                        .collect(Collectors.toMap(
+                            t -> ch.toLSP((IConstructor) t.get(0), columns),
+                            t -> List.of(Locations.toRange((ISourceLocation) t.get(1), columns)),
+                            Lists::union,
+                            LinkedHashMap::new
+                        ));
+                })
+                .thenApply(map -> map.entrySet().stream()
+                    .map(e -> constructor.apply(e.getKey(), e.getValue()))
+                    .collect(Collectors.toList()));
+    }
+
+    @Override
+    public CompletableFuture<List<CallHierarchyIncomingCall>> callHierarchyIncomingCalls(CallHierarchyIncomingCallsParams params) {
+        return recoverExceptions(incomingOutgoingCalls(CallHierarchyIncomingCall::new, params.getItem(), CallHierarchy.Direction.INCOMING), Collections::emptyList);
+    }
+
+    @Override
+    public CompletableFuture<List<CallHierarchyOutgoingCall>> callHierarchyOutgoingCalls(CallHierarchyOutgoingCallsParams params) {
+        return recoverExceptions(incomingOutgoingCalls(CallHierarchyOutgoingCall::new, params.getItem(), CallHierarchy.Direction.OUTGOING), 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

@@ -32,6 +32,8 @@
 import java.io.Writer;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
+import java.util.function.Function;
+import org.apache.commons.lang3.tuple.Pair;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -55,6 +57,7 @@
 import io.usethesource.vallang.IValue;
 import io.usethesource.vallang.IValueFactory;
 import io.usethesource.vallang.exceptions.FactTypeUseException;
+import io.usethesource.vallang.type.TypeStore;
 
 public class ParserOnlyContribution implements ILanguageContributions {
     private static final Logger logger = LogManager.getLogger(ParserOnlyContribution.class);
@@ -201,6 +204,16 @@ public InterruptibleFuture<IList> selectionRange(IList focus) {
         return InterruptibleFuture.completedFuture(VF.list());
     }
 
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> prepareCallHierarchy(IList focus) {
+        return InterruptibleFuture.completedFuture(Pair.of(VF.list(), new TypeStore()));
+    }
+
+    @Override
+    public InterruptibleFuture<Pair<IList, TypeStore>> incomingOutgoingCalls(Function<TypeStore, IConstructor> hierarchyItem, Function<TypeStore, IConstructor> direction) {
+        return InterruptibleFuture.completedFuture(Pair.of(VF.list(), new TypeStore()));
+    }
+
     @Override
     public CompletableFuture<Boolean> hasHover() {
         return CompletableFuture.completedFuture(false);
@@ -271,6 +284,11 @@ public CompletableFuture<Boolean> hasSelectionRange() {
         return CompletableFuture.completedFuture(false);
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasCallHierarchy() {
+        return CompletableFuture.completedFuture(false);
+    }
+
     @Override
     public CompletableFuture<Boolean> specialCaseHighlighting() {
         return specialCaseHighlighting;