Document CargoTaskDefinition and factor out converting TaskDefinition to Execution

Author: Wilfred

editors/code/src/run.ts

@@ -2,7 +2,6 @@ import * as vscode from "vscode";
 importtype*aslcfrom"vscode-languageclient";
 import*asrafrom"./lsp_ext";
 import*astasksfrom"./tasks";
-import*astoolchainfrom"./toolchain";
 
 importtype{CtxInit}from"./ctx";
 import{makeDebugConfig}from"./debug";
@@ -112,22 +111,12 @@ export async function createTask(runnable: ra.Runnable, config: Config): Promise
 throw`Unexpected runnable kind: ${runnable.kind}`;
 }
 
-letprogram: string;
-letargs=createArgs(runnable);
-if(runnable.args.overrideCargo){
-// Split on spaces to allow overrides like "wrapper cargo".
-constcargoParts=runnable.args.overrideCargo.split(" ");
-
-program=unwrapUndefinable(cargoParts[0]);
-args=[...cargoParts.slice(1), ...args];
-}else{
-program=awaittoolchain.cargoPath();
-}
+constargs=createArgs(runnable);
 
 constdefinition: tasks.CargoTaskDefinition={
 type: tasks.TASK_TYPE,
-program,
- args,
+command: unwrapUndefinable(args[0]),// run, test, etc...
+args: args.slice(1),
 cwd: runnable.args.workspaceRoot||".",
 env: prepareEnv(runnable,config.runnablesExtraEnv),
 overrideCargo: runnable.args.overrideCargo,

editors/code/src/tasks.ts

@@ -2,17 +2,26 @@ import * as vscode from "vscode";
 import*astoolchainfrom"./toolchain";
 importtype{Config}from"./config";
 import{log}from"./util";
+import{unwrapUndefinable}from"./undefinable";
 
 // This ends up as the `type` key in tasks.json. RLS also uses `cargo` and
 // our configuration should be compatible with it so use the same key.
 exportconstTASK_TYPE="cargo";
+
 exportconstTASK_SOURCE="rust";
 
 exportinterfaceCargoTaskDefinitionextendsvscode.TaskDefinition{
-program: string;
-args: string[];
+// The cargo command, such as "run" or "check".
+command: string;
+// Additional arguments passed to the cargo command.
+args?: string[];
+// The working directory to run the cargo command in.
 cwd?: string;
+// The shell environment.
 env?: {[key: string]: string};
+// Override the cargo executable name, such as
+// "my_custom_cargo_bin".
+overrideCargo?: string;
 }
 
 classRustTaskProviderimplementsvscode.TaskProvider{
@@ -37,14 +46,12 @@ class RustTaskProvider implements vscode.TaskProvider {
 {command: "run",group: undefined},
 ];
 
-constcargoPath=awaittoolchain.cargoPath();
-
 consttasks: vscode.Task[]=[];
 for(constworkspaceTargetofvscode.workspace.workspaceFolders||[]){
 for(constdefofdefs){
 constvscodeTask=awaitbuildRustTask(
 workspaceTarget,
-{type: TASK_TYPE,program: cargoPath,args: [def.command]},
+{type: TASK_TYPE,command: def.command},
 `cargo ${def.command}`,
 this.config.problemMatcher,
 this.config.cargoRunner,
@@ -86,10 +93,28 @@ export async function buildRustTask(
 customRunner?: string,
 throwOnError: boolean=false,
 ): Promise<vscode.Task>{
-letexec: vscode.ProcessExecution|vscode.ShellExecution|undefined=undefined;
+constexec=awaitcargoToExecution(definition,customRunner,throwOnError);
 
+returnnewvscode.Task(
+definition,
+// scope can sometimes be undefined. in these situations we default to the workspace taskscope as
+// recommended by the official docs: https://code.visualstudio.com/api/extension-guides/task-provider#task-provider)
+scope??vscode.TaskScope.Workspace,
+name,
+TASK_SOURCE,
+exec,
+problemMatcher,
+);
+}
+
+asyncfunctioncargoToExecution(
+definition: CargoTaskDefinition,
+customRunner: string|undefined,
+throwOnError: boolean,
+): Promise<vscode.ProcessExecution|vscode.ShellExecution>{
 if(customRunner){
 construnnerCommand=`${customRunner}.buildShellExecution`;
+
 try{
 construnnerArgs={
 kind: TASK_TYPE,
@@ -100,7 +125,7 @@ export async function buildRustTask(
 constcustomExec=awaitvscode.commands.executeCommand(runnerCommand,runnerArgs);
 if(customExec){
 if(customExecinstanceofvscode.ShellExecution){
-exec=customExec;
+returncustomExec;
 }else{
 log.debug("Invalid cargo ShellExecution",customExec);
 throw"Invalid cargo ShellExecution.";
@@ -113,20 +138,20 @@ export async function buildRustTask(
 }
 }
 
-if(!exec){
-exec=newvscode.ProcessExecution(definition.program,definition.args,definition);
-}
+// Check whether we must use a user-defined substitute for cargo.
+// Split on spaces to allow overrides like "wrapper cargo".
+constcargoPath=awaittoolchain.cargoPath();
+constcargoCommand=definition.overrideCargo?.split(" ")??[cargoPath];
 
-returnnewvscode.Task(
-definition,
-// scope can sometimes be undefined. in these situations we default to the workspace taskscope as
-// recommended by the official docs: https://code.visualstudio.com/api/extension-guides/task-provider#task-provider)
-scope??vscode.TaskScope.Workspace,
-name,
-TASK_SOURCE,
-exec,
-problemMatcher,
-);
+constargs=[definition.command].concat(definition.args??[]);
+constfullCommand=[...cargoCommand, ...args];
+
+constprocessName=unwrapUndefinable(fullCommand[0]);
+
+returnnewvscode.ProcessExecution(processName,fullCommand.slice(1),{
+cwd: definition.cwd,
+env: definition.env,
+});
 }
 
 exportfunctionactivateTaskProvider(config: Config): vscode.Disposable{