Merge remote-tracking branch 'origin/main' into koesie10/commands-with-progress

Author: koesie10

extensions/ql-vscode/package-lock.json

@@ -1535,7 +1535,7 @@
     "ts-node": "^10.7.0",
     "ts-protoc-gen": "^0.9.0",
     "typescript": "^4.5.5",
-    "webpack": "^5.62.2",
+    "webpack": "^5.76.0",
     "webpack-cli": "^4.6.0"
   },
   "lint-staged": {

extensions/ql-vscode/package.json

@@ -1284,11 +1284,25 @@ export class CodeQLCliServer implements Disposable {
     );
   }
 
-  async packInstall(dir: string, forceUpdate = false) {
+  async packInstall(
+    dir: string,
+    { forceUpdate = false, workspaceFolders = [] as string[] } = {},
+  ) {
     const args = [dir];
     if (forceUpdate) {
       args.push("--mode", "update");
     }
+    if (workspaceFolders?.length > 0) {
+      if (await this.cliConstraints.supportsAdditionalPacksInstall()) {
+        args.push(
+          // Allow prerelease packs from the ql submodule.
+          "--allow-prerelease",
+          // Allow the use of --additional-packs argument without issueing a warning
+          "--no-strict-mode",
+          ...this.getAdditionalPacksArg(workspaceFolders),
+        );
+      }
+    }
     return this.runJsonCodeQlCliCommandWithAuthentication(
       ["pack", "install"],
       args,
@@ -1692,6 +1706,13 @@ export class CliVersionConstraint {
    */
   public static CLI_VERSION_WITH_QLPACKS_KIND = new SemVer("2.12.3");
 
+  /**
+   * CLI version that supports the `--additional-packs` option for the `pack install` command.
+   */
+  public static CLI_VERSION_WITH_ADDITIONAL_PACKS_INSTALL = new SemVer(
+    "2.12.4",
+  );
+
   constructor(private readonly cli: CodeQLCliServer) {
     /**/
   }
@@ -1755,4 +1776,10 @@ export class CliVersionConstraint {
       CliVersionConstraint.CLI_VERSION_WITH_QLPACKS_KIND,
     );
   }
+
+  async supportsAdditionalPacksInstall() {
+    return this.isVersionAtLeast(
+      CliVersionConstraint.CLI_VERSION_WITH_ADDITIONAL_PACKS_INSTALL,
+    );
+  }
 }

extensions/ql-vscode/src/cli.ts

@@ -3,7 +3,7 @@ import { Disposable } from "../pure/disposable-object";
 import { AppEventEmitter } from "./events";
 import { Logger } from "./logging";
 import { Memento } from "./memento";
-import { ExtensionCommandManager } from "./commands";
+import { AppCommandManager } from "./commands";
 
 export interface App {
   createEventEmitter<T>(): AppEventEmitter<T>;
@@ -16,7 +16,7 @@ export interface App {
   readonly workspaceStoragePath?: string;
   readonly workspaceState: Memento;
   readonly credentials: Credentials;
-  readonly commandManager: ExtensionCommandManager;
+  readonly commands: AppCommandManager;
 }
 
 export enum AppMode {

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

@@ -8,8 +8,8 @@ import type { Uri } from "vscode";
  * the implementation in the corresponding `getCommands` function.
  */
 
-// Commands directly in the extension
-export type ExtensionCommands = {
+// Base commands not tied directly to a module like e.g. variant analysis.
+export type BaseCommands = {
   "codeQL.openDocumentation": () => Promise<void>;
 };
 
@@ -22,6 +22,6 @@ export type VariantAnalysisCommands = {
   "codeQL.runVariantAnalysisContextEditor": (uri?: Uri) => Promise<void>;
 };
 
-export type AllCommands = ExtensionCommands & VariantAnalysisCommands;
+export type AllCommands = BaseCommands & VariantAnalysisCommands;
 
-export type ExtensionCommandManager = CommandManager<AllCommands>;
+export type AppCommandManager = CommandManager<AllCommands>;

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

@@ -3,16 +3,23 @@ import { commandRunner } from "../../commandRunner";
 import { CommandFunction, CommandManager } from "../../packages/commands";
 
 /**
- * Intializes a command manager for VSCode, wrapping the commandRunner
+ * Create a command manager for VSCode, wrapping the commandRunner
  * and vscode.executeCommand.
  */
-export function initializeVSCodeCommandManager<
+export function createVSCodeCommandManager<
   Commands extends Record<string, CommandFunction>,
 >(): CommandManager<Commands> {
-  return new CommandManager(commandRunner, wrappedExecuteCommand);
+  return new CommandManager(commandRunner, wrapExecuteCommand);
 }
 
-async function wrappedExecuteCommand<
+/**
+ * wrapExecuteCommand wraps commands.executeCommand to satisfy that the
+ * type is a Promise. Type script does not seem to be smart enough
+ * to figure out that `ReturnType<Commands[CommandName]>` is actually
+ * a Promise, so we need to add a second layer of wrapping and unwrapping
+ * (The `Promise<Awaited<` part) to get the right types.
+ */
+async function wrapExecuteCommand<
   Commands extends Record<string, CommandFunction>,
   CommandName extends keyof Commands & string = keyof Commands & string,
 >(

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

@@ -6,19 +6,19 @@ import { AppEventEmitter } from "../events";
 import { extLogger, Logger } from "../logging";
 import { Memento } from "../memento";
 import { VSCodeAppEventEmitter } from "./events";
-import { ExtensionCommandManager } from "../commands";
-import { initializeVSCodeCommandManager } from "./commands";
+import { AppCommandManager } from "../commands";
+import { createVSCodeCommandManager } from "./commands";
 
 export class ExtensionApp implements App {
   public readonly credentials: VSCodeCredentials;
-  public readonly commandManager: ExtensionCommandManager;
+  public readonly commands: AppCommandManager;
 
   public constructor(
     public readonly extensionContext: vscode.ExtensionContext,
   ) {
     this.credentials = new VSCodeCredentials();
-    this.commandManager = initializeVSCodeCommandManager();
-    extensionContext.subscriptions.push(this.commandManager);
+    this.commands = createVSCodeCommandManager();
+    extensionContext.subscriptions.push(this.commands);
   }
 
   public get extensionPath(): string {