refactor: fall back to non-overlay analysis when diff-informed analysis is unavailable

Author: sam-robson

lib/init-action.js

@@ -2199,3 +2199,64 @@ test.serial(
     });
   },
 );
+
+test.serial(
+  "applyIncrementalAnalysisSettings: no-op when mode is not Overlay and diff-informed is unavailable",
+  (t) => {
+    const config = createTestConfig({});
+    config.overlayDatabaseMode = OverlayDatabaseMode.None;
+    const logger = getRunnerLogger(true);
+
+    configUtils.applyIncrementalAnalysisSettings(config, false, logger);
+
+    t.is(config.overlayDatabaseMode, OverlayDatabaseMode.None);
+    t.deepEqual(config.extraQueryExclusions, []);
+  },
+);
+
+test.serial(
+  "applyIncrementalAnalysisSettings: keeps overlay mode and adds exclusions when diff-informed analysis is available",
+  (t) => {
+    const config = createTestConfig({});
+    config.overlayDatabaseMode = OverlayDatabaseMode.Overlay;
+    const logger = getRunnerLogger(true);
+
+    configUtils.applyIncrementalAnalysisSettings(config, true, logger);
+
+    t.is(config.overlayDatabaseMode, OverlayDatabaseMode.Overlay);
+    t.deepEqual(config.extraQueryExclusions, [
+      { exclude: { tags: "exclude-from-incremental" } },
+    ]);
+  },
+);
+
+test.serial(
+  "applyIncrementalAnalysisSettings: reverts to None without exclusions when diff-informed analysis is unavailable",
+  (t) => {
+    const config = createTestConfig({});
+    config.overlayDatabaseMode =
+      OverlayDatabaseMode.Overlay as OverlayDatabaseMode;
+    const logger = getRunnerLogger(true);
+
+    configUtils.applyIncrementalAnalysisSettings(config, false, logger);
+
+    t.is(config.overlayDatabaseMode, OverlayDatabaseMode.None);
+    t.deepEqual(config.extraQueryExclusions, []);
+  },
+);
+
+test.serial(
+  "applyIncrementalAnalysisSettings: adds exclusions for diff-informed-only runs",
+  (t) => {
+    const config = createTestConfig({});
+    config.overlayDatabaseMode = OverlayDatabaseMode.None;
+    const logger = getRunnerLogger(true);
+
+    configUtils.applyIncrementalAnalysisSettings(config, true, logger);
+
+    t.is(config.overlayDatabaseMode, OverlayDatabaseMode.None);
+    t.deepEqual(config.extraQueryExclusions, [
+      { exclude: { tags: "exclude-from-incremental" } },
+    ]);
+  },
+);

src/config-utils.test.ts

@@ -31,7 +31,7 @@ import {
   addNoLanguageDiagnostic,
   makeTelemetryDiagnostic,
 } from "./diagnostics";
-import { shouldPerformDiffInformedAnalysis } from "./diff-informed-analysis-utils";
+import { prepareDiffInformedAnalysis } from "./diff-informed-analysis-utils";
 import { EnvVar } from "./environment";
 import * as errorMessages from "./error-messages";
 import { Feature, FeatureEnablement } from "./feature-flags";
@@ -1075,6 +1075,32 @@ function hasQueryCustomisation(userConfig: UserConfig): boolean {
   );
 }
 
