Factorize logic of getting a task by name or creating it

Author: eliericha

integration/vscode/ada/src/gnattest.ts

@@ -13,6 +13,7 @@ import { escapeRegExp, exe, setTerminalEnvironment, slugify } from './helpers';
 import {
     DEFAULT_PROBLEM_MATCHERS,
     findTaskByName,
+    getOrCreateTask,
     runTaskSequence,
     SimpleTaskDef,
     TASK_BUILD_TEST_DRIVER,
@@ -801,30 +802,14 @@ async function buildTestDriverAndReportErrors(
 ) {
     const buildTasks = [];
     if (coverage) {
-        const adaTP = adaExtState.getAdaTaskProvider();
-        assert(adaTP);
-
-        const instTaskName = `GNATcoverage - Generate instrumented sources for coverage analysis`;
         /**
          * First try to fetch an existing task of the corresponding name. The
          * User may have defined a homonym in tasks.json to customize this
          * step.
          */
-        const instExistingTask = await findTaskByName(`${TASK_TYPE_ADA}: ${instTaskName}`).then(
-            undefined,
-            /**
-             * Return undefined in case of errors when searching for the task.
-             */
-            () => undefined,
-        );
-        let instTask;
-        if (instExistingTask) {
-            instTask = instExistingTask;
-        } else {
-            /**
-             * If there's no existing task of that name, create one on the fly.
-             */
-            const instTaskDef: SimpleTaskDef = {
+        const instTask = await getOrCreateTask(
+            `GNATcoverage - Generate instrumented sources for coverage analysis`,
+            async () => ({
                 type: TASK_TYPE_ADA,
                 command: 'gnatcov',
                 args: [
@@ -833,31 +818,12 @@ async function buildTestDriverAndReportErrors(
                     '-P',
                     await getGnatTestDriverProjectPath(),
                 ].concat(getScenarioArgs()),
-            };
-            instTask = (await adaTP.resolveTask(
-                new vscode.Task(
-                    instTaskDef,
-                    vscode.TaskScope.Workspace,
-                    instTaskName,
-                    TASK_TYPE_ADA,
-                    undefined,
-                    DEFAULT_PROBLEM_MATCHERS,
-                ),
-            ))!;
-            instTask.presentationOptions.reveal =
-                instTask.presentationOptions.reveal ?? vscode.TaskRevealKind.Never;
-        }
-
-        const buildTaskName = `GNATcoverage - Build GNATtest harness project in coverage mode`;
-        const buildExistingTask = await findTaskByName(`${TASK_TYPE_ADA}: ${buildTaskName}`).then(
-            undefined,
-            () => undefined,
+            }),
         );
-        let buildTask;
-        if (buildExistingTask) {
-            buildTask = buildExistingTask;
-        } else {
-            const buildTaskDef: SimpleTaskDef = {
+
+        const buildTask = await getOrCreateTask(
+            `GNATcoverage - Build GNATtest harness project in coverage mode`,
+            async () => ({
                 type: TASK_TYPE_ADA,
                 command: 'gprbuild',
                 args: [
@@ -877,20 +843,8 @@ async function buildTestDriverAndReportErrors(
                         '-fdump-scos',
                         '-fpreserve-control-flow',
                     ]),
-            };
-            buildTask = (await adaTP.resolveTask(
-                new vscode.Task(
-                    buildTaskDef,
-                    vscode.TaskScope.Workspace,
-                    buildTaskName,
-                    TASK_TYPE_ADA,
-                    undefined,
-                    DEFAULT_PROBLEM_MATCHERS,
-                ),
-            ))!;
-            buildTask.presentationOptions.reveal = vscode.TaskRevealKind.Never;
-        }
-
+            }),
+        );
         buildTasks.push(instTask, buildTask);
     } else {
         const task = await findTaskByName(`${TASK_TYPE_ADA}: ${TASK_BUILD_TEST_DRIVER}`);

integration/vscode/ada/src/taskProviders.ts

@@ -1075,7 +1075,7 @@ abstract class SequentialExecution extends vscode.CustomExecution {
  * @throws an Error if the task is not found.
  */
 export async function findTaskByName(
-    taskName: string,
+    taskFullName: string,
     tasks?: vscode.Task[],
 ): Promise<vscode.Task> {
     if (!tasks) {
@@ -1088,7 +1088,7 @@ export async function findTaskByName(
     }
 
     if (tasks.length == 0) {
-        throw Error('The task list is empty.' + ` Cannot find task '${taskName}'`);
+        throw Error('The task list is empty.' + ` Cannot find task '${taskFullName}'`);
     }
 
     // Sort the given tasks to put the workspace-defined ones first
@@ -1097,12 +1097,12 @@ export async function findTaskByName(
     tasks = tasks.sort(workspaceTasksFirst);
 
     const task = tasks.find((v) => {
-        return taskName == getConventionalTaskLabel(v) || taskName == v.name;
+        return taskFullName == getConventionalTaskLabel(v) || taskFullName == v.name;
     });
     if (task) {
         return task;
     } else {
-        const msg = `Could not find a task named '${taskName}' among the tasks:\n${tasks
+        const msg = `Could not find a task named '${taskFullName}' among the tasks:\n${tasks
             .map((t) => t.name)
             .join('\n')}`;
         throw Error(msg);
@@ -1385,3 +1385,50 @@ export async function runTaskAndGetResult(task: vscode.Task): Promise<number | u
         return Promise.reject(reason);
     });
 }
+
+/**
+ *
+ * Search for a task of a given name, or create one if no matching existing task is found.
+ *
+ * @param taskPlainName - plain name of the task (without the task type prefix)
+ * @param taskDef - callback to create a task definition if a matching existing task is not found
+ * @param taskType - type identifier of the task
+ * @returns an existing task with a matching name if found, otherwise creates a
+ * task of that name using the callback to create the definition
+ */
+export async function getOrCreateTask(
+    taskPlainName: string,
+    taskDef: () => Promise<vscode.TaskDefinition>,
+    taskType = TASK_TYPE_ADA,
+): Promise<vscode.Task> {
+    const adaTP = adaExtState.getAdaTaskProvider();
+    assert(adaTP);
+    const existingTask = await findTaskByName(`${taskType}: ${taskPlainName}`).then(
+        undefined,
+        /**
+         * Return undefined in case of errors when searching for the task.
+         */
+        () => undefined,
+    );
+    let task;
+    if (existingTask) {
+        task = existingTask;
+    } else {
+        /**
+         * If there's no existing task of that name, create one on the fly.
+         */
+        task = (await adaTP.resolveTask(
+            new vscode.Task(
+                await taskDef(),
+                vscode.TaskScope.Workspace,
+                taskPlainName,
+                taskType,
+                undefined,
+                DEFAULT_PROBLEM_MATCHERS,
+            ),
+        ))!;
+        task.presentationOptions.reveal =
+            task.presentationOptions.reveal ?? vscode.TaskRevealKind.Never;
+    }
+    return task;
+}