Merge remote-tracking branch 'origin/main' into koesie10/ast-cfg-typed-commands

Author: koesie10

extensions/ql-vscode/src/common/commands.ts

@@ -3,6 +3,12 @@ import type { Uri, Range } from "vscode";
 import type { DbTreeViewItem } from "../databases/ui/db-tree-view-item";
 import type { DatabaseItem } from "../local-databases";
 import type { QueryHistoryInfo } from "../query-history/query-history-info";
+import type { RepositoriesFilterSortStateWithIds } from "../pure/variant-analysis-filter-sort";
+import type {
+  VariantAnalysis,
+  VariantAnalysisScannedRepository,
+  VariantAnalysisScannedRepositoryResult,
+} from "../variant-analysis/shared/variant-analysis";
 
 // A command function matching the signature that VS Code calls when
 // a command on a selection is invoked.
@@ -27,6 +33,8 @@ export type SingleSelectionCommandFunction<Item> = (
 // Base commands not tied directly to a module like e.g. variant analysis.
 export type BaseCommands = {
   "codeQL.openDocumentation": () => Promise<void>;
+
+  "codeQL.restartQueryServer": () => Promise<void>;
 };
 
 // Commands used for running local queries
@@ -74,6 +82,9 @@ export type QueryHistoryCommands = {
   "codeQLQueryHistory.itemClicked": SelectionCommandFunction<QueryHistoryInfo>;
   "codeQLQueryHistory.openOnGithub": SelectionCommandFunction<QueryHistoryInfo>;
   "codeQLQueryHistory.copyRepoList": SelectionCommandFunction<QueryHistoryInfo>;
+
+  // Commands in the command palette
+  "codeQL.exportSelectedVariantAnalysisResults": () => Promise<void>;
 };
 
 // Commands used for the local databases panel
@@ -118,9 +129,27 @@ export type LocalDatabasesCommands = {
 
 // Commands tied to variant analysis
 export type VariantAnalysisCommands = {
+  "codeQL.autoDownloadVariantAnalysisResult": (
+    scannedRepo: VariantAnalysisScannedRepository,
+    variantAnalysisSummary: VariantAnalysis,
+  ) => Promise<void>;
+  "codeQL.copyVariantAnalysisRepoList": (
+    variantAnalysisId: number,
+    filterSort?: RepositoriesFilterSortStateWithIds,
+  ) => Promise<void>;
+  "codeQL.loadVariantAnalysisRepoResults": (
+    variantAnalysisId: number,
+    repositoryFullName: string,
+  ) => Promise<VariantAnalysisScannedRepositoryResult>;
+  "codeQL.monitorVariantAnalysis": (
+    variantAnalysis: VariantAnalysis,
+  ) => Promise<void>;
   "codeQL.openVariantAnalysisLogs": (
     variantAnalysisId: number,
   ) => Promise<void>;
+  "codeQL.openVariantAnalysisView": (
+    variantAnalysisId: number,
+  ) => Promise<void>;
   "codeQL.runVariantAnalysis": (uri?: Uri) => Promise<void>;
   "codeQL.runVariantAnalysisContextEditor": (uri?: Uri) => Promise<void>;
 };
@@ -147,12 +176,23 @@ export type AstCfgCommands = {
   "codeQL.viewCfgContextEditor": () => Promise<void>;
 };
 
+export type PackagingCommands = {
+  "codeQL.installPackDependencies": () => Promise<void>;
+  "codeQL.downloadPacks": () => Promise<void>;
+};
+
+export type EvalLogViewerCommands = {
+  "codeQLEvalLogViewer.clear": () => Promise<void>;
+};
+
 export type AllCommands = BaseCommands &
   QueryHistoryCommands &
   LocalDatabasesCommands &
   VariantAnalysisCommands &
   DatabasePanelCommands &
-  AstCfgCommands;
+  AstCfgCommands &
+  PackagingCommands &
+  EvalLogViewerCommands;
 
 export type AppCommandManager = CommandManager<AllCommands>;
 

extensions/ql-vscode/src/eval-log-viewer.ts

@@ -8,11 +8,11 @@ import {
   EventEmitter,
   TreeItemCollapsibleState,
 } from "vscode";
-import { commandRunner } from "./commandRunner";
 import { DisposableObject } from "./pure/disposable-object";
 import { showAndLogExceptionWithTelemetry } from "./helpers";
 import { asError, getErrorMessage } from "./pure/helpers-pure";
 import { redactableError } from "./pure/errors";
+import { EvalLogViewerCommands } from "./common/commands";
 
 export interface EvalLogTreeItem {
   label?: string;
@@ -80,11 +80,12 @@ export class EvalLogViewer extends DisposableObject {
 
     this.push(this.treeView);
     this.push(this.treeDataProvider);
-    this.push(
-      commandRunner("codeQLEvalLogViewer.clear", async () => {
-        this.clear();
-      }),
-    );
+  }
+
+  public getCommands(): EvalLogViewerCommands {
+    return {
+      "codeQLEvalLogViewer.clear": async () => this.clear(),
+    };
   }
 
   private clear(): void {

extensions/ql-vscode/src/extension.ts

@@ -89,19 +89,10 @@ import { QLTestAdapterFactory } from "./test-adapter";
 import { TestUIService } from "./test-ui";
 import { CompareView } from "./compare/compare-view";
 import { initializeTelemetry } from "./telemetry";
-import {
-  commandRunner,
-  commandRunnerWithProgress,
-  ProgressCallback,
-  withProgress,
-} from "./commandRunner";
+import { commandRunner, ProgressCallback, withProgress } from "./commandRunner";
 import { CodeQlStatusBarHandler } from "./status-bar";
-import {
-  handleDownloadPacks,
-  handleInstallPackDependencies,
-} from "./packaging";
+import { getPackagingCommands } from "./packaging";
 import { HistoryItemLabelProvider } from "./query-history/history-item-label-provider";
-import { exportSelectedVariantAnalysisResults } from "./variant-analysis/export-results";
 import { EvalLogViewer } from "./eval-log-viewer";
 import { SummaryLanguageSupport } from "./log-insights/summary-language-support";
 import { JoinOrderScannerProvider } from "./log-insights/join-order";
@@ -111,16 +102,11 @@ import { NewQueryRunner } from "./query-server/query-runner";
 import { QueryRunner } from "./queryRunner";
 import { VariantAnalysisView } from "./variant-analysis/variant-analysis-view";
 import { VariantAnalysisViewSerializer } from "./variant-analysis/variant-analysis-view-serializer";
-import {
-  VariantAnalysis,
-  VariantAnalysisScannedRepository,
-} from "./variant-analysis/shared/variant-analysis";
 import { VariantAnalysisManager } from "./variant-analysis/variant-analysis-manager";
 import { createVariantAnalysisContentProvider } from "./variant-analysis/variant-analysis-content-provider";
 import { VSCodeMockGitHubApiServer } from "./mocks/vscode-mock-gh-api-server";
 import { VariantAnalysisResultsManager } from "./variant-analysis/variant-analysis-results-manager";
 import { ExtensionApp } from "./common/vscode/vscode-app";
-import { RepositoriesFilterSortStateWithIds } from "./pure/variant-analysis-filter-sort";
 import { DbModule } from "./databases/db-module";
 import { redactableError } from "./pure/errors";
 import { QueryHistoryDirs } from "./query-history/query-history-dirs";
@@ -169,11 +155,28 @@ const extension = extensions.getExtension(extensionId);
 /**
  * Return all commands that are not tied to the more specific managers.
  */
-function getCommands(): BaseCommands {
+function getCommands(
+  cliServer: CodeQLCliServer,
+  queryRunner: QueryRunner,
+): BaseCommands {
   return {
     "codeQL.openDocumentation": async () => {
       await env.openExternal(Uri.parse("https://codeql.github.com/docs/"));
     },
+    "codeQL.restartQueryServer": async () =>
+      withProgress(
+        async (progress: ProgressCallback, token: CancellationToken) => {
+          // We restart the CLI server too, to ensure they are the same version
+          cliServer.restartCliServer();
+          await queryRunner.restartQueryServer(progress, token);
+          void showAndLogInformationMessage("CodeQL Query Server restarted.", {
+            outputLogger: queryServerLogger,
+          });
+        },
+        {
+          title: "Restarting Query Server",
+        },
+      ),
   };
 }
 
@@ -819,7 +822,7 @@ async function activateWithInstalledDistribution(
   void extLogger.log("Registering top-level command palette commands.");
 
   const allCommands: AllCommands = {
-    ...getCommands(),
+    ...getCommands(cliServer, qs),
     ...qhm.getCommands(),
     ...variantAnalysisManager.getCommands(),
     ...databaseUI.getCommands(),
@@ -834,6 +837,10 @@ async function activateWithInstalledDistribution(
       astTemplateProvider,
       cfgTemplateProvider,
     }),
+    ...getPackagingCommands({
+      cliServer,
+    }),
+    ...evalLogViewer.getCommands(),
   };
 
   for (const [commandName, command] of Object.entries(allCommands)) {
@@ -860,78 +867,6 @@ async function activateWithInstalledDistribution(
     );
   }
 
-  ctx.subscriptions.push(
-    commandRunner(
-      "codeQL.copyVariantAnalysisRepoList",
-      async (
-        variantAnalysisId: number,
-        filterSort?: RepositoriesFilterSortStateWithIds,
-      ) => {
-        await variantAnalysisManager.copyRepoListToClipboard(
-          variantAnalysisId,
-          filterSort,
-        );
-      },
-    ),
-  );
-
-  ctx.subscriptions.push(
-    commandRunner(
-      "codeQL.monitorVariantAnalysis",
-      async (variantAnalysis: VariantAnalysis, token: CancellationToken) => {
-        await variantAnalysisManager.monitorVariantAnalysis(
-          variantAnalysis,
-          token,
-        );
-      },
-    ),
-  );
-
-  ctx.subscriptions.push(
-    commandRunner(
-      "codeQL.autoDownloadVariantAnalysisResult",
-      async (
-        scannedRepo: VariantAnalysisScannedRepository,
-        variantAnalysisSummary: VariantAnalysis,
-        token: CancellationToken,
-      ) => {
-        await variantAnalysisManager.enqueueDownload(
-          scannedRepo,
-          variantAnalysisSummary,
-          token,
-        );
-      },
-    ),
-  );
-
-  ctx.subscriptions.push(
-    commandRunner("codeQL.exportSelectedVariantAnalysisResults", async () => {
-      await exportSelectedVariantAnalysisResults(variantAnalysisManager, qhm);
-    }),
-  );
-
-  ctx.subscriptions.push(
-    commandRunner(
-      "codeQL.loadVariantAnalysisRepoResults",
-      async (variantAnalysisId: number, repositoryFullName: string) => {
-        await variantAnalysisManager.loadResults(
-          variantAnalysisId,
-          repositoryFullName,
-        );
-      },
-    ),
-  );
-
-  // The "openVariantAnalysisView" command is internal-only.
-  ctx.subscriptions.push(
-    commandRunner(
-      "codeQL.openVariantAnalysisView",
-      async (variantAnalysisId: number) => {
-        await variantAnalysisManager.showView(variantAnalysisId);
-      },
-    ),
-  );
-
   ctx.subscriptions.push(
     commandRunner("codeQL.openReferencedFile", async (selectedQuery: Uri) => {
       await openReferencedFile(qs, cliServer, selectedQuery);
@@ -964,23 +899,6 @@ async function activateWithInstalledDistribution(
     }),
   );
 
-  ctx.subscriptions.push(
-    commandRunnerWithProgress(
-      "codeQL.restartQueryServer",
-      async (progress: ProgressCallback, token: CancellationToken) => {
-        // We restart the CLI server too, to ensure they are the same version
-        cliServer.restartCliServer();
-        await qs.restartQueryServer(progress, token);
-        void showAndLogInformationMessage("CodeQL Query Server restarted.", {
-          outputLogger: queryServerLogger,
-        });
-      },
-      {
-        title: "Restarting Query Server",
-      },
-    ),
-  );
-
   ctx.subscriptions.push(
     commandRunner("codeQL.copyVersion", async () => {
       const text = `CodeQL extension version: ${
@@ -1013,28 +931,6 @@ async function activateWithInstalledDistribution(
     }),
   );
 
-  ctx.subscriptions.push(
-    commandRunnerWithProgress(
-      "codeQL.installPackDependencies",
-      async (progress: ProgressCallback) =>
-        await handleInstallPackDependencies(cliServer, progress),
-      {
-        title: "Installing pack dependencies",
-      },
-    ),
-  );
-
-  ctx.subscriptions.push(
-    commandRunnerWithProgress(
-      "codeQL.downloadPacks",
-      async (progress: ProgressCallback) =>
-        await handleDownloadPacks(cliServer, progress),
-      {
-        title: "Downloading packs",
-      },
-    ),
-  );
-
   ctx.subscriptions.push(
     commandRunner("codeQL.showLogs", async () => {
       extLogger.show();

extensions/ql-vscode/src/packaging.ts

@@ -5,11 +5,43 @@ import {
   showAndLogInformationMessage,
 } from "./helpers";
 import { QuickPickItem, window } from "vscode";
-import { ProgressCallback, UserCancellationException } from "./commandRunner";
+import {
+  ProgressCallback,
+  UserCancellationException,
+  withProgress,
+} from "./commandRunner";
 import { extLogger } from "./common";
 import { asError, getErrorStack } from "./pure/helpers-pure";
 import { redactableError } from "./pure/errors";
 import { PACKS_BY_QUERY_LANGUAGE } from "./common/query-language";
+import { PackagingCommands } from "./common/commands";
+
+type PackagingOptions = {
+  cliServer: CodeQLCliServer;
+};
+
+export function getPackagingCommands({
+  cliServer,
+}: PackagingOptions): PackagingCommands {
+  return {
+    "codeQL.installPackDependencies": async () =>
+      withProgress(
+        async (progress: ProgressCallback) =>
+          await handleInstallPackDependencies(cliServer, progress),
+        {
+          title: "Installing pack dependencies",
+        },
+      ),
+    "codeQL.downloadPacks": async () =>
+      withProgress(
+        async (progress: ProgressCallback) =>
+          await handleDownloadPacks(cliServer, progress),
+        {
+          title: "Downloading packs",
+        },
+      ),
+  };
+}
 
 /**
  * Prompts user to choose packs to download, and downloads them.