Use bqrs diff before sarif diff

Author: paldepind

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

@@ -1255,9 +1255,11 @@ export class CodeQLCliServer implements Disposable {
   async bqrsDiff(
     bqrsPath1: string,
     bqrsPath2: string,
+    options?: BqrsDiffOptions,
   ): Promise<{
     uniquePath1: string;
     uniquePath2: string;
+    path: string;
     cleanup: () => Promise<void>;
   }> {
     const { path, cleanup } = await dir({ unsafeCleanup: true });
@@ -1270,13 +1272,14 @@ export class CodeQLCliServer implements Disposable {
         uniquePath1,
         "--right",
         uniquePath2,
-        "--retain-result-sets=''",
+        "--retain-result-sets",
+        options?.retainResultSets?.join(",") ?? "",
         bqrsPath1,
         bqrsPath2,
       ],
       "Diffing bqrs files",
     );
-    return { uniquePath1, uniquePath2, cleanup };
+    return { uniquePath1, uniquePath2, path, cleanup };
   }
 
   private async runInterpretCommand(

extensions/ql-vscode/src/compare/interpreted-results.ts

@@ -1,24 +1,12 @@
 import { Uri } from "vscode";
-import type { Log } from "sarif";
-import { pathExists } from "fs-extra";
-import { sarifParser } from "../common/sarif-parser";
+import { join } from "path";
 import type { CompletedLocalQueryInfo } from "../query-results";
 import type { DatabaseManager } from "../databases/local-databases";
 import type { CodeQLCliServer } from "../codeql-cli/cli";
 import type { InterpretedQueryCompareResult } from "../common/interface-types";
 
 import { sarifDiff } from "./sarif-diff";
 
-async function getInterpretedResults(
-  interpretedResultsPath: string,
-): Promise<Log | undefined> {
-  if (!(await pathExists(interpretedResultsPath))) {
-    return undefined;
-  }
-
-  return await sarifParser(interpretedResultsPath);
-}
-
 export async function compareInterpretedResults(
   databaseManager: DatabaseManager,
   cliServer: CodeQLCliServer,
@@ -34,37 +22,65 @@ export async function compareInterpretedResults(
     );
   }
 
-  const [fromResultSet, toResultSet, sourceLocationPrefix] = await Promise.all([
-    getInterpretedResults(
-      fromQuery.completedQuery.query.interpretedResultsPath,
-    ),
-    getInterpretedResults(toQuery.completedQuery.query.interpretedResultsPath),
-    database.getSourceLocationPrefix(cliServer),
-  ]);
+  const { uniquePath1, uniquePath2, path, cleanup } = await cliServer.bqrsDiff(
+    fromQuery.completedQuery.query.resultsPath,
+    toQuery.completedQuery.query.resultsPath,
+    { retainResultSets: ["nodes", "edges", "subpaths"] },
+  );
+  try {
+    const sarifOutput1 = join(path, "from.sarif");
+    const sarifOutput2 = join(path, "to.sarif");
 
-  if (!fromResultSet || !toResultSet) {
-    throw new Error(
-      "Could not find interpreted results for one or both queries.",
+    const sourceLocationPrefix =
+      await database.getSourceLocationPrefix(cliServer);
+    const sourceArchiveUri = database.sourceArchive;
+    const sourceInfo =
+      sourceArchiveUri === undefined
+        ? undefined
+        : {
+            sourceArchive: sourceArchiveUri.fsPath,
+            sourceLocationPrefix,
+          };
+
+    const fromResultSet = await cliServer.interpretBqrsSarif(
+      toQuery.completedQuery.query.metadata!,
+      uniquePath1,
+      sarifOutput1,
+      sourceInfo,
+    );
+    const toResultSet = await cliServer.interpretBqrsSarif(
+      toQuery.completedQuery.query.metadata!,
+      uniquePath2,
+      sarifOutput2,
+      sourceInfo,
     );
-  }
 
-  const fromResults = fromResultSet.runs[0].results;
-  const toResults = toResultSet.runs[0].results;
+    if (!fromResultSet || !toResultSet) {
+      throw new Error(
+        "Could not find interpreted results for one or both queries.",
+      );
+    }
 
-  if (!fromResults) {
-    throw new Error("No results found in the 'from' query.");
-  }
+    const fromResults = fromResultSet.runs[0].results;
+    const toResults = toResultSet.runs[0].results;
 
-  if (!toResults) {
-    throw new Error("No results found in the 'to' query.");
-  }
+    if (!fromResults) {
+      throw new Error("CodeQL Compare: Source query has no results.");
+    }
+
+    if (!toResults) {
+      throw new Error("CodeQL Compare: Target query has no results.");
+    }
 
-  const { from, to } = sarifDiff(fromResults, toResults);
+    const { from, to } = sarifDiff(fromResults, toResults);
 
-  return {
-    kind: "interpreted",
-    sourceLocationPrefix,
-    from,
-    to,
-  };
+    return {
+      kind: "interpreted",
+      sourceLocationPrefix,
+      from,
+      to,
+    };
+  } finally {
+    await cleanup();
+  }
 }

extensions/ql-vscode/src/compare/sarif-diff.ts

@@ -97,14 +97,6 @@ function toCanonicalResult(result: Result): Result {
  *  2. If the queries are 100% disjoint
  */
 export function sarifDiff(fromResults: Result[], toResults: Result[]) {
-  if (!fromResults.length) {
-    throw new Error("CodeQL Compare: Source query has no results.");
-  }
-
-  if (!toResults.length) {
-    throw new Error("CodeQL Compare: Target query has no results.");
-  }
-
   const canonicalFromResults = fromResults.map(toCanonicalResult);
   const canonicalToResults = toResults.map(toCanonicalResult);
 
@@ -113,13 +105,6 @@ export function sarifDiff(fromResults: Result[], toResults: Result[]) {
     to: arrayDiff(canonicalToResults, canonicalFromResults),
   };
 
-  if (
-    fromResults.length === diffResults.from.length &&
-    toResults.length === diffResults.to.length
-  ) {
-    throw new Error("CodeQL Compare: No overlap between the selected queries.");
-  }
-
   // We don't want to return the canonical results, we want to return the original results.
   // We can retrieve this by finding the index of the canonical result in the canonical results
   // and then using that index to find the original result. This is possible because we know that