API and implementation of codefixes and code actions for Rascal itself

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

@@ -44,4 +44,5 @@ public interface IBaseTextDocumentService extends TextDocumentService {
     void unregisterLanguage(LanguageParameter lang);
     CompletableFuture<IValue> executeCommand(String languageName, String command);
     LineColumnOffsetMap getColumnMap(ISourceLocation file);
+
 }

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

@@ -29,7 +29,6 @@
 import java.io.IOException;
 import java.io.Reader;
 import java.time.Duration;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
@@ -50,7 +49,6 @@
 import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.eclipse.lsp4j.CodeAction;
-import org.eclipse.lsp4j.CodeActionKind;
 import org.eclipse.lsp4j.CodeActionParams;
 import org.eclipse.lsp4j.CodeLens;
 import org.eclipse.lsp4j.CodeLensOptions;
@@ -90,7 +88,6 @@
 import org.eclipse.lsp4j.TextDocumentItem;
 import org.eclipse.lsp4j.TextDocumentSyncKind;
 import org.eclipse.lsp4j.VersionedTextDocumentIdentifier;
-import org.eclipse.lsp4j.WorkspaceEdit;
 import org.eclipse.lsp4j.jsonrpc.ResponseErrorException;
 import org.eclipse.lsp4j.jsonrpc.messages.Either;
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseError;
@@ -108,11 +105,10 @@
 import org.rascalmpl.vscode.lsp.TextDocumentState;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricFileFacts;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricSummary;
-import org.rascalmpl.vscode.lsp.parametric.model.RascalADTs;
 import org.rascalmpl.vscode.lsp.parametric.model.ParametricSummary.SummaryLookup;
 import org.rascalmpl.vscode.lsp.terminal.ITerminalIDEServer.LanguageParameter;
+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.FoldingRanges;
 import org.rascalmpl.vscode.lsp.util.Outline;
 import org.rascalmpl.vscode.lsp.util.SemanticTokenizer;
@@ -132,7 +128,6 @@
 import io.usethesource.vallang.IString;
 import io.usethesource.vallang.ITuple;
 import io.usethesource.vallang.IValue;
