Refactor query evaluation code to separate UI concerns

Author: Dave Bartolomeo

extensions/ql-vscode/src/common/logging/logger.ts

@@ -3,7 +3,8 @@ export interface LogOptions {
   trailingNewline?: boolean;
 }
 
-export interface Logger {
+/** Minimal logger interface. */
+export interface BaseLogger {
   /**
    * Writes the given log message, optionally followed by a newline.
    * This function is asynchronous and will only resolve once the message is written
@@ -15,7 +16,10 @@ export interface Logger {
    * @param options Optional settings.
    */
   log(message: string, options?: LogOptions): Promise<void>;
+}
 
+/** Full logger interface, including a function to show the log in the UI. */
+export interface Logger extends BaseLogger {
   /**
    * Reveal the logger channel in the UI.
    *

extensions/ql-vscode/src/contextual/astBuilder.ts

@@ -4,7 +4,7 @@ import { DatabaseItem } from "../local-databases";
 import { ChildAstItem, AstItem } from "../astViewer";
 import fileRangeFromURI from "./fileRangeFromURI";
 import { Uri } from "vscode";
-import { QueryWithResults } from "../run-queries-shared";
+import { QueryOutputDir } from "../run-queries-shared";
 
 /**
  * A class that wraps a tree of QL results from a query that
@@ -14,12 +14,12 @@ export default class AstBuilder {
   private roots: AstItem[] | undefined;
   private bqrsPath: string;
   constructor(
-    queryResults: QueryWithResults,
+    outputDir: QueryOutputDir,
     private cli: CodeQLCliServer,
     public db: DatabaseItem,
     public fileName: Uri,
   ) {
-    this.bqrsPath = queryResults.query.resultsPaths.resultsPath;
+    this.bqrsPath = outputDir.bqrsPath;
   }
 
   async getRoots(): Promise<AstItem[]> {

extensions/ql-vscode/src/contextual/locationFinder.ts

@@ -19,8 +19,9 @@ import {
   runContextualQuery,
 } from "./queryResolver";
 import { CancellationToken, LocationLink, Uri } from "vscode";
-import { QueryWithResults } from "../run-queries-shared";
+import { QueryOutputDir } from "../run-queries-shared";
 import { QueryRunner } from "../queryRunner";
+import { QueryResultType } from "../pure/new-messages";
 
 export const SELECT_QUERY_NAME = "#select";
 export const TEMPLATE_NAME = "selectedSourceFile";
@@ -78,21 +79,23 @@ export async function getLocationsForUriString(
       token,
       templates,
     );
-    if (results.successful) {
-      links.push(...(await getLinksFromResults(results, cli, db, filter)));
+    if (results.resultType === QueryResultType.SUCCESS) {
+      links.push(
+        ...(await getLinksFromResults(results.outputDir, cli, db, filter)),
+      );
     }
   }
   return links;
 }
 
 async function getLinksFromResults(
-  results: QueryWithResults,
+  outputDir: QueryOutputDir,
   cli: CodeQLCliServer,
   db: DatabaseItem,
   filter: (srcFile: string, destFile: string) => boolean,
 ): Promise<FullLocationLink[]> {
   const localLinks: FullLocationLink[] = [];
-  const bqrsPath = results.query.resultsPaths.resultsPath;
+  const bqrsPath = outputDir.bqrsPath;
   const info = await cli.bqrsInfo(bqrsPath);
   const selectInfo = getResultSetSchema(SELECT_QUERY_NAME, info);
   if (isValidSelect(selectInfo)) {

extensions/ql-vscode/src/contextual/queryResolver.ts

@@ -13,11 +13,10 @@ import {
 import { KeyType, kindOfKeyType, nameOfKeyType, tagOfKeyType } from "./keyType";
 import { CodeQLCliServer } from "../cli";
 import { DatabaseItem } from "../local-databases";
-import { extLogger } from "../common";
-import { createInitialQueryInfo } from "../run-queries-shared";
-import { CancellationToken, Uri } from "vscode";
+import { extLogger, TeeLogger } from "../common";
+import { CancellationToken } from "vscode";
 import { ProgressCallback } from "../progress";
-import { QueryRunner } from "../queryRunner";
+import { CoreCompletedQuery, QueryRunner } from "../queryRunner";
 import { redactableError } from "../pure/errors";
 import { QLPACK_FILENAMES } from "../pure/ql";
 
@@ -169,32 +168,30 @@ export async function runContextualQuery(
   progress: ProgressCallback,
   token: CancellationToken,
   templates: Record<string, string>,
-) {
+): Promise<CoreCompletedQuery> {
   const { packPath, createdTempLockFile } = await resolveContextualQuery(
     cli,
     query,
   );
-  const initialInfo = await createInitialQueryInfo(
-    Uri.file(query),
-    {
-      name: db.name,
-      databaseUri: db.databaseUri.toString(),
-    },
+  const queryRun = qs.createQueryRun(
+    db.databaseUri.fsPath,
+    { queryPath: query, quickEvalPosition: undefined },
     false,
+    getOnDiskWorkspaceFolders(),
+    queryStorageDir,
+    undefined,
+    templates,
   );
   void extLogger.log(
-    `Running contextual query ${query}; results will be stored in ${queryStorageDir}`,
+    `Running contextual query ${query}; results will be stored in ${queryRun.outputDir}`,
   );
-  const queryResult = await qs.compileAndRunQueryAgainstDatabase(
-    db,
-    initialInfo,
-    queryStorageDir,
+  const results = await queryRun.evaluate(
     progress,
     token,
-    templates,
+    new TeeLogger(qs.logger, queryRun.outputDir.logPath),
   );
   if (createdTempLockFile) {
     await removeTemporaryLockFile(packPath);
   }
-  return queryResult;
+  return results;
 }

extensions/ql-vscode/src/contextual/templateProvider.ts

@@ -32,8 +32,7 @@ import {
   runContextualQuery,
 } from "./queryResolver";
 import { isCanary, NO_CACHE_AST_VIEWER } from "../config";
-import { QueryWithResults } from "../run-queries-shared";
-import { QueryRunner } from "../queryRunner";
+import { CoreCompletedQuery, QueryRunner } from "../queryRunner";
 
 /**
  * Runs templated CodeQL queries to find definitions in
@@ -155,25 +154,22 @@ export class TemplateQueryReferenceProvider implements ReferenceProvider {
   }
 }
 
-type QueryWithDb = {
-  query: QueryWithResults;
-  dbUri: Uri;
-};
-
 /**
  * Run templated CodeQL queries to produce AST information for
  * source-language files.
  */
 export class TemplatePrintAstProvider {
-  private cache: CachedOperation<QueryWithDb>;
+  private cache: CachedOperation<CoreCompletedQuery>;
 
   constructor(
     private cli: CodeQLCliServer,
     private qs: QueryRunner,
     private dbm: DatabaseManager,
     private queryStorageDir: string,
   ) {
-    this.cache = new CachedOperation<QueryWithDb>(this.getAst.bind(this));
+    this.cache = new CachedOperation<CoreCompletedQuery>(
+      this.getAst.bind(this),
+    );
   }
 
   async provideAst(
@@ -186,14 +182,14 @@ export class TemplatePrintAstProvider {
         "Cannot view the AST. Please select a valid source file inside a CodeQL database.",
       );
     }
-    const { query, dbUri } = this.shouldCache()
+    const completedQuery = this.shouldCache()
       ? await this.cache.get(fileUri.toString(), progress, token)
       : await this.getAst(fileUri.toString(), progress, token);
 
     return new AstBuilder(
-      query,
+      completedQuery.outputDir,
       this.cli,
-      this.dbm.findDatabaseItem(dbUri)!,
+      this.dbm.findDatabaseItem(Uri.file(completedQuery.dbPath))!,
       fileUri,
     );
   }
@@ -206,7 +202,7 @@ export class TemplatePrintAstProvider {
     uriString: string,
     progress: ProgressCallback,
     token: CancellationToken,
-  ): Promise<QueryWithDb> {
+  ): Promise<CoreCompletedQuery> {
     const uri = Uri.parse(uriString, true);
     if (uri.scheme !== zipArchiveScheme) {
       throw new Error(
@@ -242,7 +238,7 @@ export class TemplatePrintAstProvider {
       [TEMPLATE_NAME]: zippedArchive.pathWithinSourceArchive,
     };
 
-    const queryResult = await runContextualQuery(
+    const results = await runContextualQuery(
       query,
       db,
       this.queryStorageDir,
@@ -252,10 +248,7 @@ export class TemplatePrintAstProvider {
       token,
       templates,
     );
-    return {
-      query: queryResult,
-      dbUri: db.databaseUri,
-    };
+    return results;
   }
 }
 

extensions/ql-vscode/src/helpers.ts

@@ -754,7 +754,7 @@ export async function tryGetQueryMetadata(
  * Creates a file in the query directory that indicates when this query was created.
  * This is important for keeping track of when queries should be removed.
  *
- * @param queryPath The directory that will containt all files relevant to a query result.
+ * @param queryPath The directory that will contain all files relevant to a query result.
  * It does not need to exist.
  */
 export async function createTimestampFile(storagePath: string) {

extensions/ql-vscode/src/legacy-query-server/legacyRunner.ts

@@ -1,18 +1,19 @@
 import { CancellationToken } from "vscode";
+import { CodeQLCliServer } from "../cli";
 import { ProgressCallback } from "../progress";
+import { Logger } from "../common";
 import { DatabaseItem } from "../local-databases";
 import {
   Dataset,
   deregisterDatabases,
   registerDatabases,
 } from "../pure/legacy-messages";
-import { InitialQueryInfo, LocalQueryInfo } from "../query-results";
-import { QueryRunner } from "../queryRunner";
-import { QueryWithResults } from "../run-queries-shared";
+import { CoreQueryResults, CoreQueryTarget, QueryRunner } from "../queryRunner";
+import { QueryOutputDir } from "../run-queries-shared";
 import { QueryServerClient } from "./queryserver-client";
 import {
   clearCacheInDatabase,
-  compileAndRunQueryAgainstDatabase,
+  compileAndRunQueryAgainstDatabaseCore,
 } from "./run-queries";
 import { upgradeDatabaseExplicit } from "./upgrades";
 
@@ -21,10 +22,18 @@ export class LegacyQueryRunner extends QueryRunner {
     super();
   }
 
-  get cliServer() {
+  get cliServer(): CodeQLCliServer {
     return this.qs.cliServer;
   }
 
+  get customLogDirectory(): string | undefined {
+    return undefined;
+  }
+
+  get logger(): Logger {
+    return this.qs.logger;
+  }
+
   async restartQueryServer(
     progress: ProgressCallback,
     token: CancellationToken,
@@ -47,25 +56,29 @@ export class LegacyQueryRunner extends QueryRunner {
   ): Promise<void> {
     await clearCacheInDatabase(this.qs, dbItem, progress, token);
   }
-  async compileAndRunQueryAgainstDatabase(
-    dbItem: DatabaseItem,
-    initialInfo: InitialQueryInfo,
-    queryStorageDir: string,
+
+  protected async compileAndRunQueryAgainstDatabaseCore(
+    dbPath: string,
+    query: CoreQueryTarget,
+    additionalPacks: string[],
+    generateEvalLog: boolean,
+    outputDir: QueryOutputDir,
     progress: ProgressCallback,
     token: CancellationToken,
-    templates?: Record<string, string>,
-    queryInfo?: LocalQueryInfo,
-  ): Promise<QueryWithResults> {
-    return await compileAndRunQueryAgainstDatabase(
-      this.qs.cliServer,
+    templates: Record<string, string> | undefined,
+    logger: Logger,
+  ): Promise<CoreQueryResults> {
+    return await compileAndRunQueryAgainstDatabaseCore(
       this.qs,
-      dbItem,
-      initialInfo,
-      queryStorageDir,
+      dbPath,
+      query,
+      generateEvalLog,
+      additionalPacks,
+      outputDir,
       progress,
       token,
       templates,
-      queryInfo,
+      logger,
     );
   }