Parametric LSP: call hierarchy

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

@@ -32,6 +32,7 @@
 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,12 +59,15 @@ public interface ILanguageContributions {
     public InterruptibleFuture<ISet> implementation(IList focus);
     public InterruptibleFuture<IList> codeAction(IList focus);
     public InterruptibleFuture<IList> selectionRange(IList focus);
+    public InterruptibleFuture<IList> prepareCallHierarchy(IList focus);
+    public InterruptibleFuture<IList> incomingOutgoingCalls(IConstructor hierarchyItem, IConstructor direction);
 
     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<IConstructor> parseCallHierarchyData(String data);
 
     public CompletableFuture<Boolean> hasAnalysis();
     public CompletableFuture<Boolean> hasBuild();
@@ -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

@@ -33,8 +33,8 @@
 import java.util.concurrent.ExecutorService;
 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 +53,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 +95,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 +112,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 +159,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 +177,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,
@@ -263,6 +270,31 @@ public CompletableFuture<IList> parseCodeActions(String command) {
         });
     }
 
+    @Override
+    public CompletableFuture<IConstructor> parseCallHierarchyData(String data) {
+        return store.thenApply(completionStore -> {
+            try {
+                var callHierarchyDataAdt = completionStore.lookupAbstractDataType("CallHierarchyData");
+                if (callHierarchyDataAdt == null) {
+                    throw new IllegalArgumentException("CallHierarchyData is not defined in environment");
+                }
+                if (data.isEmpty()) {
+                    var none = completionStore.lookupConstructor(callHierarchyDataAdt, "none", TypeFactory.getInstance().tupleEmpty());
+                    if (none == null) {
+                        throw new IllegalArgumentException("CallHierarchyData::none() is not defined in environment");
+                    }
+                    return VF.constructor(none);
+                }
+                return (IConstructor) new StandardTextReader().read(VF, completionStore, callHierarchyDataAdt, new StringReader(data));
+            } catch (FactTypeUseException | IOException e) {
+                // this should never happen as long as the Rascal code
+                // for creating errors is type-correct. So it _might_ happen
+                // when running the interpreter on broken code.
+                throw new IllegalArgumentException("The call hierarchy item data could not be parsed", e);
+            }
+        });
+    }
+
     private CompletableFuture<IConstructor> parseCommand(String command) {
         return store.thenApply(commandStore -> {
             try {
@@ -301,7 +333,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 +441,18 @@ public InterruptibleFuture<IList> selectionRange(IList focus) {
         return execFunction(LanguageContributions.SELECTION_RANGE, selectionRange, VF.list(), focus);
     }
 
+    @Override
+    public InterruptibleFuture<IList> prepareCallHierarchy(IList focus) {
+        debug(LanguageContributions.CALL_HIERARCHY, "prepare", focus.length());
+        return execFunction(LanguageContributions.CALL_HIERARCHY, prepareCallHierarchy, VF.list(), focus);
+    }
+
+    @Override
+    public InterruptibleFuture<IList> incomingOutgoingCalls(IConstructor hierarchyItem, IConstructor direction) {
+        debug(LanguageContributions.CALL_HIERARCHY, hierarchyItem.has("name") ? hierarchyItem.get("name") : "?", direction.getName());
+        return execFunction(LanguageContributions.CALL_HIERARCHY, callHierarchyService, VF.list(), hierarchyItem, direction);
+    }
+
     private void debug(String name, Object param) {
         logger.debug("{}({})", name, param);
     }
@@ -473,6 +521,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

@@ -35,6 +35,7 @@
 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;
@@ -69,6 +70,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 +87,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 +165,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 +178,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
@@ -281,6 +288,11 @@ public CompletableFuture<IList> parseCodeActions(String command) {
         return execution.thenApply(c -> c.parseCodeActions(command)).thenCompose(Function.identity());
     }
 
+    @Override
+    public CompletableFuture<IConstructor> parseCallHierarchyData(String data) {
+        return incomingOutgoingCalls.thenApply(c -> c.parseCallHierarchyData(data)).thenCompose(Function.identity());
+    }
+
     @Override
     public InterruptibleFuture<IList> inlayHint(ITree input) {
         return flatten(inlayHint, c -> c.inlayHint(input));
@@ -336,6 +348,16 @@ public InterruptibleFuture<IList> selectionRange(IList focus) {
         return flatten(selectionRange, c -> c.selectionRange(focus));
     }
 
+    @Override
+    public InterruptibleFuture<IList> prepareCallHierarchy(IList focus) {
+        return flatten(prepareCallHierarchy, c -> c.prepareCallHierarchy(focus));
+    }
+
+    @Override
+    public InterruptibleFuture<IList> incomingOutgoingCalls(IConstructor hierarchyItem, IConstructor direction) {
+        return flatten(incomingOutgoingCalls, c -> c.incomingOutgoingCalls(hierarchyItem, direction));
+    }
+
     @Override
     public CompletableFuture<Boolean> hasCodeAction() {
         return hasCodeAction;
@@ -401,6 +423,11 @@ public CompletableFuture<Boolean> hasDidRenameFiles() {
         return hasDidRenameFiles;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasCallHierarchy() {
+        return hasCallHierarchy;
+    }
+
     @Override
     public CompletableFuture<Boolean> specialCaseHighlighting() {
         return specialCaseHighlighting;
@@ -425,4 +452,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/NoContributions.java

@@ -145,11 +145,26 @@ public InterruptibleFuture<ITuple> didRenameFiles(IList fileRenames) {
         throw new NoContributionException("didRenameFiles");
     }
 
+    @Override
+    public InterruptibleFuture<IList> prepareCallHierarchy(IList focus) {
+        throw new NoContributionException("prepareCallHierarchy");
+    }
+
+    @Override
+    public InterruptibleFuture<IList> incomingOutgoingCalls(IConstructor hierarchyItem, IConstructor direction) {
+        throw new NoContributionException("incomingOutgoingCalls");
+    }
+
     @Override
     public CompletableFuture<IList> parseCodeActions(String command) {
         throw new NoContributionException("parseCodeActions");
     }
 
+    @Override
+    public CompletableFuture<IConstructor> parseCallHierarchyData(String data) {
+        throw new NoContributionException("parseCallHierarchyData");
+    }
+
     @Override
     public CompletableFuture<Boolean> hasAnalysis() {
         return FALSE;
@@ -220,6 +235,11 @@ public CompletableFuture<Boolean> hasSelectionRange() {
         return FALSE;
     }
 
+    @Override
+    public CompletableFuture<Boolean> hasCallHierarchy() {
+        return FALSE;
+    }
+
     @Override
     public CompletableFuture<Boolean> specialCaseHighlighting() {
         return FALSE;