-import io.usethesource.vallang.IWithKeywordParameters;
 import io.usethesource.vallang.exceptions.FactParseError;
 
 public class ParametricTextDocumentService implements IBaseTextDocumentService, LanguageClientAware {
@@ -387,80 +382,10 @@ private CodeLens locCommandTupleToCodeLense(String languageName, IValue v) {
         ISourceLocation loc = (ISourceLocation) t.get(0);
         IConstructor command = (IConstructor) t.get(1);
 
-        return new CodeLens(Locations.toRange(loc, columns), constructorToCommand(languageName, command), null);
+        return new CodeLens(Locations.toRange(loc, columns), CodeActions.constructorToCommand(dedicatedLanguageName, languageName, command), null);
     }
 
-    private CodeAction constructorToCodeAction(String languageName, IConstructor codeAction) {
-        IWithKeywordParameters<?> kw = codeAction.asWithKeywordParameters();
-        IConstructor command = (IConstructor) kw.getParameter(RascalADTs.CodeActionFields.COMMAND);
-        IString title = (IString) kw.getParameter(RascalADTs.CodeActionFields.TITLE);
-        IList edits = (IList) kw.getParameter(RascalADTs.CodeActionFields.EDITS);
-        IConstructor kind = (IConstructor) kw.getParameter(RascalADTs.CodeActionFields.KIND);
 
-        // first deal with the defaults. Must mimick what's in util::LanguageServer with the `data CodeAction` declaration
-        if (title == null) {
-            if (command != null) {
-                title = (IString) command.asWithKeywordParameters().getParameter(RascalADTs.CommandFields.TITLE);
-            }
-
-            if (title == null) {
-                title = IRascalValueFactory.getInstance().string("");
-            }
-        }
-
-        CodeAction result = new CodeAction(title.getValue());
-
-        if (command != null) {
-            result.setCommand(constructorToCommand(languageName, command));
-        }
-
-        if (edits != null) {
-            result.setEdit(new WorkspaceEdit(DocumentChanges.translateDocumentChanges(this, edits)));
-        }
-
-        result.setKind(constructorToCodeActionKind(kind));
-
-        return result;
-    }
-
-    /**
-     * Translates `refactor(inline())` to `"refactor.inline"` and `empty()` to `""`, etc.
-     * `kind == null` signals absence of the optional parameter. This is factorede into
-     * this private function because otherwise every call has to check it.
-     */
-    private String constructorToCodeActionKind(@Nullable IConstructor kind) {
-        if (kind == null) {
-            return CodeActionKind.QuickFix;
-        }
-
-        String name = kind.getName();
-
-        if (name.isEmpty()) {
-            return "";
-        }
-        else if (name.length() == 1) {
-            return name.toUpperCase();
-        }
-        else if ("empty".equals(name)) {
-            return "";
-        }
-        else {
-            var kw = kind.asWithKeywordParameters();
-            for (String kwn : kw.getParameterNames()) {
-                String nestedName = constructorToCodeActionKind((IConstructor) kw.getParameter(kwn));
-                name = name + (nestedName.isEmpty() ? "" : ("." + nestedName));
-            }
-        }
-
-        return name;
-    }
-
-    private Command constructorToCommand(String languageName, IConstructor command) {
-        IWithKeywordParameters<?> kw = command.asWithKeywordParameters();
-        IString possibleTitle = (IString) kw.getParameter(RascalADTs.CommandFields.TITLE);
-
-        return new Command(possibleTitle != null ? possibleTitle.getValue() : command.toString(), getRascalMetaCommandName(), Arrays.asList(languageName, command.toString()));
-    }
 
     private void handleParsingErrors(TextDocumentState file) {
         handleParsingErrors(file, file.getCurrentTreeAsync());
@@ -588,6 +513,7 @@ public CompletableFuture<List<Either<Command, CodeAction>>> codeAction(CodeActio
         logger.debug("codeActions: {}", params);
 
         final ILanguageContributions contribs = contributions(params.getTextDocument());
+
         final var loc = Locations.toLoc(params.getTextDocument());
         final var start = params.getRange().getStart();
         // convert to Rascal 1-based line
@@ -629,15 +555,15 @@ public CompletableFuture<List<Either<Command, CodeAction>>> codeAction(CodeActio
         return codeActions.thenCombine(quickfixes, (actions, quicks) ->
                 Stream.concat(quicks, actions)
                     .map(IConstructor.class::cast)
-                    .map(cons -> constructorToCodeAction(contribs.getName(), cons))
+                    .map(cons -> CodeActions.constructorToCodeAction(this, dedicatedLanguageName, contribs.getName(), cons))
                     .map(cmd  -> Either.<Command,CodeAction>forRight(cmd))
                     .collect(Collectors.toList())
             );
     }
 
     private CompletableFuture<IList> computeCodeActions(final ILanguageContributions contribs, final int startLine, final int startColumn, ITree tree) {
         IList focus = TreeSearch.computeFocusList(tree, startLine, startColumn);
-        
+
         if (!focus.isEmpty()) {
             return contribs.codeActions(focus).get();
         }

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

@@ -30,6 +30,7 @@
 import static org.rascalmpl.vscode.lsp.util.EvaluatorUtil.runEvaluator;
 
 import java.io.IOException;
+import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -51,6 +52,7 @@
 import org.eclipse.lsp4j.jsonrpc.messages.ResponseErrorCode;
 import org.rascalmpl.exceptions.Throw;
 import org.rascalmpl.interpreter.Evaluator;
+import org.rascalmpl.interpreter.env.ModuleEnvironment;
 import org.rascalmpl.library.util.PathConfig;
 import org.rascalmpl.values.IRascalValueFactory;
 import org.rascalmpl.values.functions.IFunction;
@@ -59,17 +61,19 @@
 import org.rascalmpl.vscode.lsp.BaseWorkspaceService;
 import org.rascalmpl.vscode.lsp.IBaseLanguageClient;
 import org.rascalmpl.vscode.lsp.RascalLSPMonitor;
+import org.rascalmpl.vscode.lsp.util.EvaluatorUtil;
 import org.rascalmpl.vscode.lsp.util.RascalServices;
 import org.rascalmpl.vscode.lsp.util.concurrent.InterruptibleFuture;
 import org.rascalmpl.vscode.lsp.util.locations.ColumnMaps;
-
 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.IValue;
 import io.usethesource.vallang.IValueFactory;
+import io.usethesource.vallang.exceptions.FactTypeUseException;
+import io.usethesource.vallang.io.StandardTextReader;
 import io.usethesource.vallang.type.Type;
 import io.usethesource.vallang.type.TypeFactory;
 import io.usethesource.vallang.type.TypeStore;
@@ -82,6 +86,9 @@ public class RascalLanguageServices {
     private final CompletableFuture<Evaluator> outlineEvaluator;
     private final CompletableFuture<Evaluator> semanticEvaluator;
     private final CompletableFuture<Evaluator> compilerEvaluator;
+    private final CompletableFuture<Evaluator> actionEvaluator;
+
+    private final CompletableFuture<TypeStore> actionStore;
 
     private final TypeFactory tf = TypeFactory.getInstance();
     private final TypeStore store = new TypeStore();
@@ -100,6 +107,8 @@ public RascalLanguageServices(RascalTextDocumentService docService, BaseWorkspac
         outlineEvaluator = makeFutureEvaluator(exec, docService, workspaceService, client, "Rascal outline", monitor, null, false, "lang::rascal::lsp::Outline");
         semanticEvaluator = makeFutureEvaluator(exec, docService, workspaceService, client, "Rascal semantics", monitor, null, true, "lang::rascalcore::check::Summary", "lang::rascal::lsp::refactor::Rename");
         compilerEvaluator = makeFutureEvaluator(exec, docService, workspaceService, client, "Rascal compiler", monitor, null, true, "lang::rascalcore::check::Checker");
+        actionEvaluator = makeFutureEvaluator(exec, docService, workspaceService, client, "Rascal actions", monitor, null, true, "lang::rascal::lsp::Actions");
+        actionStore = actionEvaluator.thenApply(e -> ((ModuleEnvironment) e.getModule("lang::rascal::lsp::Actions")).getStore());
     }
 
     public InterruptibleFuture<@Nullable IConstructor> getSummary(ISourceLocation occ, PathConfig pcfg) {
@@ -116,6 +125,8 @@ public RascalLanguageServices(RascalTextDocumentService docService, BaseWorkspac
         }
     }
 
+
+
     private static IConstructor addResources(PathConfig pcfg) {
         var result = pcfg.asConstructor();
         return result.asWithKeywordParameters()
@@ -250,6 +261,49 @@ public List<CodeLensSuggestion> locateCodeLenses(ITree tree) {
         return result;
     }
 
+    public CompletableFuture<IList> parseCodeActions(String command) {
+        return actionStore.thenApply(commandStore -> {
+            try {
+                var TF = TypeFactory.getInstance();
+                return (IList) new StandardTextReader().read(VF, commandStore, TF.listType(commandStore.lookupAbstractDataType("CodeAction")), new StringReader(command));
+            } 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 command could not be parsed", e);
+            }
+        });
+    }
+
+    public InterruptibleFuture<IValue> executeCommand(String command) {
+        logger.debug("executeCommand({}...) (full command value in TRACE level)", () -> command.substring(0, Math.min(10, command.length())));
+        logger.trace("Full command: {}", command);
+
+        return InterruptibleFuture.flatten(parseCommand(command).thenApply(cons ->
+            EvaluatorUtil.<IValue>runEvaluator(
+                "executeCommand",
+                actionEvaluator,
+                ev -> ev.call("evaluateRascalCommand", cons),
+                null,
+                exec,
+                true,
+                client
+            )
+        ), exec);
+    }
+
+    private CompletableFuture<IConstructor> parseCommand(String command) {
+        return actionStore.thenApply(commandStore -> {
+            try {
+                return (IConstructor) new StandardTextReader().read(VF, commandStore, commandStore.lookupAbstractDataType("Command"), new StringReader(command));
+            }
+            catch (FactTypeUseException | IOException e) {
+                logger.catching(e);
+                throw new IllegalArgumentException("The command could not be parsed", e);
+            }
+        });
+    }
+
     public static final class CodeLensSuggestion {
         private final ISourceLocation line;
         private final String commandName;
@@ -268,7 +322,6 @@ public List<Object> getArguments() {
             return arguments;
         }
 
-
         public ISourceLocation getLine() {
             return line;
         }
@@ -281,6 +334,13 @@ public String getCommandName() {
         public String getShortName() {
             return shortName;
         }
+    }
 
+    public InterruptibleFuture<IList> codeActions(IList focus, PathConfig pcfg) {
+        return runEvaluator("Rascal codeActions", actionEvaluator, eval -> {
+            Map<String,IValue> kws = Map.of("pcfg", pcfg.asConstructor());
+            return (IList) eval.call("rascalCodeActions", "lang::rascal::lsp::Actions", kws, focus);
+        },
+        null, exec, false, client);
     }
 }