+export function applyIncrementalAnalysisSettings(
+  config: Config,
+  diffInformedAnalysisAvailable: boolean,
+  logger: Logger,
+): void {
+  if (
+    config.overlayDatabaseMode === OverlayDatabaseMode.Overlay &&
+    !diffInformedAnalysisAvailable
+  ) {
+    logger.warning(
+      "Diff-informed analysis is not available for this pull request. " +
+        `Reverting overlay database mode to ${OverlayDatabaseMode.None}.`,
+    );
+    config.overlayDatabaseMode = OverlayDatabaseMode.None;
+  }
+
+  if (
+    config.overlayDatabaseMode === OverlayDatabaseMode.Overlay ||
+    diffInformedAnalysisAvailable
+  ) {
+    config.extraQueryExclusions.push({
+      exclude: { tags: "exclude-from-incremental" },
+    });
+  }
+}
+
 /**
  * Load and return the config.
  *
@@ -1229,18 +1255,17 @@ export async function initConfig(
     );
   }
 
-  if (
-    config.overlayDatabaseMode === OverlayDatabaseMode.Overlay ||
-    (await shouldPerformDiffInformedAnalysis(
-      inputs.codeql,
-      inputs.features,
-      logger,
-    ))
-  ) {
-    config.extraQueryExclusions.push({
-      exclude: { tags: "exclude-from-incremental" },
-    });
-  }
+  const diffInformedAnalysisAvailable = await prepareDiffInformedAnalysis(
+    inputs.codeql,
+    inputs.features,
+    logger,
+  );
+
+  applyIncrementalAnalysisSettings(
+    config,
+    diffInformedAnalysisAvailable,
+    logger,
+  );
 
   if (await isTrapCachingEnabled(features, config.overlayDatabaseMode)) {
     const { trapCaches, trapCacheDownloadTime } = await downloadCacheWithTime(

src/config-utils.ts

@@ -5,9 +5,9 @@ import type { PullRequestBranches } from "./actions-util";
 import { getApiClient, getGitHubVersion } from "./api-client";
 import type { CodeQL } from "./codeql";
 import { Feature, FeatureEnablement } from "./feature-flags";
-import { Logger } from "./logging";
+import { Logger, withGroupAsync } from "./logging";
 import { getRepositoryNwoFromEnv } from "./repository";
-import { GitHubVariant, satisfiesGHESVersion } from "./util";
+import { getErrorMessage, GitHubVariant, satisfiesGHESVersion } from "./util";
 
 /**
  * This interface is an abbreviated version of the file diff object returned by
@@ -69,6 +69,46 @@ export async function getDiffInformedAnalysisBranches(
   return branches;
 }
 
+/**
+ * Prepares the diff ranges needed for diff-informed analysis for the current
+ * run.
+ *
+ * @returns `true` if diff-informed analysis is ready to use for this run,
+ *   otherwise `false`.
+ */
+export async function prepareDiffInformedAnalysis(
+  codeql: CodeQL,
+  features: FeatureEnablement,
+  logger: Logger,
+): Promise<boolean> {
+  try {
+    const branches = await getDiffInformedAnalysisBranches(
+      codeql,
+      features,
+      logger,
+    );
+    if (!branches) {
+      return false;
+    }
+
+    return await withGroupAsync("Computing PR diff ranges", async () => {
+      try {
+        return await computeAndPersistDiffRanges(branches, logger);
+      } catch (e) {
+        logger.warning(
+          `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`,
+        );
+        return false;
+      }
+    });
+  } catch (e) {
+    logger.warning(
+      `Failed to determine diff-informed analysis availability: ${getErrorMessage(e)}`,
+    );
+    return false;
+  }
+}
+
 export interface DiffThunkRange {
   /** Relative path from the repository root, using forward slashes as separators. */
   path: string;
@@ -151,6 +191,33 @@ export async function getPullRequestEditedDiffRanges(
   return results;
 }
 
+/**
+ * Compute and persist the diff ranges for a pull request. This fetches the
+ * diff from the GitHub API and writes it to the diff ranges JSON file so that
+ * CodeQL can use it for diff-informed analysis.
+ *
+ * @param branches The base and head branches of the pull request, as returned
+ *   by `getDiffInformedAnalysisBranches`.
+ * @param logger
+ * @returns `true` if the diff ranges were successfully computed and persisted,
+ *   otherwise `false`.
+ */
+export async function computeAndPersistDiffRanges(
+  branches: PullRequestBranches,
+  logger: Logger,
+): Promise<boolean> {
+  const ranges = await getPullRequestEditedDiffRanges(branches, logger);
+  if (ranges === undefined) {
+    return false;
+  }
+  writeDiffRangesJsonFile(logger, ranges);
+  const distinctFiles = new Set(ranges.map((r) => r.path)).size;
+  logger.info(
+    `Persisted ${ranges.length} diff range(s) across ${distinctFiles} file(s).`,
+  );
+  return true;
+}
+
 async function getFileDiffsWithBasehead(
   branches: PullRequestBranches,
   logger: Logger,