Merge pull request #3245 from github/robertbrignull/multi-query-published-pack

Add prototype implementation for codeQL.runVariantAnalysisPublishedPack

Author: robertbrignull

extensions/ql-vscode/src/codeql-cli/cli.ts

@@ -121,6 +121,16 @@ type GenerateExtensiblePredicateMetadataResult = {
   }>;
 };
 
+type PackDownloadResult = {
+  // There are other properties in this object, but they are
+  // not relevant for its use in the extension, so we omit them.
+  packs: Array<{
+    name: string;
+    version: string;
+  }>;
+  packDir: string;
+};
+
 /**
  * The expected output of `codeql resolve qlref`.
  */
@@ -1383,7 +1393,7 @@ export class CodeQLCliServer implements Disposable {
    * Downloads a specified pack.
    * @param packs The `<package-scope/name[@version]>` of the packs to download.
    */
-  async packDownload(packs: string[]) {
+  async packDownload(packs: string[]): Promise<PackDownloadResult> {
     return this.runJsonCodeQlCliCommandWithAuthentication(
       ["pack", "download"],
       packs,

extensions/ql-vscode/src/codeql-cli/query-language.ts

@@ -63,7 +63,7 @@ export async function askForLanguage(
     .sort((a, b) => a.label.localeCompare(b.label));
 
   const selectedItem = await window.showQuickPick(items, {
-    placeHolder: "Select target language for your query",
+    placeHolder: "Select target query language",
     ignoreFocusOut: true,
   });
   if (!selectedItem) {

extensions/ql-vscode/src/variant-analysis/variant-analysis-manager.ts

@@ -87,6 +87,7 @@ import type { QueryTreeViewItem } from "../queries-panel/query-tree-view-item";
 import { RequestError } from "@octokit/request-error";
 import { handleRequestError } from "./custom-errors";
 import { createMultiSelectionCommand } from "../common/vscode/selection-commands";
+import { askForLanguage } from "../codeql-cli/query-language";
 
 const maxRetryCount = 3;
 
@@ -214,7 +215,83 @@ export class VariantAnalysisManager
   }
 
   private async runVariantAnalysisFromPublishedPack(): Promise<void> {
-    throw new Error("Command not yet implemented");
+    return withProgress(async (progress, token) => {
+      progress({
+        maxStep: 8,
+        step: 0,
+        message: "Determining query language",
+      });
+
+      const language = await askForLanguage(this.cliServer);
+
+      progress({
+        maxStep: 8,
+        step: 1,
+        message: "Downloading query pack",
+      });
+
+      const packName = `codeql/${language}-queries`;
+      const packDownloadResult = await this.cliServer.packDownload([packName]);
+      const downloadedPack = packDownloadResult.packs[0];
+
+      const packDir = join(
+        packDownloadResult.packDir,
+        downloadedPack.name,
+        downloadedPack.version,
+      );
+
+      progress({
+        maxStep: 8,
+        step: 2,
+        message: "Resolving queries in pack",
+      });
+
+      const suitePath = join(
+        packDir,
+        "codeql-suites",
+        `${language}-code-scanning.qls`,
+      );
+      const resolvedQueries = await this.cliServer.resolveQueries(suitePath);
+
+      const problemQueries =
+        await this.filterToOnlyProblemQueries(resolvedQueries);
+
+      if (problemQueries.length === 0) {
+        void this.app.logger.showErrorMessage(
+          `Unable to trigger variant analysis. No problem queries found in published query pack: ${packName}.`,
+        );
+        return;
+      }
+
+      await this.runVariantAnalysis(
+        problemQueries.map((q) => Uri.file(q)),
+        (p) =>
+          progress({
+            ...p,
+            maxStep: p.maxStep + 3,
+            step: p.step + 3,
+          }),
+        token,
+      );
+    });
+  }
+
+  private async filterToOnlyProblemQueries(
+    queries: string[],
+  ): Promise<string[]> {
+    const problemQueries: string[] = [];
+    for (const query of queries) {
+      const queryMetadata = await this.cliServer.resolveMetadata(query);
+      if (
+        queryMetadata.kind === "problem" ||
+        queryMetadata.kind === "path-problem"
+      ) {
+        problemQueries.push(query);
+      } else {
+        void this.app.logger.log(`Skipping non-problem query ${query}`);
+      }
+    }
+    return problemQueries;
   }
 
   private async runVariantAnalysisCommand(uri: Uri): Promise<void> {