Use options instead of separate method for skipping cache store

This adds a new options argument to the `loadResults` method which
allows the caller to specify that the results should not be saved to the
cache. This exposes a smaller API surface and makes it harder to misuse
the methods.

Author: koesie10

extensions/ql-vscode/src/remote-queries/export-results.ts

@@ -126,13 +126,9 @@ export async function exportVariantAnalysisResults(
         continue;
       }
 
-      let result: VariantAnalysisScannedRepositoryResult;
-
-      if (!variantAnalysisManager.areResultsLoaded(variantAnalysis.id, repo.repository.fullName)) {
-        result = await variantAnalysisManager.loadResultsFromStorage(variantAnalysis.id, repo.repository.fullName);
-      } else {
-        result = await variantAnalysisManager.loadResults(variantAnalysis.id, repo.repository.fullName);
-      }
+      const result = await variantAnalysisManager.loadResults(variantAnalysis.id, repo.repository.fullName, {
+        skipCacheStore: true,
+      });
 
       yield [repo, result];
     }

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

@@ -18,7 +18,7 @@ import {
 import { getErrorMessage } from '../pure/helpers-pure';
 import { VariantAnalysisView } from './variant-analysis-view';
 import { VariantAnalysisViewManager } from './variant-analysis-view-manager';
-import { VariantAnalysisResultsManager } from './variant-analysis-results-manager';
+import { LoadResultsOptions, VariantAnalysisResultsManager } from './variant-analysis-results-manager';
 import { getControllerRepo, getQueryName, prepareRemoteQueryRun } from './run-remote-query';
 import {
   processUpdatedVariantAnalysis,
@@ -209,34 +209,13 @@ export class VariantAnalysisManager extends DisposableObject implements VariantA
     return this.variantAnalyses.size;
   }
 
-  public async loadResults(variantAnalysisId: number, repositoryFullName: string): Promise<VariantAnalysisScannedRepositoryResult> {
+  public async loadResults(variantAnalysisId: number, repositoryFullName: string, options?: LoadResultsOptions): Promise<VariantAnalysisScannedRepositoryResult> {
     const variantAnalysis = this.variantAnalyses.get(variantAnalysisId);
     if (!variantAnalysis) {
       throw new Error(`No variant analysis with id: ${variantAnalysisId}`);
     }
 
-    return this.variantAnalysisResultsManager.loadResults(variantAnalysisId, this.getVariantAnalysisStorageLocation(variantAnalysisId), repositoryFullName);
-  }
-
-  public areResultsLoaded(variantAnalysisId: number, repositoryFullName: string): boolean {
-    if (!this.variantAnalyses.has(variantAnalysisId)) {
-      return false;
-    }
-
-    return this.variantAnalysisResultsManager.areResultsLoaded(variantAnalysisId, repositoryFullName);
-  }
-
-  /**
-   * This method should only be used to temporarily get the results for a variant analysis. In general, loadResults should
-   * be preferred.
-   */
-  public async loadResultsFromStorage(variantAnalysisId: number, repositoryFullName: string): Promise<VariantAnalysisScannedRepositoryResult> {
-    const variantAnalysis = this.variantAnalyses.get(variantAnalysisId);
-    if (!variantAnalysis) {
-      throw new Error(`No variant analysis with id: ${variantAnalysisId}`);
-    }
-
-    return this.variantAnalysisResultsManager.loadResultsFromStorage(variantAnalysisId, this.getVariantAnalysisStorageLocation(variantAnalysisId), repositoryFullName);
+    return this.variantAnalysisResultsManager.loadResults(variantAnalysisId, this.getVariantAnalysisStorageLocation(variantAnalysisId), repositoryFullName, options);
   }
 
   private async variantAnalysisRecordExists(variantAnalysisId: number): Promise<boolean> {

extensions/ql-vscode/src/remote-queries/variant-analysis-results-manager.ts

@@ -28,6 +28,12 @@ export type ResultDownloadedEvent = {
   repoTask: VariantAnalysisRepositoryTask;
 }
 
+export type LoadResultsOptions = {
+  // If true, when results are loaded from storage, they will not be stored in the cache. This reduces memory usage if
+  // results are only needed temporarily (e.g. for exporting results to a different format).
+  skipCacheStore?: boolean;
+}
+
 export class VariantAnalysisResultsManager extends DisposableObject {
   private static readonly REPO_TASK_FILENAME = 'repo_task.json';
   private static readonly RESULTS_DIRECTORY = 'results';
@@ -86,18 +92,19 @@ export class VariantAnalysisResultsManager extends DisposableObject {
   public async loadResults(
     variantAnalysisId: number,
     variantAnalysisStoragePath: string,
-    repositoryFullName: string
+    repositoryFullName: string,
+    options?: LoadResultsOptions,
   ): Promise<VariantAnalysisScannedRepositoryResult> {
     const result = this.cachedResults.get(createCacheKey(variantAnalysisId, repositoryFullName));
+    if (result) {
+      return result;
+    }
 
-    return result ?? await this.loadResultsIntoMemory(variantAnalysisId, variantAnalysisStoragePath, repositoryFullName);
-  }
+    if (options?.skipCacheStore) {
+      return this.loadResultsFromStorage(variantAnalysisId, variantAnalysisStoragePath, repositoryFullName);
+    }
 
-  public areResultsLoaded(
-    variantAnalysisId: number,
-    repositoryFullName: string
-  ): boolean {
-    return this.cachedResults.has(createCacheKey(variantAnalysisId, repositoryFullName));
+    return this.loadResultsIntoMemory(variantAnalysisId, variantAnalysisStoragePath, repositoryFullName);
   }
 
   private async loadResultsIntoMemory(