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

Author: koesie10

extensions/ql-vscode/src/commandRunner.ts

@@ -89,7 +89,7 @@ export type ProgressTaskWithArgs<R> = (
  * @param args arguments passed to this task passed on from
  * `commands.registerCommand`.
  */
-type NoProgressTask = (...args: any[]) => Promise<any>;
+export type NoProgressTask = (...args: any[]) => Promise<any>;
 
 /**
  * This mediates between the kind of progress callbacks we want to

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

@@ -1,5 +1,5 @@
 import type { CommandManager } from "../packages/commands";
-import type { Uri } from "vscode";
+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";
@@ -27,6 +27,23 @@ 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
+export type LocalQueryCommands = {
+  "codeQL.runQuery": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryContextEditor": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryOnMultipleDatabases": (uri?: Uri) => Promise<void>;
+  "codeQL.runQueryOnMultipleDatabasesContextEditor": (
+    uri?: Uri,
+  ) => Promise<void>;
+  "codeQL.runQueries": SelectionCommandFunction<Uri>;
+  "codeQL.quickEval": (uri: Uri) => Promise<void>;
+  "codeQL.quickEvalContextEditor": (uri: Uri) => Promise<void>;
+  "codeQL.codeLensQuickEval": (uri: Uri, range: Range) => Promise<void>;
+  "codeQL.quickQuery": () => Promise<void>;
 };
 
 // Commands used for the query history panel
@@ -63,27 +80,42 @@ export type QueryHistoryCommands = {
 
 // Commands used for the local databases panel
 export type LocalDatabasesCommands = {
-  "codeQL.setCurrentDatabase": (uri: Uri) => Promise<void>;
-  "codeQL.setDefaultTourDatabase": () => Promise<void>;
+  // Command palette commands
+  "codeQL.chooseDatabaseFolder": () => Promise<void>;
+  "codeQL.chooseDatabaseArchive": () => Promise<void>;
+  "codeQL.chooseDatabaseInternet": () => Promise<void>;
+  "codeQL.chooseDatabaseGithub": () => Promise<void>;
   "codeQL.upgradeCurrentDatabase": () => Promise<void>;
   "codeQL.clearCache": () => Promise<void>;
 
+  // Explorer context menu
+  "codeQL.setCurrentDatabase": (uri: Uri) => Promise<void>;
+
+  // Database panel view title commands
   "codeQLDatabases.chooseDatabaseFolder": () => Promise<void>;
   "codeQLDatabases.chooseDatabaseArchive": () => Promise<void>;
   "codeQLDatabases.chooseDatabaseInternet": () => Promise<void>;
   "codeQLDatabases.chooseDatabaseGithub": () => Promise<void>;
+  "codeQLDatabases.sortByName": () => Promise<void>;
+  "codeQLDatabases.sortByDateAdded": () => Promise<void>;
+
+  // Database panel context menu
   "codeQLDatabases.setCurrentDatabase": (
     databaseItem: DatabaseItem,
   ) => Promise<void>;
-  "codeQLDatabases.sortByName": () => Promise<void>;
-  "codeQLDatabases.sortByDateAdded": () => Promise<void>;
-  "codeQLDatabases.removeOrphanedDatabases": () => Promise<void>;
 
+  // Database panel selection commands
   "codeQLDatabases.removeDatabase": SelectionCommandFunction<DatabaseItem>;
   "codeQLDatabases.upgradeDatabase": SelectionCommandFunction<DatabaseItem>;
   "codeQLDatabases.renameDatabase": SelectionCommandFunction<DatabaseItem>;
   "codeQLDatabases.openDatabaseFolder": SelectionCommandFunction<DatabaseItem>;
   "codeQLDatabases.addDatabaseSource": SelectionCommandFunction<DatabaseItem>;
+
+  // Codespace template commands
+  "codeQL.setDefaultTourDatabase": () => Promise<void>;
+
+  // Internal commands
+  "codeQLDatabases.removeOrphanedDatabases": () => Promise<void>;
 };
 
 // Commands tied to variant analysis
@@ -113,11 +145,20 @@ export type PackagingCommands = {
   "codeQL.downloadPacks": () => Promise<void>;
 };
 
+export type EvalLogViewerCommands = {
+  "codeQLEvalLogViewer.clear": () => Promise<void>;
+};
+
 export type AllCommands = BaseCommands &
   QueryHistoryCommands &
   LocalDatabasesCommands &
   VariantAnalysisCommands &
   DatabasePanelCommands &
-  PackagingCommands;
+  PackagingCommands &
+  EvalLogViewerCommands;
 
 export type AppCommandManager = CommandManager<AllCommands>;
+
+// Separate command manager because it uses a different logger
+export type QueryServerCommands = LocalQueryCommands;
+export type QueryServerCommandManager = CommandManager<QueryServerCommands>;

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

@@ -1,15 +1,18 @@
 import { commands } from "vscode";
-import { commandRunner } from "../../commandRunner";
+import { commandRunner, NoProgressTask } from "../../commandRunner";
 import { CommandFunction, CommandManager } from "../../packages/commands";
+import { OutputChannelLogger } from "../logging";
 
 /**
  * Create a command manager for VSCode, wrapping the commandRunner
  * and vscode.executeCommand.
  */
 export function createVSCodeCommandManager<
   Commands extends Record<string, CommandFunction>,
->(): CommandManager<Commands> {
-  return new CommandManager(commandRunner, wrapExecuteCommand);
+>(outputLogger?: OutputChannelLogger): CommandManager<Commands> {
+  return new CommandManager((commandId, task: NoProgressTask) => {
+    return commandRunner(commandId, task, outputLogger);
+  }, wrapExecuteCommand);
 }
 
 /**

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

@@ -3,21 +3,23 @@ import { VSCodeCredentials } from "../../authentication";
 import { Disposable } from "../../pure/disposable-object";
 import { App, AppMode } from "../app";
 import { AppEventEmitter } from "../events";
-import { extLogger, Logger } from "../logging";
+import { extLogger, Logger, queryServerLogger } from "../logging";
 import { Memento } from "../memento";
 import { VSCodeAppEventEmitter } from "./events";
-import { AppCommandManager } from "../commands";
+import { AppCommandManager, QueryServerCommandManager } from "../commands";
 import { createVSCodeCommandManager } from "./commands";
 
 export class ExtensionApp implements App {
   public readonly credentials: VSCodeCredentials;
   public readonly commands: AppCommandManager;
+  public readonly queryServerCommands: QueryServerCommandManager;
 
   public constructor(
     public readonly extensionContext: vscode.ExtensionContext,
   ) {
     this.credentials = new VSCodeCredentials();
     this.commands = createVSCodeCommandManager();
+    this.queryServerCommands = createVSCodeCommandManager(queryServerLogger);
     extensionContext.subscriptions.push(this.commands);
   }
 

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 {