v1.5.0

Add more context in changelog
Update changelog
2021-06-14 20:00:34 +01:00 · 2021-06-14 18:42:42 +01:00 · 2021-06-14 18:42:42 +01:00 · 2021-06-14 18:42:42 +01:00 · 2021-06-14 18:42:42 +01:00 · 2021-06-14 18:42:42 +01:00
58 changed files with 1722 additions and 595 deletions
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -126,7 +126,7 @@ jobs:
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest]
-        version: ['v2.2.6', 'v2.3.3', 'v2.4.5', 'v2.4.6', 'v2.5.3']
+        version: ['v2.2.6', 'v2.3.3', 'v2.4.6', 'v2.5.5']
    env:
      CLI_VERSION: ${{ matrix.version }}
      TEST_CODEQL_PATH: '${{ github.workspace }}/codeql'
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,7 +56,8 @@ We recommend that you keep `npm run watch` running in the backgound and you only

 1. on first checkout
 2. whenever any of the non-TypeScript resources have changed
-3. on any change to files included in the webview
+3. on any change to files included in one of the webviews
+   - **Important**: This is easy to forget. You must explicitly run `npm run build` whenever one of the files in the webview is changed. These are the files in the `src/view` and `src/compare/view` folders.

 ### Installing the extension

--- a/extensions/ql-vscode/.eslintrc.js
+++ b/extensions/ql-vscode/.eslintrc.js
@@ -22,8 +22,10 @@ module.exports = {
      },
    ],
    "@typescript-eslint/explicit-function-return-type": "off",
+    "@typescript-eslint/explicit-module-boundary-types": "off",
    "@typescript-eslint/no-non-null-assertion": "off",
    "@typescript-eslint/no-explicit-any": "off",
+    "@typescript-eslint/no-floating-promises": [ "error", { ignoreVoid: true } ],
    "prefer-const": ["warn", { destructuring: "all" }],
    indent: "off",
    "@typescript-eslint/indent": "off",
--- a/extensions/ql-vscode/CHANGELOG.md
+++ b/extensions/ql-vscode/CHANGELOG.md
@@ -1,5 +1,14 @@
 # CodeQL for Visual Studio Code: Changelog

+## 1.5.0 - 14 June 2021
+
+- Display CodeQL CLI version being downloaded during an upgrade. [#862](https://github.com/github/vscode-codeql/pull/862)
+- Display a helpful message and link to documentation when a query produces no results. [#866](https://github.com/github/vscode-codeql/pull/866)
+- Refresh test databases automatically after a test run. [#868](https://github.com/github/vscode-codeql/pull/868)
+- Allow users to specify a custom directory for storing query server logs (`codeQL.runningQueries.customLogDirectory`). The extension will not delete these logs automatically. [#863](https://github.com/github/vscode-codeql/pull/863)
+- Support the VS Code [Workspace Trust feature](https://code.visualstudio.com/docs/editor/workspace-trust). This extension is now enabled in untrusted workspaces, but it restricts commands that contain arbitrary paths. [#861](https://github.com/github/vscode-codeql/pull/861)
+- Allow the `codeQL.cli.executablePath` configuration setting to be set in workspace-scoped configuration files. This means that each workspace can now specify its own CodeQL CLI compiler, a feature that is unblocked due to implementing Workspace Trust. [#861](https://github.com/github/vscode-codeql/pull/861)
+
 ## 1.4.8 - 05 May 2021

 - Copy version information to the clipboard when a user clicks the CodeQL section of the status bar. [#845](https://github.com/github/vscode-codeql/pull/845)
--- a/extensions/ql-vscode/package-lock.json
+++ b/extensions/ql-vscode/package-lock.json
--- a/extensions/ql-vscode/package.json
+++ b/extensions/ql-vscode/package.json
@@ -4,7 +4,7 @@
  "description": "CodeQL for Visual Studio Code",
  "author": "GitHub",
  "private": true,
-  "version": "1.4.8",
+  "version": "1.5.0",
  "publisher": "GitHub",
  "license": "MIT",
  "icon": "media/VS-marketplace-CodeQL-icon.png",
@@ -13,7 +13,7 @@
    "url": "https://github.com/github/vscode-codeql"
  },
  "engines": {
-    "vscode": "^1.43.0"
+    "vscode": "^1.57.0"
  },
  "categories": [
    "Programming Languages"
@@ -21,6 +21,16 @@
  "extensionDependencies": [
    "hbenl.vscode-test-explorer"
  ],
+  "capabilities": {
+    "untrustedWorkspaces": {
+      "supported": "limited",
+      "description": "Workspace trust is required to execute commands that can contain arbitrary paths.",
+      "restrictedConfigurations": [
+        "codeQL.cli.executablePath",
+        "codeQL.runningTests.additionalTestArguments"
+      ]
+    }
+  },
  "activationEvents": [
    "onLanguage:ql",
    "onView:codeQLDatabases",
@@ -118,7 +128,7 @@
      "title": "CodeQL",
      "properties": {
        "codeQL.cli.executablePath": {
-          "scope": "machine",
+          "scope": "window",
          "type": "string",
          "default": "",
          "description": "Path to the CodeQL executable that should be used by the CodeQL extension. The executable is named `codeql` on Linux/Mac and `codeql.exe` on Windows. If empty, the extension will look for a CodeQL executable on your shell PATH, or if CodeQL is not on your PATH, download and manage its own CodeQL executable."
@@ -179,6 +189,14 @@
          "default": 20,
          "description": "Max number of simultaneous queries to run using the 'CodeQL: Run Queries' command."
        },
+        "codeQL.runningQueries.customLogDirectory": {
+          "type": [
+            "string",
+            null
+          ],
+          "default": null,
+          "description": "Path to a directory where the CodeQL extension should store query server logs. If empty, the extension stores logs in a temporary workspace folder and deletes the contents after each run."
+        },
        "codeQL.resultsDisplay.pageSize": {
          "type": "integer",
          "default": 200,
@@ -190,7 +208,7 @@
          "description": "Default string for how to label query history items. %t is the time of the query, %q is the query name, %d is the database name, %r is the number of results, and %s is a status string."
        },
        "codeQL.runningTests.additionalTestArguments": {
-          "scope": "machine",
+          "scope": "window",
          "type": "array",
          "default": [],
          "markdownDescription": "Additional command line arguments to pass to the CLI when [running tests](https://codeql.github.com/docs/codeql-cli/manual/test-run/). This setting should be an array of strings, each containing an argument to be passed."
@@ -898,11 +916,11 @@
    "@types/through2": "^2.0.36",
    "@types/tmp": "^0.1.0",
    "@types/unzipper": "~0.10.1",
-    "@types/vscode": "^1.43.0",
+    "@types/vscode": "^1.57.0",
    "@types/webpack": "^4.32.1",
    "@types/xml2js": "~0.4.4",
-    "@typescript-eslint/eslint-plugin": "~2.23.0",
-    "@typescript-eslint/parser": "~2.23.0",
+    "@typescript-eslint/eslint-plugin": "^4.26.0",
+    "@typescript-eslint/parser": "^4.26.0",
    "ansi-colors": "^4.1.1",
    "applicationinsights": "^1.8.7",
    "chai": "^4.2.0",
@@ -930,7 +948,7 @@
    "ts-loader": "^8.1.0",
    "ts-node": "^8.3.0",
    "ts-protoc-gen": "^0.9.0",
-    "typescript": "~3.8.3",
+    "typescript": "^4.3.2",
    "typescript-formatter": "^7.2.2",
    "vsce": "^1.65.0",
    "vscode-test": "^1.4.0",
--- a/extensions/ql-vscode/src/archive-filesystem-provider.ts
+++ b/extensions/ql-vscode/src/archive-filesystem-provider.ts
@@ -115,7 +115,7 @@ class InvalidSourceArchiveUriError extends Error {
 export function decodeSourceArchiveUri(uri: vscode.Uri): ZipFileReference {
  if (!uri.authority) {
    // Uri is malformed, but this is recoverable
-    logger.log(`Warning: ${new InvalidSourceArchiveUriError(uri).message}`);
+    void logger.log(`Warning: ${new InvalidSourceArchiveUriError(uri).message}`);
    return {
      pathWithinSourceArchive: '/',
      sourceArchiveZipPath: uri.path
@@ -141,7 +141,7 @@ function ensureFile(map: DirectoryHierarchyMap, file: string) {
  const dirname = path.dirname(file);
  if (dirname === '.') {
    const error = `Ill-formed path ${file} in zip archive (expected absolute path)`;
-    logger.log(error);
+    void logger.log(error);
    throw new Error(error);
  }
  ensureDir(map, dirname);
--- a/extensions/ql-vscode/src/astViewer.ts
+++ b/extensions/ql-vscode/src/astViewer.ts
@@ -56,7 +56,7 @@ class AstViewerDataProvider extends DisposableObject implements TreeDataProvider
  }

  refresh(): void {
-    this._onDidChangeTreeData.fire();
+    this._onDidChangeTreeData.fire(undefined);
  }
  getChildren(item?: AstItem): ProviderResult<AstItem[]> {
    const children = item ? item.children : this.roots;
--- a/extensions/ql-vscode/src/cli-version.ts
+++ b/extensions/ql-vscode/src/cli-version.ts
@@ -18,7 +18,7 @@ export async function getCodeQlCliVersion(codeQlPath: string, logger: Logger): P
  } catch (e) {
    // Failed to run the version command. This might happen if the cli version is _really_ old, or it is corrupted.
    // Either way, we can't determine compatibility.
-    logger.log(`Failed to run 'codeql version'. Reason: ${e.message}`);
+    void logger.log(`Failed to run 'codeql version'. Reason: ${e.message}`);
    return undefined;
  }
 }
--- a/extensions/ql-vscode/src/cli.ts
+++ b/extensions/ql-vscode/src/cli.ts
@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/camelcase */
 import * as cpp from 'child-process-promise';
 import * as child_process from 'child_process';
 import * as fs from 'fs-extra';
@@ -183,15 +182,15 @@ export class CodeQLCliServer implements Disposable {
  killProcessIfRunning(): void {
    if (this.process) {
      // Tell the Java CLI server process to shut down.
-      this.logger.log('Sending shutdown request');
+      void this.logger.log('Sending shutdown request');
      try {
        this.process.stdin.write(JSON.stringify(['shutdown']), 'utf8');
        this.process.stdin.write(this.nullBuffer);
-        this.logger.log('Sent shutdown request');
+        void this.logger.log('Sent shutdown request');
      } catch (e) {
        // We are probably fine here, the process has already closed stdin.
-        this.logger.log(`Shutdown request failed: process stdin may have already closed. The error was ${e}`);
-        this.logger.log('Stopping the process anyway.');
+        void this.logger.log(`Shutdown request failed: process stdin may have already closed. The error was ${e}`);
+        void this.logger.log('Stopping the process anyway.');
      }
      // Close the stdin and stdout streams.
      // This is important on Windows where the child process may not die cleanly.
@@ -271,7 +270,7 @@ export class CodeQLCliServer implements Disposable {
      // Compute the full args array
      const args = command.concat(LOGGING_FLAGS).concat(commandArgs);
      const argsString = args.join(' ');
-      this.logger.log(`${description} using CodeQL CLI: ${argsString}...`);
+      void this.logger.log(`${description} using CodeQL CLI: ${argsString}...`);
      try {
        await new Promise<void>((resolve, reject) => {
          // Start listening to stdout
@@ -298,7 +297,7 @@ export class CodeQLCliServer implements Disposable {
        const fullBuffer = Buffer.concat(stdoutBuffers);
        // Make sure we remove the terminator;
        const data = fullBuffer.toString('utf8', 0, fullBuffer.length - 1);
-        this.logger.log('CLI command succeeded.');
+        void this.logger.log('CLI command succeeded.');
        return data;
      } catch (err) {
        // Kill the process if it isn't already dead.
@@ -311,7 +310,7 @@ export class CodeQLCliServer implements Disposable {
        newError.stack += (err.stack || '');
        throw newError;
      } finally {
-        this.logger.log(Buffer.concat(stderrBuffers).toString('utf8'));
+        void this.logger.log(Buffer.concat(stderrBuffers).toString('utf8'));
        // Remove the listeners we set up.
        process.stdout.removeAllListeners('data');
        process.stderr.removeAllListeners('data');
@@ -371,7 +370,7 @@ export class CodeQLCliServer implements Disposable {
      }
      if (logger !== undefined) {
        // The human-readable output goes to stderr.
-        logStream(child.stderr!, logger);
+        void logStream(child.stderr!, logger);
      }

      for await (const event of await splitStreamAtSeparators(child.stdout!, ['\0'])) {
@@ -813,7 +812,7 @@ export function spawnServer(
  if (progressReporter !== undefined) {
    progressReporter.report({ message: `Starting ${name}` });
  }
-  logger.log(`Starting ${name} using CodeQL CLI: ${base} ${argsString}`);
+  void logger.log(`Starting ${name} using CodeQL CLI: ${base} ${argsString}`);
  const child = child_process.spawn(base, args);
  if (!child || !child.pid) {
    throw new Error(`Failed to start ${name} using command ${base} ${argsString}.`);
@@ -829,7 +828,7 @@ export function spawnServer(
  if (progressReporter !== undefined) {
    progressReporter.report({ message: `Started ${name}` });
  }
-  logger.log(`${name} started on PID: ${child.pid}`);
+  void logger.log(`${name} started on PID: ${child.pid}`);
  return child;
 }

@@ -858,10 +857,10 @@ export async function runCodeQlCliCommand(
    if (progressReporter !== undefined) {
      progressReporter.report({ message: description });
    }
-    logger.log(`${description} using CodeQL CLI: ${codeQlPath} ${argsString}...`);
+    void logger.log(`${description} using CodeQL CLI: ${codeQlPath} ${argsString}...`);
    const result = await promisify(child_process.execFile)(codeQlPath, args);
-    logger.log(result.stderr);
-    logger.log('CLI command succeeded.');
+    void logger.log(result.stderr);
+    void logger.log('CLI command succeeded.');
    return result.stdout;
  } catch (err) {
    throw new Error(`${description} failed: ${err.stderr || err}`);
@@ -976,7 +975,8 @@ const lineEndings = ['\r\n', '\r', '\n'];
 */
 async function logStream(stream: Readable, logger: Logger): Promise<void> {
  for await (const line of await splitStreamAtSeparators(stream, lineEndings)) {
-    logger.log(line);
+    // Await the result of log here in order to ensure the logs are written in the correct order.
+    await logger.log(line);
  }
 }

--- a/extensions/ql-vscode/src/commandRunner.ts
+++ b/extensions/ql-vscode/src/commandRunner.ts
@@ -126,16 +126,16 @@ export function commandRunner(
      if (e instanceof UserCancellationException) {
        // User has cancelled this action manually
        if (e.silent) {
-          logger.log(errorMessage);
+          void logger.log(errorMessage);
        } else {
-          showAndLogWarningMessage(errorMessage);
+          void showAndLogWarningMessage(errorMessage);
        }
      } else {
        // Include the full stack in the error log only.
        const fullMessage = e.stack
          ? `${errorMessage}\n${e.stack}`
          : errorMessage;
-        showAndLogErrorMessage(errorMessage, {
+        void showAndLogErrorMessage(errorMessage, {
          fullMessage
        });
      }
@@ -177,16 +177,16 @@ export function commandRunnerWithProgress<R>(
      if (e instanceof UserCancellationException) {
        // User has cancelled this action manually
        if (e.silent) {
-          logger.log(errorMessage);
+          void logger.log(errorMessage);
        } else {
-          showAndLogWarningMessage(errorMessage);
+          void showAndLogWarningMessage(errorMessage);
        }
      } else {
        // Include the full stack in the error log only.
        const fullMessage = e.stack
          ? `${errorMessage}\n${e.stack}`
          : errorMessage;
-        showAndLogErrorMessage(errorMessage, {
+        void showAndLogErrorMessage(errorMessage, {
          fullMessage
        });
      }
--- a/extensions/ql-vscode/src/compare/compare-interface.ts
+++ b/extensions/ql-vscode/src/compare/compare-interface.ts
@@ -173,7 +173,7 @@ export class CompareInterfaceManager extends DisposableObject {
        break;

      case 'changeCompare':
-        this.changeTable(msg.newResultSetName);
+        await this.changeTable(msg.newResultSetName);
        break;

      case 'viewSourceFile':
@@ -267,11 +267,11 @@ export class CompareInterfaceManager extends DisposableObject {
    return resultsDiff(fromResults, toResults);
  }

-  private openQuery(kind: 'from' | 'to') {
+  private async openQuery(kind: 'from' | 'to') {
    const toOpen =
      kind === 'from' ? this.comparePair?.from : this.comparePair?.to;
    if (toOpen) {
-      this.showQueryResultsCallback(toOpen);
+      await this.showQueryResultsCallback(toOpen);
    }
  }
 }
--- a/extensions/ql-vscode/src/compare/view/Compare.tsx
+++ b/extensions/ql-vscode/src/compare/view/Compare.tsx
@@ -21,7 +21,7 @@ const emptyComparison: SetComparisonsMessage = {
  message: 'Empty comparison'
 };

-export function Compare(_: {}): JSX.Element {
+export function Compare(_: Record<string, never>): JSX.Element {
  const [comparison, setComparison] = useState<SetComparisonsMessage>(
    emptyComparison
  );
@@ -38,7 +38,9 @@ export function Compare(_: {}): JSX.Element {
            setComparison(msg);
        }
      } else {
-        console.error(`Invalid event origin ${evt.origin}`);
+        // sanitize origin
+        const origin = evt.origin.replace(/\n|\r/g, '');
+        console.error(`Invalid event origin ${origin}`);
      }
    });
  });
@@ -64,8 +66,8 @@ export function Compare(_: {}): JSX.Element {
        {hasRows ? (
          <CompareTable comparison={comparison}></CompareTable>
        ) : (
-            <div className="vscode-codeql__compare-message">{message}</div>
-          )}
+          <div className="vscode-codeql__compare-message">{message}</div>
+        )}
      </>
    );
  } catch (err) {
--- a/extensions/ql-vscode/src/config.ts
+++ b/extensions/ql-vscode/src/config.ts
@@ -87,9 +87,10 @@ export const NUMBER_OF_TEST_THREADS_SETTING = new Setting('numberOfThreads', RUN
 export const MAX_QUERIES = new Setting('maxQueries', RUNNING_QUERIES_SETTING);
 export const AUTOSAVE_SETTING = new Setting('autoSave', RUNNING_QUERIES_SETTING);
 export const PAGE_SIZE = new Setting('pageSize', RESULTS_DISPLAY_SETTING);
+const CUSTOM_LOG_DIRECTORY_SETTING = new Setting('customLogDirectory', RUNNING_QUERIES_SETTING);

 /** When these settings change, the running query server should be restarted. */
-const QUERY_SERVER_RESTARTING_SETTINGS = [NUMBER_OF_THREADS_SETTING, SAVE_CACHE_SETTING, CACHE_SIZE_SETTING, MEMORY_SETTING, DEBUG_SETTING];
+const QUERY_SERVER_RESTARTING_SETTINGS = [NUMBER_OF_THREADS_SETTING, SAVE_CACHE_SETTING, CACHE_SIZE_SETTING, MEMORY_SETTING, DEBUG_SETTING, CUSTOM_LOG_DIRECTORY_SETTING];

 export interface QueryServerConfig {
  codeQlPath: string;
@@ -99,6 +100,7 @@ export interface QueryServerConfig {
  cacheSize: number;
  queryMemoryMb?: number;
  timeoutSecs: number;
+  customLogDirectory?: string;
  onDidChangeConfiguration?: Event<void>;
 }

@@ -145,7 +147,7 @@ export abstract class ConfigListener extends DisposableObject {

  protected abstract handleDidChangeConfiguration(e: ConfigurationChangeEvent): void;
  private updateConfiguration(): void {
-    this._onDidChangeConfiguration.fire();
+    this._onDidChangeConfiguration.fire(undefined);
  }

  public get onDidChangeConfiguration(): Event<void> {
@@ -187,7 +189,7 @@ export class QueryServerConfigListener extends ConfigListener implements QuerySe
      config.push(distributionManager.onDidChangeDistribution(async () => {
        const codeQlPath = await distributionManager.getCodeQlPathWithoutVersionCheck();
        config._codeQlPath = codeQlPath!;
-        config._onDidChangeConfiguration.fire();
+        config._onDidChangeConfiguration.fire(undefined);
      }));
    }
    return config;
@@ -197,6 +199,10 @@ export class QueryServerConfigListener extends ConfigListener implements QuerySe
    return this._codeQlPath;
  }

+  public get customLogDirectory(): string | undefined {
+    return CUSTOM_LOG_DIRECTORY_SETTING.getValue<string>() || undefined;
+  }
+
  public get numThreads(): number {
    return NUMBER_OF_THREADS_SETTING.getValue<number>();
  }
@@ -220,7 +226,7 @@ export class QueryServerConfigListener extends ConfigListener implements QuerySe
      return undefined;
    }
    if (memory == 0 || typeof (memory) !== 'number') {
-      logger.log(`Ignoring value '${memory}' for setting ${MEMORY_SETTING.qualifiedName}`);
+      void logger.log(`Ignoring value '${memory}' for setting ${MEMORY_SETTING.qualifiedName}`);
      return undefined;
    }
    return memory;
--- a/extensions/ql-vscode/src/contextual/queryResolver.ts
+++ b/extensions/ql-vscode/src/contextual/queryResolver.ts
@@ -37,7 +37,7 @@ export async function resolveQueries(cli: CodeQLCliServer, qlpack: string, keyTy

  const queries = await cli.resolveQueriesInSuite(suiteFile, helpers.getOnDiskWorkspaceFolders());
  if (queries.length === 0) {
-    helpers.showAndLogErrorMessage(
+    void helpers.showAndLogErrorMessage(
      `No ${nameOfKeyType(keyType)} queries (tagged "${tagOfKeyType(keyType)}") could be found in the current library path. \
      Try upgrading the CodeQL libraries. If that doesn't work, then ${nameOfKeyType(keyType)} queries are not yet available \
      for this language.`
--- a/extensions/ql-vscode/src/databaseFetcher.ts
+++ b/extensions/ql-vscode/src/databaseFetcher.ts
@@ -51,8 +51,8 @@ export async function promptImportInternetDatabase(
  );

  if (item) {
-    commands.executeCommand('codeQLDatabases.focus');
-    showAndLogInformationMessage('Database downloaded and imported successfully.');
+    await commands.executeCommand('codeQLDatabases.focus');
+    void showAndLogInformationMessage('Database downloaded and imported successfully.');
  }
  return item;

@@ -91,8 +91,8 @@ export async function promptImportLgtmDatabase(
        token
      );
      if (item) {
-        commands.executeCommand('codeQLDatabases.focus');
-        showAndLogInformationMessage('Database downloaded and imported successfully.');
+        await commands.executeCommand('codeQLDatabases.focus');
+        void showAndLogInformationMessage('Database downloaded and imported successfully.');
      }
      return item;
    }
@@ -125,8 +125,8 @@ export async function importArchiveDatabase(
      token
    );
    if (item) {
-      commands.executeCommand('codeQLDatabases.focus');
-      showAndLogInformationMessage('Database unzipped and imported successfully.');
+      await commands.executeCommand('codeQLDatabases.focus');
+      void showAndLogInformationMessage('Database unzipped and imported successfully.');
    }
    return item;
  } catch (e) {
@@ -433,7 +433,7 @@ export async function convertToDatabaseUrl(lgtmUrl: string) {
      language,
    ].join('/')}`;
  } catch (e) {
-    logger.log(`Error: ${e.message}`);
+    void logger.log(`Error: ${e.message}`);
    throw new Error(`Invalid LGTM URL: ${lgtmUrl}`);
  }
 }
--- a/extensions/ql-vscode/src/databases-ui.ts
+++ b/extensions/ql-vscode/src/databases-ui.ts
@@ -179,7 +179,7 @@ class DatabaseTreeDataProvider extends DisposableObject

  public set sortOrder(newSortOrder: SortOrder) {
    this._sortOrder = newSortOrder;
-    this._onDidChangeTreeData.fire();
+    this._onDidChangeTreeData.fire(undefined);
  }
 }

@@ -234,7 +234,7 @@ export class DatabaseUI extends DisposableObject {
  }

  init() {
-    logger.log('Registering database panel commands.');
+    void logger.log('Registering database panel commands.');
    this.push(
      commandRunnerWithProgress(
        'codeQL.setCurrentDatabase',
@@ -369,20 +369,20 @@ export class DatabaseUI extends DisposableObject {
    try {
      return await this.chooseAndSetDatabase(true, progress, token);
    } catch (e) {
-      showAndLogErrorMessage(e.message);
+      void showAndLogErrorMessage(e.message);
      return undefined;
    }
  };

  handleRemoveOrphanedDatabases = async (): Promise<void> => {
-    logger.log('Removing orphaned databases from workspace storage.');
+    void logger.log('Removing orphaned databases from workspace storage.');
    let dbDirs = undefined;

    if (
      !(await fs.pathExists(this.storagePath)) ||
      !(await fs.stat(this.storagePath)).isDirectory()
    ) {
-      logger.log('Missing or invalid storage directory. Not trying to remove orphaned databases.');
+      void logger.log('Missing or invalid storage directory. Not trying to remove orphaned databases.');
      return;
    }

@@ -403,7 +403,7 @@ export class DatabaseUI extends DisposableObject {
    dbDirs = await asyncFilter(dbDirs, isLikelyDatabaseRoot);

    if (!dbDirs.length) {
-      logger.log('No orphaned databases found.');
+      void logger.log('No orphaned databases found.');
      return;
    }

@@ -412,8 +412,8 @@ export class DatabaseUI extends DisposableObject {
    await Promise.all(
      dbDirs.map(async dbDir => {
        try {
-          logger.log(`Deleting orphaned database '${dbDir}'.`);
-          await fs.rmdir(dbDir, { recursive: true } as any);  // typings doesn't recognize the options argument
+          void logger.log(`Deleting orphaned database '${dbDir}'.`);
+          await fs.remove(dbDir);
        } catch (e) {
          failures.push(`${path.basename(dbDir)}`);
        }
@@ -422,9 +422,8 @@ export class DatabaseUI extends DisposableObject {

    if (failures.length) {
      const dirname = path.dirname(failures[0]);
-      showAndLogErrorMessage(
-        `Failed to delete unused databases (${
-        failures.join(', ')
+      void showAndLogErrorMessage(
+        `Failed to delete unused databases (${failures.join(', ')
        }).\nTo delete unused databases, please remove them manually from the storage folder ${dirname}.`
      );
    }
@@ -438,7 +437,7 @@ export class DatabaseUI extends DisposableObject {
    try {
      return await this.chooseAndSetDatabase(false, progress, token);
    } catch (e) {
-      showAndLogErrorMessage(e.message);
+      void showAndLogErrorMessage(e.message);
      return undefined;
    }
  };
@@ -583,8 +582,7 @@ export class DatabaseUI extends DisposableObject {
    } catch (e) {
      // rethrow and let this be handled by default error handling.
      throw new Error(
-        `Could not set database to ${path.basename(uri.fsPath)}. Reason: ${
-        e.message
+        `Could not set database to ${path.basename(uri.fsPath)}. Reason: ${e.message
        }`
      );
    }
@@ -617,7 +615,7 @@ export class DatabaseUI extends DisposableObject {
    });

    if (newName) {
-      this.databaseManager.renameDatabaseItem(databaseItem, newName);
+      await this.databaseManager.renameDatabaseItem(databaseItem, newName);
    }
  };

--- a/extensions/ql-vscode/src/databases.ts
+++ b/extensions/ql-vscode/src/databases.ts
@@ -115,7 +115,7 @@ async function findDataset(parentDirectory: string): Promise<vscode.Uri> {

  const dbAbsolutePath = path.join(parentDirectory, dbRelativePaths[0]);
  if (dbRelativePaths.length > 1) {
-    showAndLogWarningMessage(`Found multiple dataset directories in database, using '${dbAbsolutePath}'.`);
+    void showAndLogWarningMessage(`Found multiple dataset directories in database, using '${dbAbsolutePath}'.`);
  }

  return vscode.Uri.file(dbAbsolutePath);
@@ -138,7 +138,7 @@ async function findSourceArchive(
    }
  }
  if (!silent) {
-    showAndLogInformationMessage(
+    void showAndLogInformationMessage(
      `Could not find source archive for database '${databasePath}'. Assuming paths are absolute.`
    );
  }
@@ -265,6 +265,11 @@ export interface DatabaseItem {
   */
  belongsToSourceArchiveExplorerUri(uri: vscode.Uri): boolean;

+  /**
+   * Whether the database may be affected by test execution for the given path.
+   */
+  isAffectedByTest(testPath: string): Promise<boolean>;
+
  /**
   * Gets the state of this database, to be persisted in the workspace state.
   */
@@ -470,6 +475,27 @@ export class DatabaseItemImpl implements DatabaseItem {
    return uri.scheme === zipArchiveScheme &&
      decodeSourceArchiveUri(uri).sourceArchiveZipPath === this.sourceArchive.fsPath;
  }
+
+  public async isAffectedByTest(testPath: string): Promise<boolean> {
+    const databasePath = this.databaseUri.fsPath;
+    if (!databasePath.endsWith('.testproj')) {
+      return false;
+    }
+    try {
+      const stats = await fs.stat(testPath);
+      if (stats.isDirectory()) {
+        return !path.relative(testPath, databasePath).startsWith('..');
+      } else {
+        // database for /one/two/three/test.ql is at /one/two/three/three.testproj
+        const testdir = path.dirname(testPath);
+        const testdirbase = path.basename(testdir);
+        return databasePath == path.join(testdir, testdirbase + '.testproj');
+      }
+    } catch {
+      // No information available for test path - assume database is unaffected.
+      return false;
+    }
+  }
 }

 /**
@@ -480,7 +506,7 @@ export class DatabaseItemImpl implements DatabaseItem {
 function eventFired<T>(event: vscode.Event<T>, timeoutMs = 1000): Promise<T | undefined> {
  return new Promise((res, _rej) => {
    const timeout = setTimeout(() => {
-      logger.log(`Waiting for event ${event} timed out after ${timeoutMs}ms`);
+      void logger.log(`Waiting for event ${event} timed out after ${timeoutMs}ms`);
      res(undefined);
      dispose();
    }, timeoutMs);
@@ -517,7 +543,7 @@ export class DatabaseManager extends DisposableObject {
    qs.onDidStartQueryServer(this.reregisterDatabases.bind(this));

    // Let this run async.
-    this.loadPersistedState();
+    void this.loadPersistedState();
  }

  public async openDatabase(
@@ -579,15 +605,15 @@ export class DatabaseManager extends DisposableObject {
      const end = (vscode.workspace.workspaceFolders || []).length;
      const uri = item.getSourceArchiveExplorerUri();
      if (uri === undefined) {
-        logger.log(`Couldn't obtain file explorer uri for ${item.name}`);
+        void logger.log(`Couldn't obtain file explorer uri for ${item.name}`);
      }
      else {
-        logger.log(`Adding workspace folder for ${item.name} source archive at index ${end}`);
+        void logger.log(`Adding workspace folder for ${item.name} source archive at index ${end}`);
        if ((vscode.workspace.workspaceFolders || []).length < 2) {
          // Adding this workspace folder makes the workspace
          // multi-root, which may surprise the user. Let them know
          // we're doing this.
-          vscode.window.showInformationMessage(`Adding workspace folder for source archive of database ${item.name}.`);
+          void vscode.window.showInformationMessage(`Adding workspace folder for source archive of database ${item.name}.`);
        }
        vscode.workspace.updateWorkspaceFolders(end, 0, {
          name: `[${item.name} source archive]`,
@@ -670,7 +696,7 @@ export class DatabaseManager extends DisposableObject {
              await databaseItem.refresh();
              await this.registerDatabase(progress, token, databaseItem);
              if (currentDatabaseUri === database.uri) {
-                this.setCurrentDatabaseItem(databaseItem, true);
+                await this.setCurrentDatabaseItem(databaseItem, true);
              }
            }
            catch (e) {
@@ -680,7 +706,7 @@ export class DatabaseManager extends DisposableObject {
          }
        } catch (e) {
          // database list had an unexpected type - nothing to be done?
-          showAndLogErrorMessage(`Database list loading failed: ${e.message}`);
+          void showAndLogErrorMessage(`Database list loading failed: ${e.message}`);
        }
      });
  }
@@ -737,7 +763,7 @@ export class DatabaseManager extends DisposableObject {
    item: DatabaseItem
  ) {
    this._databaseItems.push(item);
-    this.updatePersistedDatabaseList();
+    await this.updatePersistedDatabaseList();

    // Add this database item to the allow-list
    // Database items reconstituted from persisted state
@@ -754,7 +780,7 @@ export class DatabaseManager extends DisposableObject {

  public async renameDatabaseItem(item: DatabaseItem, newName: string) {
    item.name = newName;
-    this.updatePersistedDatabaseList();
+    await this.updatePersistedDatabaseList();
    this._onDidChangeDatabaseItem.fire({
      // pass undefined so that the entire tree is rebuilt in order to re-sort
      item: undefined,
@@ -774,23 +800,23 @@ export class DatabaseManager extends DisposableObject {
    if (index >= 0) {
      this._databaseItems.splice(index, 1);
    }
-    this.updatePersistedDatabaseList();
+    await this.updatePersistedDatabaseList();

    // Delete folder from workspace, if it is still there
    const folderIndex = (vscode.workspace.workspaceFolders || []).findIndex(
      folder => item.belongsToSourceArchiveExplorerUri(folder.uri)
    );
    if (folderIndex >= 0) {
-      logger.log(`Removing workspace folder at index ${folderIndex}`);
+      void logger.log(`Removing workspace folder at index ${folderIndex}`);
      vscode.workspace.updateWorkspaceFolders(folderIndex, 1);
    }

    // Delete folder from file system only if it is controlled by the extension
    if (this.isExtensionControlledLocation(item.databaseUri)) {
-      logger.log('Deleting database from filesystem.');
+      void logger.log('Deleting database from filesystem.');
      fs.remove(item.databaseUri.fsPath).then(
-        () => logger.log(`Deleted '${item.databaseUri.fsPath}'`),
-        e => logger.log(`Failed to delete '${item.databaseUri.fsPath}'. Reason: ${e.message}`));
+        () => void logger.log(`Deleted '${item.databaseUri.fsPath}'`),
+        e => void logger.log(`Failed to delete '${item.databaseUri.fsPath}'. Reason: ${e.message}`));
    }

    // Remove this database item from the allow-list
@@ -832,12 +858,12 @@ export class DatabaseManager extends DisposableObject {
  }

  private updatePersistedCurrentDatabaseItem(): void {
-    this.ctx.workspaceState.update(CURRENT_DB, this._currentDatabaseItem ?
+    void this.ctx.workspaceState.update(CURRENT_DB, this._currentDatabaseItem ?
      this._currentDatabaseItem.databaseUri.toString(true) : undefined);
  }

-  private updatePersistedDatabaseList(): void {
-    this.ctx.workspaceState.update(DB_LIST, this._databaseItems.map(item => item.getPersistedState()));
+  private async updatePersistedDatabaseList(): Promise<void> {
+    await this.ctx.workspaceState.update(DB_LIST, this._databaseItems.map(item => item.getPersistedState()));
  }

  private isExtensionControlledLocation(uri: vscode.Uri) {
--- a/extensions/ql-vscode/src/discovery.ts
+++ b/extensions/ql-vscode/src/discovery.ts
@@ -59,23 +59,23 @@ export abstract class Discovery<T> extends DisposableObject {
        this.discoveryInProgress = false;
        this.update(results);
      }
-    });
+    })

-    discoveryPromise.catch(err => {
-      logger.log(`${this.name} failed. Reason: ${err.message}`);
-    });
+      .catch(err => {
+        void logger.log(`${this.name} failed. Reason: ${err.message}`);
+      })

-    discoveryPromise.finally(() => {
-      if (this.retry) {
-        // Another refresh request came in while we were still running a previous discovery
-        // operation. Since the discovery results we just computed are now stale, we'll launch
-        // another discovery operation instead of updating.
-        // Note that by doing this inside of `finally`, we will relaunch discovery even if the
-        // initial discovery operation failed.
-        this.retry = false;
-        this.launchDiscovery();
-      }
-    });
+      .finally(() => {
+        if (this.retry) {
+          // Another refresh request came in while we were still running a previous discovery
+          // operation. Since the discovery results we just computed are now stale, we'll launch
+          // another discovery operation instead of updating.
+          // Note that by doing this inside of `finally`, we will relaunch discovery even if the
+          // initial discovery operation failed.
+          this.retry = false;
+          this.launchDiscovery();
+        }
+      });
  }

  /**
--- a/extensions/ql-vscode/src/distribution.ts
+++ b/extensions/ql-vscode/src/distribution.ts
@@ -153,7 +153,7 @@ export class DistributionManager implements DistributionProvider {
    // Check config setting, then extension specific distribution, then PATH.
    if (this.config.customCodeQlPath) {
      if (!await fs.pathExists(this.config.customCodeQlPath)) {
-        showAndLogErrorMessage(`The CodeQL executable path is specified as "${this.config.customCodeQlPath}" ` +
+        void showAndLogErrorMessage(`The CodeQL executable path is specified as "${this.config.customCodeQlPath}" ` +
          'by a configuration setting, but a CodeQL executable could not be found at that path. Please check ' +
          'that a CodeQL executable exists at the specified path or remove the setting.');
        return undefined;
@@ -191,7 +191,7 @@ export class DistributionManager implements DistributionProvider {
          };
        }
      }
-      logger.log('INFO: Could not find CodeQL on path.');
+      void logger.log('INFO: Could not find CodeQL on path.');
    }

    return undefined;
@@ -276,7 +276,7 @@ class ExtensionSpecificDistributionManager {
      try {
        await this.removeDistribution();
      } catch (e) {
-        logger.log('WARNING: Tried to remove corrupted CodeQL CLI at ' +
+        void logger.log('WARNING: Tried to remove corrupted CodeQL CLI at ' +
          `${this.getDistributionStoragePath()} but encountered an error: ${e}.`);
      }
    }
@@ -313,7 +313,7 @@ class ExtensionSpecificDistributionManager {
    progressCallback?: ProgressCallback): Promise<void> {
    await this.downloadDistribution(release, progressCallback);
    // Store the installed release within the global extension state.
-    this.storeInstalledRelease(release);
+    await this.storeInstalledRelease(release);
  }

  private async downloadDistribution(release: Release,
@@ -321,7 +321,7 @@ class ExtensionSpecificDistributionManager {
    try {
      await this.removeDistribution();
    } catch (e) {
-      logger.log(`Tried to clean up old version of CLI at ${this.getDistributionStoragePath()} ` +
+      void logger.log(`Tried to clean up old version of CLI at ${this.getDistributionStoragePath()} ` +
        `but encountered an error: ${e}.`);
    }

@@ -332,7 +332,7 @@ class ExtensionSpecificDistributionManager {
      throw new Error(`Invariant violation: chose a release to install that didn't have ${requiredAssetName}`);
    }
    if (assets.length > 1) {
-      logger.log('WARNING: chose a release with more than one asset to install, found ' +
+      void logger.log('WARNING: chose a release with more than one asset to install, found ' +
        assets.map(asset => asset.name).join(', '));
    }

@@ -345,7 +345,7 @@ class ExtensionSpecificDistributionManager {

      const contentLength = assetStream.headers.get('content-length');
      const totalNumBytes = contentLength ? parseInt(contentLength, 10) : undefined;
-      reportStreamProgress(assetStream.body, 'Downloading CodeQL CLI…', totalNumBytes, progressCallback);
+      reportStreamProgress(assetStream.body, `Downloading CodeQL CLI ${release.name}…`, totalNumBytes, progressCallback);

      await new Promise((resolve, reject) =>
        assetStream.body.pipe(archiveFile)
@@ -355,7 +355,7 @@ class ExtensionSpecificDistributionManager {

      await this.bumpDistributionFolderIndex();

-      logger.log(`Extracting CodeQL CLI to ${this.getDistributionStoragePath()}`);
+      void logger.log(`Extracting CodeQL CLI to ${this.getDistributionStoragePath()}`);
      await extractZipArchive(archivePath, this.getDistributionStoragePath());
    } finally {
      await fs.remove(tmpDirectory);
@@ -368,7 +368,7 @@ class ExtensionSpecificDistributionManager {
   * This should not be called for a distribution that is currently in use, as remove may fail.
   */
  private async removeDistribution(): Promise<void> {
-    this.storeInstalledRelease(undefined);
+    await this.storeInstalledRelease(undefined);
    if (await fs.pathExists(this.getDistributionStoragePath())) {
      await fs.remove(this.getDistributionStoragePath());
    }
@@ -376,7 +376,7 @@ class ExtensionSpecificDistributionManager {

  private async getLatestRelease(): Promise<Release> {
    const requiredAssetName = DistributionManager.getRequiredAssetName();
-    logger.log(`Searching for latest release including ${requiredAssetName}.`);
+    void logger.log(`Searching for latest release including ${requiredAssetName}.`);
    return this.createReleasesApiConsumer().getLatestRelease(
      this.versionRange,
      this.config.includePrerelease,
@@ -384,11 +384,11 @@ class ExtensionSpecificDistributionManager {
        const matchingAssets = release.assets.filter(asset => asset.name === requiredAssetName);
        if (matchingAssets.length === 0) {
          // For example, this could be a release with no platform-specific assets.
-          logger.log(`INFO: Ignoring a release with no assets named ${requiredAssetName}`);
+          void logger.log(`INFO: Ignoring a release with no assets named ${requiredAssetName}`);
          return false;
        }
        if (matchingAssets.length > 1) {
-          logger.log(`WARNING: Ignoring a release with more than one asset named ${requiredAssetName}`);
+          void logger.log(`WARNING: Ignoring a release with more than one asset named ${requiredAssetName}`);
          return false;
        }
        return true;
@@ -707,16 +707,14 @@ export async function getExecutableFromDirectory(directory: string, warnWhenNotF
    return alternateExpectedLauncherPath;
  }
  if (warnWhenNotFound) {
-    logger.log(`WARNING: Expected to find a CodeQL CLI executable at ${expectedLauncherPath} but one was not found. ` +
+    void logger.log(`WARNING: Expected to find a CodeQL CLI executable at ${expectedLauncherPath} but one was not found. ` +
      'Will try PATH.');
  }
  return undefined;
 }

 function warnDeprecatedLauncher() {
-
-  showAndLogWarningMessage(
-
+  void showAndLogWarningMessage(
    `The "${deprecatedCodeQlLauncherName()!}" launcher has been deprecated and will be removed in a future version. ` +
    `Please use "${codeQlLauncherName()}" instead. It is recommended to update to the latest CodeQL binaries.`
  );
--- a/extensions/ql-vscode/src/extension.ts
+++ b/extensions/ql-vscode/src/extension.ts
@@ -148,14 +148,14 @@ export interface CodeQLExtensionInterface {
 *
 * @returns CodeQLExtensionInterface
 */
-export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionInterface | {}> {
-  logger.log(`Starting ${extensionId} extension`);
+export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionInterface | Record<string, never>> {
+  void logger.log(`Starting ${extensionId} extension`);
  if (extension === undefined) {
    throw new Error(`Can't find extension ${extensionId}`);
  }

  const distributionConfigListener = new DistributionConfigListener();
-  initializeLogging(ctx);
+  await initializeLogging(ctx);
  await initializeTelemetry(extension, ctx);
  languageSupport.install();

@@ -166,7 +166,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
  const shouldUpdateOnNextActivationKey = 'shouldUpdateOnNextActivation';

  registerErrorStubs([checkForUpdatesCommand], command => (async () => {
-    helpers.showAndLogErrorMessage(`Can't execute ${command}: waiting to finish loading CodeQL CLI.`);
+    void helpers.showAndLogErrorMessage(`Can't execute ${command}: waiting to finish loading CodeQL CLI.`);
  }));

  interface DistributionUpdateConfig {
@@ -178,7 +178,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
  async function installOrUpdateDistributionWithProgressTitle(progressTitle: string, config: DistributionUpdateConfig): Promise<void> {
    const minSecondsSinceLastUpdateCheck = config.isUserInitiated ? 0 : 86400;
    const noUpdatesLoggingFunc = config.shouldDisplayMessageWhenNoUpdates ?
-      helpers.showAndLogInformationMessage : async (message: string) => logger.log(message);
+      helpers.showAndLogInformationMessage : async (message: string) => void logger.log(message);
    const result = await distributionManager.checkForUpdatesToExtensionManagedDistribution(minSecondsSinceLastUpdateCheck);

    // We do want to auto update if there is no distribution at all
@@ -186,7 +186,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn

    switch (result.kind) {
      case DistributionUpdateCheckResultKind.AlreadyCheckedRecentlyResult:
-        logger.log('Didn\'t perform CodeQL CLI update check since a check was already performed within the previous ' +
+        void logger.log('Didn\'t perform CodeQL CLI update check since a check was already performed within the previous ' +
          `${minSecondsSinceLastUpdateCheck} seconds.`);
        break;
      case DistributionUpdateCheckResultKind.AlreadyUpToDate:
@@ -213,7 +213,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
            distributionManager.installExtensionManagedDistributionRelease(result.updatedRelease, progress));

          await ctx.globalState.update(shouldUpdateOnNextActivationKey, false);
-          helpers.showAndLogInformationMessage(`CodeQL CLI updated to version "${result.updatedRelease.name}".`);
+          void helpers.showAndLogInformationMessage(`CodeQL CLI updated to version "${result.updatedRelease.name}".`);
        }
        break;
      default:
@@ -245,12 +245,12 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
        codeQlInstalled ? 'check for updates to' : 'install') + ' CodeQL CLI';

      if (e instanceof GithubRateLimitedError) {
-        alertFunction(`Rate limited while trying to ${taskDescription}. Please try again after ` +
+        void alertFunction(`Rate limited while trying to ${taskDescription}. Please try again after ` +
          `your rate limit window resets at ${e.rateLimitResetDate.toLocaleString(env.language)}.`);
      } else if (e instanceof GithubApiError) {
-        alertFunction(`Encountered GitHub API error while trying to ${taskDescription}. ` + e);
+        void alertFunction(`Encountered GitHub API error while trying to ${taskDescription}. ` + e);
      }
-      alertFunction(`Unable to ${taskDescription}. ` + e);
+      void alertFunction(`Unable to ${taskDescription}. ` + e);
    } finally {
      isInstallingOrUpdatingDistribution = false;
    }
@@ -260,7 +260,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
    const result = await distributionManager.getDistribution();
    switch (result.kind) {
      case FindDistributionResultKind.CompatibleDistribution:
-        logger.log(`Found compatible version of CodeQL CLI (version ${result.version.raw})`);
+        void logger.log(`Found compatible version of CodeQL CLI (version ${result.version.raw})`);
        break;
      case FindDistributionResultKind.IncompatibleDistribution: {
        const fixGuidanceMessage = (() => {
@@ -275,16 +275,20 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
          }
        })();

-        helpers.showAndLogWarningMessage(`The current version of the CodeQL CLI (${result.version.raw}) ` +
-          'is incompatible with this extension. ' + fixGuidanceMessage);
+        void helpers.showAndLogWarningMessage(
+          `The current version of the CodeQL CLI (${result.version.raw}) ` +
+          `is incompatible with this extension. ${fixGuidanceMessage}`
+        );
        break;
      }
      case FindDistributionResultKind.UnknownCompatibilityDistribution:
-        helpers.showAndLogWarningMessage('Compatibility with the configured CodeQL CLI could not be determined. ' +
-          'You may experience problems using the extension.');
+        void helpers.showAndLogWarningMessage(
+          'Compatibility with the configured CodeQL CLI could not be determined. ' +
+          'You may experience problems using the extension.'
+        );
        break;
      case FindDistributionResultKind.NoDistribution:
-        helpers.showAndLogErrorMessage('The CodeQL CLI could not be found.');
+        void helpers.showAndLogErrorMessage('The CodeQL CLI could not be found.');
        break;
      default:
        assertNever(result);
@@ -294,13 +298,13 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn

  async function installOrUpdateThenTryActivate(
    config: DistributionUpdateConfig
-  ): Promise<CodeQLExtensionInterface | {}> {
+  ): Promise<CodeQLExtensionInterface | Record<string, never>> {

    await installOrUpdateDistribution(config);

    // Display the warnings even if the extension has already activated.
    const distributionResult = await getDistributionDisplayingDistributionWarnings();
-    let extensionInterface: CodeQLExtensionInterface | {} = {};
+    let extensionInterface: CodeQLExtensionInterface | Record<string, never> = {};
    if (!beganMainExtensionActivation && distributionResult.kind !== FindDistributionResultKind.NoDistribution) {
      extensionInterface = await activateWithInstalledDistribution(
        ctx,
@@ -311,7 +315,7 @@ export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionIn
    } else if (distributionResult.kind === FindDistributionResultKind.NoDistribution) {
      registerErrorStubs([checkForUpdatesCommand], command => async () => {
        const installActionName = 'Install CodeQL CLI';
-        const chosenAction = await helpers.showAndLogErrorMessage(`Can't execute ${command}: missing CodeQL CLI.`, {
+        const chosenAction = await void helpers.showAndLogErrorMessage(`Can't execute ${command}: missing CodeQL CLI.`, {
          items: [installActionName]
        });
        if (chosenAction === installActionName) {
@@ -357,13 +361,13 @@ async function activateWithInstalledDistribution(
  // of activation.
  errorStubs.forEach((stub) => stub.dispose());

-  logger.log('Initializing configuration listener...');
+  void logger.log('Initializing configuration listener...');
  const qlConfigurationListener = await QueryServerConfigListener.createQueryServerConfigListener(
    distributionManager
  );
  ctx.subscriptions.push(qlConfigurationListener);

-  logger.log('Initializing CodeQL cli server...');
+  void logger.log('Initializing CodeQL cli server...');
  const cliServer = new CodeQLCliServer(
    distributionManager,
    new CliConfigListener(),
@@ -374,12 +378,13 @@ async function activateWithInstalledDistribution(
  const statusBar = new CodeQlStatusBarHandler(cliServer, distributionConfigListener);
  ctx.subscriptions.push(statusBar);

-  logger.log('Initializing query server client.');
+  void logger.log('Initializing query server client.');
  const qs = new qsClient.QueryServerClient(
    qlConfigurationListener,
    cliServer,
    {
      logger: queryServerLogger,
+      contextStoragePath: getContextStoragePath(ctx),
    },
    (task) =>
      Window.withProgress(
@@ -390,10 +395,10 @@ async function activateWithInstalledDistribution(
  ctx.subscriptions.push(qs);
  await qs.startQueryServer();

-  logger.log('Initializing database manager.');
+  void logger.log('Initializing database manager.');
  const dbm = new DatabaseManager(ctx, qs, cliServer, logger);
  ctx.subscriptions.push(dbm);
-  logger.log('Initializing database panel.');
+  void logger.log('Initializing database panel.');
  const databaseUI = new DatabaseUI(
    dbm,
    qs,
@@ -403,7 +408,7 @@ async function activateWithInstalledDistribution(
  databaseUI.init();
  ctx.subscriptions.push(databaseUI);

-  logger.log('Initializing query history manager.');
+  void logger.log('Initializing query history manager.');
  const queryHistoryConfigurationListener = new QueryHistoryConfigListener();
  ctx.subscriptions.push(queryHistoryConfigurationListener);
  const showResults = async (item: CompletedQuery) =>
@@ -418,11 +423,11 @@ async function activateWithInstalledDistribution(
      showResultsForComparison(from, to),
  );
  ctx.subscriptions.push(qhm);
-  logger.log('Initializing results panel interface.');
+  void logger.log('Initializing results panel interface.');
  const intm = new InterfaceManager(ctx, dbm, cliServer, queryServerLogger);
  ctx.subscriptions.push(intm);

-  logger.log('Initializing compare panel interface.');
+  void logger.log('Initializing compare panel interface.');
  const cmpm = new CompareInterfaceManager(
    ctx,
    dbm,
@@ -432,7 +437,7 @@ async function activateWithInstalledDistribution(
  );
  ctx.subscriptions.push(cmpm);

-  logger.log('Initializing source archive filesystem provider.');
+  void logger.log('Initializing source archive filesystem provider.');
  archiveFilesystemProvider.activate(ctx);

  async function showResultsForComparison(
@@ -442,7 +447,7 @@ async function activateWithInstalledDistribution(
    try {
      await cmpm.showResults(from, to);
    } catch (e) {
-      helpers.showAndLogErrorMessage(e.message);
+      void helpers.showAndLogErrorMessage(e.message);
    }
  }

@@ -490,11 +495,10 @@ async function activateWithInstalledDistribution(
        const uri = Uri.file(resolved.resolvedPath);
        await window.showTextDocument(uri, { preview: false });
      } else {
-        helpers.showAndLogErrorMessage(
+        void helpers.showAndLogErrorMessage(
          'Jumping from a .qlref file to the .ql file it references is not '
          + 'supported with the CLI version you are running.\n'
-          + `Please upgrade your CLI to version ${
-          CliVersionConstraint.CLI_VERSION_WITH_RESOLVE_QLREF
+          + `Please upgrade your CLI to version ${CliVersionConstraint.CLI_VERSION_WITH_RESOLVE_QLREF
          } or later to use this feature.`);
      }
    }
@@ -502,7 +506,7 @@ async function activateWithInstalledDistribution(

  ctx.subscriptions.push(tmpDirDisposal);

-  logger.log('Initializing CodeQL language server.');
+  void logger.log('Initializing CodeQL language server.');
  const client = new LanguageClient(
    'CodeQL Language Server',
    () => spawnIdeServer(qlConfigurationListener),
@@ -520,20 +524,20 @@ async function activateWithInstalledDistribution(
    true
  );

-  logger.log('Initializing QLTest interface.');
+  void logger.log('Initializing QLTest interface.');
  const testExplorerExtension = extensions.getExtension<TestHub>(
    testExplorerExtensionId
  );
  if (testExplorerExtension) {
    const testHub = testExplorerExtension.exports;
-    const testAdapterFactory = new QLTestAdapterFactory(testHub, cliServer);
+    const testAdapterFactory = new QLTestAdapterFactory(testHub, cliServer, dbm);
    ctx.subscriptions.push(testAdapterFactory);

    const testUIService = new TestUIService(testHub);
    ctx.subscriptions.push(testUIService);
  }

-  logger.log('Registering top-level command palette commands.');
+  void logger.log('Registering top-level command palette commands.');
  ctx.subscriptions.push(
    commandRunnerWithProgress(
      'codeQL.runQuery',
@@ -649,7 +653,7 @@ async function activateWithInstalledDistribution(
      token: CancellationToken
    ) => {
      await qs.restartQueryServer(progress, token);
-      helpers.showAndLogInformationMessage('CodeQL Query Server restarted.', {
+      void helpers.showAndLogInformationMessage('CodeQL Query Server restarted.', {
        outputLogger: queryServerLogger,
      });
    }, {
@@ -704,16 +708,16 @@ async function activateWithInstalledDistribution(
  ctx.subscriptions.push(
    commandRunner('codeQL.copyVersion', async () => {
      const text = `CodeQL extension version: ${extension?.packageJSON.version} \nCodeQL CLI version: ${await cliServer.getVersion()} \nPlatform: ${os.platform()} ${os.arch()}`;
-      env.clipboard.writeText(text);
-      helpers.showAndLogInformationMessage(text);
+      await env.clipboard.writeText(text);
+      void helpers.showAndLogInformationMessage(text);
    }));


-  logger.log('Starting language server.');
+  void logger.log('Starting language server.');
  ctx.subscriptions.push(client.start());

  // Jump-to-definition and find-references
-  logger.log('Registering jump-to-definition handlers.');
+  void logger.log('Registering jump-to-definition handlers.');
  languages.registerDefinitionProvider(
    { scheme: archiveFilesystemProvider.zipArchiveScheme },
    new TemplateQueryDefinitionProvider(cliServer, qs, dbm)
@@ -745,9 +749,9 @@ async function activateWithInstalledDistribution(
    title: 'Calculate AST'
  }));

-  commands.executeCommand('codeQLDatabases.removeOrphanedDatabases');
+  await commands.executeCommand('codeQLDatabases.removeOrphanedDatabases');

-  logger.log('Successfully finished extension initialization.');
+  void logger.log('Successfully finished extension initialization.');

  return {
    ctx,
@@ -766,11 +770,10 @@ function getContextStoragePath(ctx: ExtensionContext) {
  return ctx.storagePath || ctx.globalStoragePath;
 }

-function initializeLogging(ctx: ExtensionContext): void {
+async function initializeLogging(ctx: ExtensionContext): Promise<void> {
  const storagePath = getContextStoragePath(ctx);
-  logger.init(storagePath);
-  queryServerLogger.init(storagePath);
-  ideServerLogger.init(storagePath);
+  await logger.setLogStoragePath(storagePath, false);
+  await ideServerLogger.setLogStoragePath(storagePath, false);
  ctx.subscriptions.push(logger);
  ctx.subscriptions.push(queryServerLogger);
  ctx.subscriptions.push(ideServerLogger);
--- a/extensions/ql-vscode/src/helpers.ts
+++ b/extensions/ql-vscode/src/helpers.ts
@@ -77,7 +77,7 @@ async function internalShowAndLog(
  fullMessage?: string
 ): Promise<string | undefined> {
  const label = 'Show Log';
-  outputLogger.log(fullMessage || message);
+  void outputLogger.log(fullMessage || message);
  const result = await fn(message, label, ...items);
  if (result === label) {
    outputLogger.show();
@@ -259,11 +259,11 @@ export async function getQlPackForDbscheme(cliServer: CodeQLCliServer, dbschemeP
  const packs: { packDir: string | undefined; packName: string }[] =
    Object.entries(qlpacks).map(([packName, dirs]) => {
      if (dirs.length < 1) {
-        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has no directories`);
+        void logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has no directories`);
        return { packName, packDir: undefined };
      }
      if (dirs.length > 1) {
-        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has more than one directory; arbitrarily choosing the first`);
+        void logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has more than one directory; arbitrarily choosing the first`);
      }
      return {
        packName,
@@ -292,7 +292,7 @@ export async function getPrimaryDbscheme(datasetFolder: string): Promise<string>
  const dbscheme = dbschemes[0];

  if (dbschemes.length > 1) {
-    Window.showErrorMessage(`Found multiple dbschemes in ${datasetFolder} during quick query; arbitrarily choosing the first, ${dbscheme}, to decide what library to use.`);
+    void Window.showErrorMessage(`Found multiple dbschemes in ${datasetFolder} during quick query; arbitrarily choosing the first, ${dbscheme}, to decide what library to use.`);
  }
  return dbscheme;
 }
--- a/extensions/ql-vscode/src/interface-utils.ts
+++ b/extensions/ql-vscode/src/interface-utils.ts
@@ -224,14 +224,14 @@ export async function jumpToLocation(
    } catch (e) {
      if (e instanceof Error) {
        if (e.message.match(/File not found/)) {
-          Window.showErrorMessage(
+          void Window.showErrorMessage(
            'Original file of this result is not in the database\'s source archive.'
          );
        } else {
-          logger.log(`Unable to handleMsgFromView: ${e.message}`);
+          void logger.log(`Unable to handleMsgFromView: ${e.message}`);
        }
      } else {
-        logger.log(`Unable to handleMsgFromView: ${e}`);
+        void logger.log(`Unable to handleMsgFromView: ${e}`);
      }
    }
  }
--- a/extensions/ql-vscode/src/interface.ts
+++ b/extensions/ql-vscode/src/interface.ts
@@ -119,7 +119,7 @@ export class InterfaceManager extends DisposableObject {
        this.handleSelectionChange.bind(this)
      )
    );
-    logger.log('Registering path-step navigation commands.');
+    void logger.log('Registering path-step navigation commands.');
    this.push(
      commandRunner(
        'codeQLQueryResults.nextPathStep',
@@ -138,7 +138,7 @@ export class InterfaceManager extends DisposableObject {
        if (kind === DatabaseEventKind.Remove) {
          this._diagnosticCollection.clear();
          if (this.isShowingPanel()) {
-            this.postMessage({
+            void this.postMessage({
              t: 'untoggleShowProblems'
            });
          }
@@ -148,7 +148,7 @@ export class InterfaceManager extends DisposableObject {
  }

  async navigatePathStep(direction: number): Promise<void> {
-    this.postMessage({ t: 'navigatePath', direction });
+    await this.postMessage({ t: 'navigatePath', direction });
  }

  private isShowingPanel() {
@@ -207,14 +207,14 @@ export class InterfaceManager extends DisposableObject {
    sortState: InterpretedResultsSortState | undefined
  ): Promise<void> {
    if (this._displayedQuery === undefined) {
-      showAndLogErrorMessage(
+      void showAndLogErrorMessage(
        'Failed to sort results since evaluation info was unknown.'
      );
      return;
    }
    // Notify the webview that it should expect new results.
    await this.postMessage({ t: 'resultsUpdating' });
-    this._displayedQuery.updateInterpretedSortState(sortState);
+    await this._displayedQuery.updateInterpretedSortState(sortState);
    await this.showResults(this._displayedQuery, WebviewReveal.NotForced, true);
  }

@@ -223,7 +223,7 @@ export class InterfaceManager extends DisposableObject {
    sortState: RawResultsSortState | undefined
  ): Promise<void> {
    if (this._displayedQuery === undefined) {
-      showAndLogErrorMessage(
+      void showAndLogErrorMessage(
        'Failed to sort results since evaluation info was unknown.'
      );
      return;
@@ -301,7 +301,7 @@ export class InterfaceManager extends DisposableObject {
          assertNever(msg);
      }
    } catch (e) {
-      showAndLogErrorMessage(e.message, {
+      void showAndLogErrorMessage(e.message, {
        fullMessage: e.stack
      });
    }
@@ -372,7 +372,7 @@ export class InterfaceManager extends DisposableObject {
      );
      // Address this click asynchronously so we still update the
      // query history immediately.
-      resultPromise.then((result) => {
+      void resultPromise.then((result) => {
        if (result === showButton) {
          panel.reveal();
        }
@@ -556,7 +556,7 @@ export class InterfaceManager extends DisposableObject {
    sortState: InterpretedResultsSortState | undefined
  ): Promise<Interpretation | undefined> {
    if (!resultsPaths) {
-      this.logger.log('No results path. Cannot display interpreted results.');
+      void this.logger.log('No results path. Cannot display interpreted results.');
      return undefined;
    }

@@ -603,7 +603,7 @@ export class InterfaceManager extends DisposableObject {
      throw new Error('Tried to get interpreted results before interpretation finished');
    }
    if (this._interpretation.sarif.runs.length !== 1) {
-      this.logger.log(`Warning: SARIF file had ${this._interpretation.sarif.runs.length} runs, expected 1`);
+      void this.logger.log(`Warning: SARIF file had ${this._interpretation.sarif.runs.length} runs, expected 1`);
    }
    const interp = this._interpretation;
    return {
@@ -642,7 +642,7 @@ export class InterfaceManager extends DisposableObject {
      } catch (e) {
        // If interpretation fails, accept the error and continue
        // trying to render uninterpreted results anyway.
-        showAndLogErrorMessage(
+        void showAndLogErrorMessage(
          `Showing raw results instead of interpreted ones due to an error. ${e.message}`
        );
      }
@@ -683,7 +683,7 @@ export class InterfaceManager extends DisposableObject {
      await this.showProblemResultsAsDiagnostics(interpretation, database);
    } catch (e) {
      const msg = e instanceof Error ? e.message : e.toString();
-      this.logger.log(
+      void this.logger.log(
        `Exception while computing problem results as diagnostics: ${msg}`
      );
      this._diagnosticCollection.clear();
@@ -697,7 +697,7 @@ export class InterfaceManager extends DisposableObject {
    const { sarif, sourceLocationPrefix } = interpretation;

    if (!sarif.runs || !sarif.runs[0].results) {
-      this.logger.log(
+      void this.logger.log(
        'Didn\'t find a run in the sarif results. Error processing sarif?'
      );
      return;
@@ -708,11 +708,11 @@ export class InterfaceManager extends DisposableObject {
    for (const result of sarif.runs[0].results) {
      const message = result.message.text;
      if (message === undefined) {
-        this.logger.log('Sarif had result without plaintext message');
+        void this.logger.log('Sarif had result without plaintext message');
        continue;
      }
      if (!result.locations) {
-        this.logger.log('Sarif had result without location');
+        void this.logger.log('Sarif had result without location');
        continue;
      }

@@ -725,7 +725,7 @@ export class InterfaceManager extends DisposableObject {
      }
      const resultLocation = tryResolveLocation(sarifLoc, databaseItem);
      if (!resultLocation) {
-        this.logger.log('Sarif location was not resolvable ' + sarifLoc);
+        void this.logger.log('Sarif location was not resolvable ' + sarifLoc);
        continue;
      }
      const parsedMessage = parseSarifPlainTextMessage(message);
--- a/extensions/ql-vscode/src/logging.ts
+++ b/extensions/ql-vscode/src/logging.ts
@@ -28,9 +28,16 @@ export interface Logger {
  removeAdditionalLogLocation(location: string | undefined): void;

  /**
-   * The base location location where all side log files are stored.
+   * The base location where all side log files are stored.
   */
  getBaseLocation(): string | undefined;
+
+  /**
+   * Sets the location where logs are stored.
+   * @param storagePath The path where logs are stored.
+   * @param isCustomLogDirectory Whether the logs are stored in a custom, user-specified directory.
+   */
+  setLogStoragePath(storagePath: string, isCustomLogDirectory: boolean): Promise<void>;
 }

 export type ProgressReporter = Progress<{ message: string }>;
@@ -40,18 +47,24 @@ export class OutputChannelLogger extends DisposableObject implements Logger {
  public readonly outputChannel: OutputChannel;
  private readonly additionalLocations = new Map<string, AdditionalLogLocation>();
  private additionalLogLocationPath: string | undefined;
+  isCustomLogDirectory: boolean;

  constructor(private title: string) {
    super();
    this.outputChannel = Window.createOutputChannel(title);
    this.push(this.outputChannel);
+    this.isCustomLogDirectory = false;
  }

-  init(storagePath: string): void {
+  async setLogStoragePath(storagePath: string, isCustomLogDirectory: boolean): Promise<void> {
    this.additionalLogLocationPath = path.join(storagePath, this.title);

-    // clear out any old state from previous runs
-    fs.remove(this.additionalLogLocationPath);
+    this.isCustomLogDirectory = isCustomLogDirectory;
+
+    if (!this.isCustomLogDirectory) {
+      // clear out any old state from previous runs
+      await fs.remove(this.additionalLogLocationPath);
+    }
  }

  /**
@@ -80,7 +93,7 @@ export class OutputChannelLogger extends DisposableObject implements Logger {
        this.outputChannel.appendLine(separator);
        this.outputChannel.appendLine(msg);
        this.outputChannel.appendLine(separator);
-        additional = new AdditionalLogLocation(logPath);
+        additional = new AdditionalLogLocation(logPath, !this.isCustomLogDirectory);
        this.additionalLocations.set(logPath, additional);
        this.track(additional);
      }
@@ -112,7 +125,7 @@ export class OutputChannelLogger extends DisposableObject implements Logger {
 }

 class AdditionalLogLocation extends Disposable {
-  constructor(private location: string) {
+  constructor(private location: string, private shouldDeleteLogs: boolean) {
    super(() => { /**/ });
  }

@@ -128,7 +141,9 @@ class AdditionalLogLocation extends Disposable {
  }

  async dispose(): Promise<void> {
-    await fs.remove(this.location);
+    if (this.shouldDeleteLogs) {
+      await fs.remove(this.location);
+    }
  }
 }

--- a/extensions/ql-vscode/src/pure/messages.ts
+++ b/extensions/ql-vscode/src/pure/messages.ts
@@ -262,7 +262,7 @@ export interface CompilationTarget {
  /**
   * Compile as a normal query
   */
-  query?: {};
+  query?: Record<string, never>;
  /**
   * Compile as a quick evaluation
   */
@@ -826,7 +826,7 @@ export interface ResultSet {
 /**
 * The type returned when the evaluation is complete
 */
-export type EvaluationComplete = {};
+export type EvaluationComplete = Record<string, never>;

 /**
 * The result of a single query
--- a/extensions/ql-vscode/src/qltest-discovery.ts
+++ b/extensions/ql-vscode/src/qltest-discovery.ts
@@ -172,7 +172,7 @@ export class QLTestDiscovery extends Discovery<QLTestDiscoveryResults> {
    this.watcher.addWatch(new RelativePattern(results.watchPath, '**/*.{ql,qlref}'));
    // need to explicitly watch for changes to directories themselves.
    this.watcher.addWatch(new RelativePattern(results.watchPath, '**/'));
-    this._onDidChangeTests.fire();
+    this._onDidChangeTests.fire(undefined);
  }

  /**
--- a/extensions/ql-vscode/src/query-history.ts
+++ b/extensions/ql-vscode/src/query-history.ts
@@ -193,7 +193,7 @@ export class HistoryTreeDataProvider extends DisposableObject {

  public set sortOrder(newSortOrder: SortOrder) {
    this._sortOrder = newSortOrder;
-    this._onDidChangeTreeData.fire();
+    this._onDidChangeTreeData.fire(undefined);
  }
 }

@@ -249,7 +249,7 @@ export class QueryHistoryManager extends DisposableObject {
      })
    );

-    logger.log('Registering query history panel commands.');
+    void logger.log('Registering query history panel commands.');
    this.push(
      commandRunner(
        'codeQLQueryHistory.openQuery',
@@ -402,7 +402,7 @@ export class QueryHistoryManager extends DisposableObject {
    });
    const current = this.treeDataProvider.getCurrent();
    if (current !== undefined) {
-      this.treeView.reveal(current);
+      await this.treeView.reveal(current);
      await this.invokeCallbackOn(current);
    }
  }
@@ -470,10 +470,10 @@ export class QueryHistoryManager extends DisposableObject {
      const to = await this.findOtherQueryToCompare(from, multiSelect);

      if (from && to) {
-        this.doCompareCallback(from, to);
+        await this.doCompareCallback(from, to);
      }
    } catch (e) {
-      showAndLogErrorMessage(e.message);
+      void showAndLogErrorMessage(e.message);
    }
  }

@@ -520,7 +520,7 @@ export class QueryHistoryManager extends DisposableObject {
    if (singleItem.logFileLocation) {
      await this.tryOpenExternalFile(singleItem.logFileLocation);
    } else {
-      showAndLogWarningMessage('No log file available');
+      void showAndLogWarningMessage('No log file available');
    }
  }

@@ -565,7 +565,7 @@ export class QueryHistoryManager extends DisposableObject {
      );
    } else {
      const label = singleItem.getLabel();
-      showAndLogInformationMessage(
+      void showAndLogInformationMessage(
        `Query ${label} has no interpreted results.`
      );
    }
@@ -644,7 +644,7 @@ export class QueryHistoryManager extends DisposableObject {
        // We must fire the onDidChangeTreeData event to ensure the current element can be selected
        // using `reveal` if the tree view was not visible when the current element was added.
        this.treeDataProvider.refresh();
-        this.treeView.reveal(current);
+        void this.treeView.reveal(current);
      }
    }
  }
@@ -671,13 +671,13 @@ the file in the file explorer and dragging it into the workspace.`
          try {
            await vscode.commands.executeCommand('revealFileInOS', uri);
          } catch (e) {
-            showAndLogErrorMessage(e.message);
+            void showAndLogErrorMessage(e.message);
          }
        }
      } else {
-        showAndLogErrorMessage(`Could not open file ${fileLocation}`);
-        logger.log(e.message);
-        logger.log(e.stack);
+        void showAndLogErrorMessage(`Could not open file ${fileLocation}`);
+        void logger.log(e.message);
+        void logger.log(e.stack);
      }
    }
  }
@@ -729,7 +729,7 @@ the file in the file explorer and dragging it into the workspace.`

  private assertSingleQuery(multiSelect: CompletedQuery[] = [], message = 'Please select a single query.') {
    if (multiSelect.length > 1) {
-      showAndLogErrorMessage(
+      void showAndLogErrorMessage(
        message
      );
      return false;
@@ -797,4 +797,3 @@ the file in the file explorer and dragging it into the workspace.`
    this.treeDataProvider.refresh(completedQuery);
  }
 }
-
--- a/extensions/ql-vscode/src/queryserver-client.ts
+++ b/extensions/ql-vscode/src/queryserver-client.ts
@@ -9,9 +9,12 @@ import { Logger, ProgressReporter } from './logging';
 import { completeQuery, EvaluationResult, progress, ProgressMessage, WithProgressId } from './pure/messages';
 import * as messages from './pure/messages';
 import { ProgressCallback, ProgressTask } from './commandRunner';
+import * as fs from 'fs-extra';
+import * as helpers from './helpers';

 type ServerOpts = {
  logger: Logger;
+  contextStoragePath: string;
 }

 /** A running query server process and its associated message connection. */
@@ -27,7 +30,7 @@ class ServerProcess implements Disposable {
  }

  dispose(): void {
-    this.logger.log('Stopping query server...');
+    void this.logger.log('Stopping query server...');
    this.connection.dispose();
    this.child.stdin!.end();
    this.child.stderr!.destroy();
@@ -35,7 +38,7 @@ class ServerProcess implements Disposable {

    // On Windows, we usually have to terminate the process before closing its stdout.
    this.child.stdout!.destroy();
-    this.logger.log('Stopped query server.');
+    void this.logger.log('Stopped query server.');
  }
 }

@@ -86,6 +89,26 @@ export class QueryServerClient extends DisposableObject {
    this.evaluationResultCallbacks = {};
  }

+  async initLogger() {
+    let storagePath = this.opts.contextStoragePath;
+    let isCustomLogDirectory = false;
+    if (this.config.customLogDirectory) {
+      try {
+        if (!(await fs.pathExists(this.config.customLogDirectory))) {
+          await fs.mkdir(this.config.customLogDirectory);
+        }
+        void this.logger.log(`Saving query server logs to user-specified directory: ${this.config.customLogDirectory}.`);
+        storagePath = this.config.customLogDirectory;
+        isCustomLogDirectory = true;
+      } catch (e) {
+        void helpers.showAndLogErrorMessage(`${this.config.customLogDirectory} is not a valid directory. Logs will be stored in a temporary workspace directory instead.`);
+      }
+    }
+
+    await this.logger.setLogStoragePath(storagePath, isCustomLogDirectory);
+
+  }
+
  get logger(): Logger {
    return this.opts.logger;
  }
@@ -95,7 +118,7 @@ export class QueryServerClient extends DisposableObject {
    if (this.serverProcess !== undefined) {
      this.disposeAndStopTracking(this.serverProcess);
    } else {
-      this.logger.log('No server process to be stopped.');
+      void this.logger.log('No server process to be stopped.');
    }
  }

@@ -127,6 +150,7 @@ export class QueryServerClient extends DisposableObject {

  /** Starts a new query server process, sending progress messages to the given reporter. */
  private async startQueryServerImpl(progressReporter: ProgressReporter): Promise<void> {
+    await this.initLogger();
    const ramArgs = await this.cliServer.resolveRam(this.config.queryMemoryMb, progressReporter);
    const args = ['--threads', this.config.numThreads.toString()].concat(ramArgs);

@@ -168,9 +192,8 @@ export class QueryServerClient extends DisposableObject {
    const connection = createMessageConnection(child.stdout, child.stdin);
    connection.onRequest(completeQuery, res => {
      if (!(res.runId in this.evaluationResultCallbacks)) {
-        this.logger.log(`No callback associated with run id ${res.runId}, continuing without executing any callback`);
-      }
-      else {
+        void this.logger.log(`No callback associated with run id ${res.runId}, continuing without executing any callback`);
+      } else {
        const baseLocation = this.logger.getBaseLocation();
        if (baseLocation && this.activeQueryName) {
          res.logFileLocation = path.join(baseLocation, this.activeQueryName);
@@ -185,7 +208,7 @@ export class QueryServerClient extends DisposableObject {
        callback(res);
      }
    });
-    this.serverProcess = new ServerProcess(child, connection, this.opts.logger);
+    this.serverProcess = new ServerProcess(child, connection, this.logger);
    // Ensure the server process is disposed together with this client.
    this.track(this.serverProcess);
    connection.listen();
--- a/extensions/ql-vscode/src/run-queries.ts
+++ b/extensions/ql-vscode/src/run-queries.ts
@@ -156,7 +156,7 @@ export class QueryInfo {

      compiled = await qs.sendRequest(messages.compileQuery, params, token, progress);
    } finally {
-      qs.logger.log(' - - - COMPILATION DONE - - - ');
+      void qs.logger.log(' - - - COMPILATION DONE - - - ');
    }
    return (compiled?.messages || []).filter(msg => msg.severity === messages.Severity.ERROR);
  }
@@ -167,12 +167,12 @@ export class QueryInfo {
  async canHaveInterpretedResults(): Promise<boolean> {
    const hasMetadataFile = await this.dbItem.hasMetadataFile();
    if (!hasMetadataFile) {
-      logger.log('Cannot produce interpreted results since the database does not have a .dbinfo or codeql-database.yml file.');
+      void logger.log('Cannot produce interpreted results since the database does not have a .dbinfo or codeql-database.yml file.');
    }

    const hasKind = !!this.metadata?.kind;
    if (!hasKind) {
-      logger.log('Cannot produce interpreted results since the query does not have @kind metadata.');
+      void logger.log('Cannot produce interpreted results since the query does not have @kind metadata.');
    }

    const isTable = hasKind && this.metadata?.kind === 'table';
@@ -499,7 +499,7 @@ export async function determineSelectedQuery(selectedResourceUri: Uri | undefine
  // then prompt the user to save it first.
  if (editor !== undefined && editor.document.uri.fsPath === queryPath) {
    if (await promptUserToSaveChanges(editor.document)) {
-      editor.document.save();
+      void editor.document.save();
    }
  }

@@ -562,7 +562,7 @@ export async function compileAndRunQueryAgainstDatabase(
  const querySchemaName = path.basename(packConfig.dbscheme);
  const dbSchemaName = path.basename(db.contents.dbSchemeUri.fsPath);
  if (querySchemaName != dbSchemaName) {
-    logger.log(`Query schema was ${querySchemaName}, but database schema was ${dbSchemaName}.`);
+    void logger.log(`Query schema was ${querySchemaName}, but database schema was ${dbSchemaName}.`);
    throw new Error(`The query ${path.basename(queryPath)} cannot be run against the selected database: their target languages are different. Please select a different database and try again.`);
  }

@@ -584,7 +584,7 @@ export async function compileAndRunQueryAgainstDatabase(
    metadata = await cliServer.resolveMetadata(qlProgram.queryPath);
  } catch (e) {
    // Ignore errors and provide no metadata.
-    logger.log(`Couldn't resolve metadata for ${qlProgram.queryPath}: ${e}`);
+    void logger.log(`Couldn't resolve metadata for ${qlProgram.queryPath}: ${e}`);
  }

  const query = new QueryInfo(qlProgram, db, packConfig.dbscheme, quickEvalPosition, metadata, templates);
@@ -612,8 +612,8 @@ export async function compileAndRunQueryAgainstDatabase(
      const result = await query.run(qs, upgradeQlo, progress, token);
      if (result.resultType !== messages.QueryResultType.SUCCESS) {
        const message = result.message || 'Failed to run query';
-        logger.log(message);
-        showAndLogErrorMessage(message);
+        void logger.log(message);
+        void showAndLogErrorMessage(message);
      }
      return {
        query,
@@ -633,7 +633,7 @@ export async function compileAndRunQueryAgainstDatabase(
      // so we include a general description of the problem,
      // and direct the user to the output window for the detailed compilation messages.
      // However we don't show quick eval errors there so we need to display them anyway.
-      qs.logger.log(`Failed to compile query ${query.program.queryPath} against database scheme ${query.program.dbschemePath}:`);
+      void qs.logger.log(`Failed to compile query ${query.program.queryPath} against database scheme ${query.program.dbschemePath}:`);

      const formattedMessages: string[] = [];

@@ -641,24 +641,24 @@ export async function compileAndRunQueryAgainstDatabase(
        const message = error.message || '[no error message available]';
        const formatted = `ERROR: ${message} (${error.position.fileName}:${error.position.line}:${error.position.column}:${error.position.endLine}:${error.position.endColumn})`;
        formattedMessages.push(formatted);
-        qs.logger.log(formatted);
+        void qs.logger.log(formatted);
      }
      if (quickEval && formattedMessages.length <= 2) {
        // If there are more than 2 error messages, they will not be displayed well in a popup
        // and will be trimmed by the function displaying the error popup. Accordingly, we only
        // try to show the errors if there are 2 or less, otherwise we direct the user to the log.
-        showAndLogErrorMessage('Quick evaluation compilation failed: ' + formattedMessages.join('\n'));
+        void showAndLogErrorMessage('Quick evaluation compilation failed: ' + formattedMessages.join('\n'));
      } else {
-        showAndLogErrorMessage((quickEval ? 'Quick evaluation' : 'Query') + compilationFailedErrorTail);
+        void showAndLogErrorMessage((quickEval ? 'Quick evaluation' : 'Query') + compilationFailedErrorTail);
      }

      return createSyntheticResult(query, db, historyItemOptions, 'Query had compilation errors', messages.QueryResultType.OTHER_ERROR);
    }
  } finally {
    try {
-      upgradeDir.cleanup();
+      await upgradeDir.cleanup();
    } catch (e) {
-      qs.logger.log(`Could not clean up the upgrades dir. Reason: ${e.message || e}`);
+      void qs.logger.log(`Could not clean up the upgrades dir. Reason: ${e.message || e}`);
    }
  }
 }
--- a/extensions/ql-vscode/src/status-bar.ts
+++ b/extensions/ql-vscode/src/status-bar.ts
@@ -20,7 +20,7 @@ export class CodeQlStatusBarHandler extends DisposableObject {
    this.push(workspace.onDidChangeConfiguration(this.handleDidChangeConfiguration, this));
    this.push(distributionConfigListener.onDidChangeConfiguration(() => this.updateStatusItem()));
    this.item.command = 'codeQL.copyVersion';
-    this.updateStatusItem();
+    void this.updateStatusItem();
  }

  private handleDidChangeConfiguration(e: ConfigurationChangeEvent) {
--- a/extensions/ql-vscode/src/telemetry.ts
+++ b/extensions/ql-vscode/src/telemetry.ts
@@ -119,7 +119,7 @@ export class TelemetryListener extends ConfigListener {
        }

        if (LOG_TELEMETRY.getValue<boolean>()) {
-          logger.log(`Telemetry: ${JSON.stringify(envelope)}`);
+          void logger.log(`Telemetry: ${JSON.stringify(envelope)}`);
        }
        return true;
      });
@@ -128,7 +128,7 @@ export class TelemetryListener extends ConfigListener {

  dispose() {
    super.dispose();
-    this.reporter?.dispose();
+    void this.reporter?.dispose();
  }

  sendCommandUsage(name: string, executionTime: number, error?: Error) {
@@ -187,7 +187,7 @@ export class TelemetryListener extends ConfigListener {

  private disposeReporter() {
    if (this.reporter) {
-      this.reporter.dispose();
+      void this.reporter.dispose();
      this.reporter = undefined;
    }
  }
@@ -209,6 +209,8 @@ export let telemetryListener: TelemetryListener;

 export async function initializeTelemetry(extension: Extension<any>, ctx: ExtensionContext): Promise<void> {
  telemetryListener = new TelemetryListener(extension.id, extension.packageJSON.version, key, ctx);
-  telemetryListener.initialize();
+  // do not await initialization, since doing so will sometimes cause a modal popup.
+  // this is a particular problem during integration tests, which will hang if a modal popup is displayed.
+  void telemetryListener.initialize();
  ctx.subscriptions.push(telemetryListener);
 }
--- a/extensions/ql-vscode/src/test-adapter.ts
+++ b/extensions/ql-vscode/src/test-adapter.ts
@@ -1,3 +1,4 @@
+import * as fs from 'fs-extra';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import {
@@ -17,8 +18,9 @@ import { QLTestFile, QLTestNode, QLTestDirectory, QLTestDiscovery } from './qlte
 import { Event, EventEmitter, CancellationTokenSource, CancellationToken } from 'vscode';
 import { DisposableObject } from './pure/disposable-object';
 import { CodeQLCliServer } from './cli';
-import { getOnDiskWorkspaceFolders } from './helpers';
+import { getOnDiskWorkspaceFolders, showAndLogErrorMessage, showAndLogWarningMessage } from './helpers';
 import { testLogger } from './logging';
+import { DatabaseItem, DatabaseManager } from './databases';

 /**
 * Get the full path of the `.expected` file for the specified QL test.
@@ -57,13 +59,13 @@ function getTestOutputFile(testPath: string, extension: string): string {
 * A factory service that creates `QLTestAdapter` objects for workspace folders on demand.
 */
 export class QLTestAdapterFactory extends DisposableObject {
-  constructor(testHub: TestHub, cliServer: CodeQLCliServer) {
+  constructor(testHub: TestHub, cliServer: CodeQLCliServer, databaseManager: DatabaseManager) {
    super();

    // this will register a QLTestAdapter for each WorkspaceFolder
    this.push(new TestAdapterRegistrar(
      testHub,
-      workspaceFolder => new QLTestAdapter(workspaceFolder, cliServer)
+      workspaceFolder => new QLTestAdapter(workspaceFolder, cliServer, databaseManager)
    ));
  }
 }
@@ -91,7 +93,8 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {

  constructor(
    public readonly workspaceFolder: vscode.WorkspaceFolder,
-    private readonly cliServer: CodeQLCliServer
+    private readonly cliServer: CodeQLCliServer,
+    private readonly databaseManager: DatabaseManager
  ) {
    super();

@@ -182,19 +185,79 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
    testLogger.outputChannel.show(true);

    this.runningTask = this.track(new CancellationTokenSource());
+    const token = this.runningTask.token;

    this._testStates.fire({ type: 'started', tests: tests } as TestRunStartedEvent);

+    const currentDatabaseUri = this.databaseManager.currentDatabaseItem?.databaseUri;
+    const databasesUnderTest = this.databaseManager.databaseItems
+      .filter(database => tests.find(testPath => database.isAffectedByTest(testPath)));
+
+    await this.removeDatabasesBeforeTests(databasesUnderTest, token);
    try {
-      await this.runTests(tests, this.runningTask.token);
-    }
-    catch (e) {
-      /**/
+      await this.runTests(tests, token);
+    } catch (e) {
+      // CodeQL testing can throw exception even in normal scenarios. For example, if the test run
+      // produces no output (which is normal), the testing command would throw an exception on
+      // unexpected EOF during json parsing. So nothing needs to be done here - all the relevant
+      // error information (if any) should have already been written to the test logger.
    }
+    await this.reopenDatabasesAfterTests(databasesUnderTest, currentDatabaseUri, token);
+
    this._testStates.fire({ type: 'finished' } as TestRunFinishedEvent);
    this.clearTask();
  }

+  private async removeDatabasesBeforeTests(
+    databasesUnderTest: DatabaseItem[], token: vscode.CancellationToken): Promise<void> {
+    for (const database of databasesUnderTest) {
+      try {
+        await this.databaseManager
+          .removeDatabaseItem(_ => { /* no progress reporting */ }, token, database);
+      } catch (e) {
+        // This method is invoked from Test Explorer UI, and testing indicates that Test
+        // Explorer UI swallows any thrown exception without reporting it to the user.
+        // So we need to display the error message ourselves and then rethrow.
+        void showAndLogErrorMessage(`Cannot remove database ${database.name}: ${e}`);
+        throw e;
+      }
+    }
+  }
+
+  private async reopenDatabasesAfterTests(
+    databasesUnderTest: DatabaseItem[],
+    currentDatabaseUri: vscode.Uri | undefined,
+    token: vscode.CancellationToken): Promise<void> {
+    for (const closedDatabase of databasesUnderTest) {
+      const uri = closedDatabase.databaseUri;
+      if (await this.isFileAccessible(uri)) {
+        try {
+          const reopenedDatabase = await this.databaseManager
+            .openDatabase(_ => { /* no progress reporting */ }, token, uri);
+          await this.databaseManager.renameDatabaseItem(reopenedDatabase, closedDatabase.name);
+          if (currentDatabaseUri == uri) {
+            await this.databaseManager.setCurrentDatabaseItem(reopenedDatabase, true);
+          }
+        } catch (e) {
+          // This method is invoked from Test Explorer UI, and testing indicates that Test
+          // Explorer UI swallows any thrown exception without reporting it to the user.
+          // So we need to display the error message ourselves and then rethrow.
+          void showAndLogWarningMessage(`Cannot reopen database ${uri}: ${e}`);
+          throw e;
+        }
+      }
+    }
+  }
+
+  private async isFileAccessible(uri: vscode.Uri): Promise<boolean> {
+    try {
+      await fs.access(uri.fsPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
  private clearTask(): void {
    if (this.runningTask !== undefined) {
      const runningTask = this.runningTask;
@@ -205,7 +268,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {

  public cancel(): void {
    if (this.runningTask !== undefined) {
-      testLogger.log('Cancelling test run...');
+      void testLogger.log('Cancelling test run...');
      this.runningTask.cancel();
      this.clearTask();
    }
@@ -225,7 +288,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
      let message: string | undefined;
      if (event.failureDescription || event.diff?.length) {
        message = ['', `${state}: ${event.test}`, event.failureDescription || event.diff?.join('\n'), ''].join('\n');
-        testLogger.log(message);
+        void testLogger.log(message);
      }
      this._testStates.fire({
        type: 'test',
--- a/extensions/ql-vscode/src/test-ui.ts
+++ b/extensions/ql-vscode/src/test-ui.ts
@@ -44,7 +44,7 @@ export class TestUIService extends UIService implements TestController {
  constructor(private readonly testHub: TestHub) {
    super();

-    logger.log('Registering CodeQL test panel commands.');
+    void logger.log('Registering CodeQL test panel commands.');
    this.registerCommand('codeQLTests.showOutputDifferences', this.showOutputDifferences);
    this.registerCommand('codeQLTests.acceptOutput', this.acceptOutput);

@@ -90,7 +90,7 @@ export class TestUIService extends UIService implements TestController {
      };

      if (!await fs.pathExists(expectedPath)) {
-        showAndLogWarningMessage(`'${path.basename(expectedPath)}' does not exist. Creating an empty file.`);
+        void showAndLogWarningMessage(`'${path.basename(expectedPath)}' does not exist. Creating an empty file.`);
        await fs.createFile(expectedPath);
      }

--- a/extensions/ql-vscode/src/upgrades.ts
+++ b/extensions/ql-vscode/src/upgrades.ts
@@ -103,7 +103,7 @@ async function checkAndConfirmDatabaseUpgrade(
    descriptionMessage += `Would perform upgrade: ${script.description}\n`;
    descriptionMessage += `\t-> Compatibility: ${script.compatibility}\n`;
  }
-  logger.log(descriptionMessage);
+  void logger.log(descriptionMessage);


  // If the quiet flag is set, do the upgrade without a popup.
@@ -187,35 +187,35 @@ export async function upgradeDatabaseExplicit(
      compileUpgradeResult = await compileDatabaseUpgrade(qs, db, finalDbscheme, scripts, currentUpgradeTmp, progress, token);
    }
    catch (e) {
-      showAndLogErrorMessage(`Compilation of database upgrades failed: ${e}`);
+      void showAndLogErrorMessage(`Compilation of database upgrades failed: ${e}`);
      return;
    }
    finally {
-      qs.logger.log('Done compiling database upgrade.');
+      void qs.logger.log('Done compiling database upgrade.');
    }

    if (!compileUpgradeResult.compiledUpgrades) {
      const error = compileUpgradeResult.error || '[no error message available]';
-      showAndLogErrorMessage(`Compilation of database upgrades failed: ${error}`);
+      void showAndLogErrorMessage(`Compilation of database upgrades failed: ${error}`);
      return;
    }

    await checkAndConfirmDatabaseUpgrade(compileUpgradeResult.compiledUpgrades, db, qs.cliServer.quiet);

    try {
-      qs.logger.log('Running the following database upgrade:');
+      void qs.logger.log('Running the following database upgrade:');

      getUpgradeDescriptions(compileUpgradeResult.compiledUpgrades).map(s => s.description).join('\n');
      return await runDatabaseUpgrade(qs, db, compileUpgradeResult.compiledUpgrades, progress, token);
    }
    catch (e) {
-      showAndLogErrorMessage(`Database upgrade failed: ${e}`);
+      void showAndLogErrorMessage(`Database upgrade failed: ${e}`);
      return;
    } finally {
-      qs.logger.log('Done running database upgrade.');
+      void qs.logger.log('Done running database upgrade.');
    }
  } finally {
-    currentUpgradeTmp.cleanup();
+    await currentUpgradeTmp.cleanup();
  }
 }

--- a/extensions/ql-vscode/src/view/alert-table.tsx
+++ b/extensions/ql-vscode/src/view/alert-table.tsx
@@ -3,7 +3,7 @@ import * as React from 'react';
 import * as Sarif from 'sarif';
 import * as Keys from '../pure/result-keys';
 import * as octicons from './octicons';
-import { className, renderLocation, ResultTableProps, zebraStripe, selectableZebraStripe, jumpToLocation, nextSortDirection } from './result-table-utils';
+import { className, renderLocation, ResultTableProps, zebraStripe, selectableZebraStripe, jumpToLocation, nextSortDirection, emptyQueryResultsMessage } from './result-table-utils';
 import { onNavigation, NavigationEvent } from './results';
 import { PathTableResultSet } from '../pure/interface-types';
 import {
@@ -79,7 +79,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
    if (this.props.nonemptyRawResults) {
      return <span>No Alerts. See <a href='#' onClick={this.props.showRawResults}>raw results</a>.</span>;
    } else {
-      return <span>No Alerts</span>;
+      return emptyQueryResultsMessage();
    }
  }

--- a/extensions/ql-vscode/src/view/raw-results-table.tsx
+++ b/extensions/ql-vscode/src/view/raw-results-table.tsx
@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { ResultTableProps, className } from './result-table-utils';
+import { ResultTableProps, className, emptyQueryResultsMessage } from './result-table-utils';
 import { RAW_RESULTS_LIMIT, RawResultsSortState } from '../pure/interface-types';
 import { RawTableResultSet } from '../pure/interface-types';
 import RawTableHeader from './RawTableHeader';
@@ -12,7 +12,7 @@ export type RawTableProps = ResultTableProps & {
  offset: number;
 };

-export class RawTable extends React.Component<RawTableProps, {}> {
+export class RawTable extends React.Component<RawTableProps, Record<string, never>> {
  constructor(props: RawTableProps) {
    super(props);
  }
@@ -21,6 +21,10 @@ export class RawTable extends React.Component<RawTableProps, {}> {
    const { resultSet, databaseUri } = this.props;

    let dataRows = resultSet.rows;
+    if (dataRows.length === 0) {
+      return emptyQueryResultsMessage();
+    }
+
    let numTruncatedResults = 0;
    if (dataRows.length > RAW_RESULTS_LIMIT) {
      numTruncatedResults = dataRows.length - RAW_RESULTS_LIMIT;
--- a/extensions/ql-vscode/src/view/result-table-utils.tsx
+++ b/extensions/ql-vscode/src/view/result-table-utils.tsx
@@ -140,3 +140,9 @@ export function nextSortDirection(direction: SortDirection | undefined, includeU
      return assertNever(direction);
  }
 }
+
+export function emptyQueryResultsMessage(): JSX.Element {
+  return <div className='vscode-codeql__empty-query-message'><span>
+    This query returned no results. If this isn&apos;t what you were expecting, and for effective query-writing tips, check out the <a href="https://codeql.github.com/docs/codeql-language-guides/">CodeQL language guides</a>.
+  </span></div>;
+}
--- a/extensions/ql-vscode/src/view/result-tables.tsx
+++ b/extensions/ql-vscode/src/view/result-tables.tsx
@@ -82,7 +82,7 @@ export class ResultTables

  private getResultSets(): ResultSet[] {
    const resultSets: ResultSet[] =
-      // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
      // @ts-ignore 2783
      this.props.rawResultSets.map((rs) => ({ t: 'RawResultSet', ...rs }));

@@ -328,13 +328,15 @@ export class ResultTables
  }

  private vscodeMessageHandler(evt: MessageEvent) {
+    // sanitize origin
+    const origin = evt.origin.replace(/\n|\r/g, '');
    evt.origin === window.origin
      ? this.handleMessage(evt.data as IntoResultsViewMsg)
-      : console.error(`Invalid event origin ${evt.origin}`);
+      : console.error(`Invalid event origin ${origin}`);
  }
 }

-class ResultTable extends React.Component<ResultTableProps, {}> {
+class ResultTable extends React.Component<ResultTableProps, Record<string, never>> {

  constructor(props: ResultTableProps) {
    super(props);
--- a/extensions/ql-vscode/src/view/results.tsx
+++ b/extensions/ql-vscode/src/view/results.tsx
@@ -71,7 +71,7 @@ export const onNavigation = new EventHandlerList<NavigationEvent>();
 /**
 * A minimal state container for displaying results.
 */
-class App extends React.Component<{}, ResultsViewState> {
+class App extends React.Component<Record<string, never>, ResultsViewState> {
  constructor(props: any) {
    super(props);
    this.state = {
@@ -102,7 +102,7 @@ class App extends React.Component<{}, ResultsViewState> {
          queryPath: msg.queryPath,
        });

-        this.loadResults();
+        void this.loadResults();
        break;
      case 'showInterpretedPage':
        this.updateStateWithNewResultsInfo({
@@ -134,7 +134,7 @@ class App extends React.Component<{}, ResultsViewState> {
          queryName: msg.queryName,
          queryPath: msg.queryPath,
        });
-        this.loadResults();
+        void this.loadResults();
        break;
      case 'resultsUpdating':
        this.setState({
@@ -307,9 +307,11 @@ class App extends React.Component<{}, ResultsViewState> {
  }

  private vscodeMessageHandler(evt: MessageEvent) {
+    // sanitize origin
+    const origin = evt.origin.replace(/\n|\r/g, '');
    evt.origin === window.origin
      ? this.handleMessage(evt.data as IntoResultsViewMsg)
-      : console.error(`Invalid event origin ${evt.origin}`);
+      : console.error(`Invalid event origin ${origin}`);
  }
 }

--- a/extensions/ql-vscode/src/view/resultsView.css
+++ b/extensions/ql-vscode/src/view/resultsView.css
@@ -221,3 +221,16 @@ td.vscode-codeql__path-index-cell {
 .vscode-codeql__compare-body > tbody {
  vertical-align: top;
 }
+
+.vscode-codeql__empty-query-message {
+  height: 300px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.vscode-codeql__empty-query-message > span {
+  max-width: 80%;
+  font-size: 14px;
+  text-align: center;
+}
--- a/extensions/ql-vscode/src/vscode-tests/.eslintrc.js
+++ b/extensions/ql-vscode/src/vscode-tests/.eslintrc.js
@@ -1,5 +1,19 @@
 module.exports = {
  env: {
    mocha: true
+  },
+  rules: {
+    "@typescript-eslint/ban-types": [
+      "error",
+      { 
+        // For a full list of the default banned types, see:
+        // https://github.com/typescript-eslint/typescript-eslint/blob/master/packages/eslint-plugin/docs/rules/ban-types.md
+        extendDefaults: true,
+        "types": {
+          // Don't complain about the `Function` type in test files. (Default is `true`.)
+          "Function": false,
+        }
+      }
+    ]
  }
 }
--- a/extensions/ql-vscode/src/vscode-tests/cli-integration/databases.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/cli-integration/databases.test.ts
@@ -25,7 +25,7 @@ describe('Databases', function() {

  beforeEach(async () => {
    try {
-      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | Record<string, never>>('GitHub.vscode-codeql')!.activate();
      if ('databaseManager' in extension) {
        databaseManager = extension.databaseManager;
      } else {
--- a/extensions/ql-vscode/src/vscode-tests/cli-integration/global.helper.ts
+++ b/extensions/ql-vscode/src/vscode-tests/cli-integration/global.helper.ts
@@ -27,7 +27,7 @@ export default function(mocha: Mocha) {
      if (!fs.existsSync(dbLoc)) {
        try {
          await new Promise((resolve, reject) => {
-            fetch(DB_URL).then(response => {
+            return fetch(DB_URL).then(response => {
              const dest = fs.createWriteStream(dbLoc);
              response.body.pipe(dest);

@@ -68,7 +68,7 @@ export default function(mocha: Mocha) {
  // ensure etension is cleaned up.
  (mocha.options as any).globalTeardown.push(
    async () => {
-      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | Record<string, never>>('GitHub.vscode-codeql')!.activate();
      // This shuts down the extension and can only be run after all tests have completed.
      // If this is not called, then the test process will hang.
      if ('dispose' in extension) {
--- a/extensions/ql-vscode/src/vscode-tests/cli-integration/queries.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/cli-integration/queries.test.ts
@@ -45,7 +45,7 @@ describe('Queries', function() {
    sandbox = sinon.createSandbox();

    try {
-      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | Record<string, never>>('GitHub.vscode-codeql')!.activate();
      if ('databaseManager' in extension) {
        databaseManager = extension.databaseManager;
        cli = extension.cliServer;
--- a/extensions/ql-vscode/src/vscode-tests/cli-integration/query.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/cli-integration/query.test.ts
@@ -34,7 +34,7 @@ class Checkpoint<T> {
    this.res = () => { /**/ };
    this.rej = () => { /**/ };
    this.promise = new Promise((res, rej) => {
-      this.res = res as () => {};
+      this.res = res as () => Record<string, never>;
      this.rej = rej;
    });
  }
@@ -104,7 +104,7 @@ describe('using the query server', function() {

  beforeEach(async () => {
    try {
-      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | Record<string, never>>('GitHub.vscode-codeql')!.activate();
      if ('cliServer' in extension && 'qs' in extension) {
        cliServer = extension.cliServer;
        qs = extension.qs;
@@ -119,7 +119,7 @@ describe('using the query server', function() {

  it('should be able to start the query server', async function() {
    await qs.startQueryServer();
-    queryServerStarted.resolve();
+    await queryServerStarted.resolve();
  });

  for (const queryTestCase of queryTestCases) {
@@ -160,10 +160,10 @@ describe('using the query server', function() {
        };
        const result = await qs.sendRequest(messages.compileQuery, params, token, () => { /**/ });
        expect(result.messages!.length).to.equal(0);
-        compilationSucceeded.resolve();
+        await compilationSucceeded.resolve();
      }
      catch (e) {
-        compilationSucceeded.reject(e);
+        await compilationSucceeded.reject(e);
      }
    });

@@ -171,7 +171,7 @@ describe('using the query server', function() {
      try {
        await compilationSucceeded.done();
        const callbackId = qs.registerCallback(_res => {
-          evaluationSucceeded.resolve();
+          void evaluationSucceeded.resolve();
        });
        const queryToRun: messages.QueryToRun = {
          resultsPath: RESULTS_PATH,
@@ -190,7 +190,7 @@ describe('using the query server', function() {
        await qs.sendRequest(messages.runQueries, params, token, () => { /**/ });
      }
      catch (e) {
-        evaluationSucceeded.reject(e);
+        await evaluationSucceeded.reject(e);
      }
    });

@@ -203,7 +203,7 @@ describe('using the query server', function() {
        const decoded = await cliServer.bqrsDecode(RESULTS_PATH, resultSet.name);
        actualResultSets[resultSet.name] = decoded.tuples;
      }
-      parsedResults.resolve();
+      await parsedResults.resolve();
    });

    it(`should have correct results for query ${queryName}`, async function() {
--- a/extensions/ql-vscode/src/vscode-tests/cli-integration/run-cli.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/cli-integration/run-cli.test.ts
@@ -16,7 +16,7 @@ describe('Use cli', function() {
  let cli: CodeQLCliServer;

  beforeEach(async () => {
-    const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+    const extension = await extensions.getExtension<CodeQLExtensionInterface | Record<string, never>>('GitHub.vscode-codeql')!.activate();
    if ('cliServer' in extension) {
      cli = extension.cliServer;
    } else {
--- a/extensions/ql-vscode/src/vscode-tests/ensureCli.ts
+++ b/extensions/ql-vscode/src/vscode-tests/ensureCli.ts
@@ -39,7 +39,7 @@ const _10MB = _1MB * 10;

 // CLI version to test. Hard code the latest as default. And be sure
 // to update the env if it is not otherwise set.
-const CLI_VERSION = process.env.CLI_VERSION || 'v2.4.2';
+const CLI_VERSION = process.env.CLI_VERSION || 'v2.5.5';
 process.env.CLI_VERSION = CLI_VERSION;

 // Base dir where CLIs will be downloaded into
--- a/extensions/ql-vscode/src/vscode-tests/index-template.ts
+++ b/extensions/ql-vscode/src/vscode-tests/index-template.ts
@@ -79,6 +79,7 @@ export async function runTestsInDirectory(testsRoot: string, useCli = false): Pr
          .filter(f => f.endsWith('.helper.js'))
          .forEach(f => {
            console.log(`Executing helper ${f}`);
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
            const helper = require(path.resolve(testsRoot, f)).default;
            helper(mocha);
          });
--- a/extensions/ql-vscode/src/vscode-tests/minimal-workspace/config.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/minimal-workspace/config.test.ts
@@ -29,7 +29,7 @@ describe('config listeners', function() {
  });

  interface TestConfig<T> {
-    clazz: new () => {};
+    clazz: new () => unknown;
    settings: {
      name: string;
      property: string;
--- a/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/minimal-workspace/databases.test.ts
@@ -179,7 +179,7 @@ describe('databases', () => {
      expect(spy).to.have.been.calledWith(mockEvent);
    });

-    it('should add a database item source archive', async function() {
+    it('should add a database item source archive', async function () {
      const mockDbItem = createMockDB();
      mockDbItem.name = 'xxx';
      await (databaseManager as any).addDatabaseSourceArchiveFolder(mockDbItem);
@@ -414,6 +414,72 @@ describe('databases', () => {
    expect(result).to.eq('');
  });

+  describe('isAffectedByTest', () => {
+    const directoryStats = new fs.Stats();
+    const fileStats = new fs.Stats();
+
+    before(() => {
+      sinon.stub(directoryStats, 'isDirectory').returns(true);
+      sinon.stub(fileStats, 'isDirectory').returns(false);
+    });
+
+    it('should return true for testproj database in test directory', async () => {
+      sandbox.stub(fs, 'stat').resolves(directoryStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/dir')).to.true;
+    });
+
+    it('should return false for non-existent test directory', async () => {
+      sandbox.stub(fs, 'stat').throws('Simulated Error: ENOENT');
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/dir')).to.false;
+    });
+
+    it('should return false for non-testproj database in test directory', async () => {
+      sandbox.stub(fs, 'stat').resolves(directoryStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.proj'));
+      expect(await db.isAffectedByTest('/path/to/dir')).to.false;
+    });
+
+    it('should return false for testproj database outside test directory', async () => {
+      sandbox.stub(fs, 'stat').resolves(directoryStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/other/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/dir')).to.false;
+    });
+
+    it('should return false for testproj database for prefix directory', async () => {
+      sandbox.stub(fs, 'stat').resolves(directoryStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      // /path/to/d is a prefix of /path/to/dir/dir.testproj, but
+      // /path/to/dir/dir.testproj is not under /path/to/d
+      expect(await db.isAffectedByTest('/path/to/d')).to.false;
+    });
+
+    it('should return true for testproj database for test file', async () => {
+      sandbox.stub(fs, 'stat').resolves(fileStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/dir/test.ql')).to.true;
+    });
+
+    it('should return false for non-existent test file', async () => {
+      sandbox.stub(fs, 'stat').throws('Simulated Error: ENOENT');
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/dir/test.ql')).to.false;
+    });
+
+    it('should return false for non-testproj database for test file', async () => {
+      sandbox.stub(fs, 'stat').resolves(fileStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.proj'));
+      expect(await db.isAffectedByTest('/path/to/dir/test.ql')).to.false;
+    });
+
+    it('should return false for testproj database not matching test file', async () => {
+      sandbox.stub(fs, 'stat').resolves(fileStats);
+      const db = createMockDB(sourceLocationUri(), Uri.file('/path/to/dir/dir.testproj'));
+      expect(await db.isAffectedByTest('/path/to/test.ql')).to.false;
+    });
+  });
+
  function createMockDB(
    // source archive location must be a real(-ish) location since
    // tests will add this to the workspace location
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/contextual/astBuilder.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/contextual/astBuilder.test.ts
@@ -19,23 +19,23 @@ This test uses an AST generated from this file (already BQRS-decoded in ../data/

 int interrupt_init(void)
 {
-	return 0;
+    return 0;
 }

 void enable_interrupts(void)
 {
-	return;
+    return;
 }
 int disable_interrupts(void)
 {
-	return 0;
+    return 0;
 }
 */


 describe('AstBuilder', () => {
  let mockCli: CodeQLCliServer;
-  let overrides: Record<string, object | undefined>;
+  let overrides: Record<string, Record<string, unknown> | undefined>;

  beforeEach(() => {
    mockCli = {
@@ -135,7 +135,7 @@ describe('AstBuilder', () => {
    };

    const astBuilder = createAstBuilder();
-    expect(astBuilder.getRoots()).to.be.rejectedWith('AST is invalid');
+    await expect(astBuilder.getRoots()).to.be.rejectedWith('AST is invalid');
  });

  function createAstBuilder() {
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/databaseFetcher.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/databaseFetcher.test.ts
@@ -69,7 +69,7 @@ describe('databaseFetcher', function() {
    it('should fail on a nonexistent project', async () => {
      quickPickSpy.resolves('javascript');
      const lgtmUrl = 'https://lgtm.com/projects/g/github/hucairz';
-      expect(convertToDatabaseUrl(lgtmUrl)).to.rejectedWith(/Invalid LGTM URL/);
+      await expect(convertToDatabaseUrl(lgtmUrl)).to.rejectedWith(/Invalid LGTM URL/);
    });
  });

--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/helpers.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/helpers.test.ts
@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import 'mocha';
-import { ExtensionContext, Memento, window } from 'vscode';
+import { EnvironmentVariableCollection, EnvironmentVariableMutator, Event, ExtensionContext, ExtensionMode, Memento, SecretStorage, SecretStorageChangeEvent, Uri, window } from 'vscode';
 import * as yaml from 'js-yaml';
 import * as tmp from 'tmp';
 import * as path from 'path';
@@ -146,9 +146,10 @@ describe('helpers', () => {
  });

  class MockExtensionContext implements ExtensionContext {
+    extensionMode: ExtensionMode = 3;
    subscriptions: { dispose(): unknown }[] = [];
    workspaceState: Memento = new MockMemento();
-    globalState: Memento = new MockMemento();
+    globalState = new MockGlobalStorage();
    extensionPath = '';
    asAbsolutePath(_relativePath: string): string {
      throw new Error('Method not implemented.');
@@ -156,6 +157,38 @@ describe('helpers', () => {
    storagePath = '';
    globalStoragePath = '';
    logPath = '';
+    extensionUri = Uri.parse('');
+    environmentVariableCollection = new MockEnvironmentVariableCollection();
+    secrets = new MockSecretStorage();
+    storageUri = Uri.parse('');
+    globalStorageUri = Uri.parse('');
+    logUri = Uri.parse('');
+    extension: any;
+  }
+
+  class MockEnvironmentVariableCollection implements EnvironmentVariableCollection {
+    persistent = false;
+    replace(_variable: string, _value: string): void {
+      throw new Error('Method not implemented.');
+    }
+    append(_variable: string, _value: string): void {
+      throw new Error('Method not implemented.');
+    }
+    prepend(_variable: string, _value: string): void {
+      throw new Error('Method not implemented.');
+    }
+    get(_variable: string): EnvironmentVariableMutator | undefined {
+      throw new Error('Method not implemented.');
+    }
+    forEach(_callback: (variable: string, mutator: EnvironmentVariableMutator, collection: EnvironmentVariableCollection) => any, _thisArg?: any): void {
+      throw new Error('Method not implemented.');
+    }
+    delete(_variable: string): void {
+      throw new Error('Method not implemented.');
+    }
+    clear(): void {
+      throw new Error('Method not implemented.');
+    }
  }

  class MockMemento implements Memento {
@@ -184,6 +217,25 @@ describe('helpers', () => {
    }
  }

+  class MockGlobalStorage extends MockMemento {
+    public setKeysForSync(_keys: string[]): void {
+      return;
+    }
+  }
+
+  class MockSecretStorage implements SecretStorage {
+    get(_key: string): Thenable<string | undefined> {
+      throw new Error('Method not implemented.');
+    }
+    store(_key: string, _value: string): Thenable<void> {
+      throw new Error('Method not implemented.');
+    }
+    delete(_key: string): Thenable<void> {
+      throw new Error('Method not implemented.');
+    }
+    onDidChange!: Event<SecretStorageChangeEvent>;
+  }
+
  it('should report stream progress', () => {
    const spy = sandbox.spy();
    const mockReadable = {
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/query-history.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/query-history.test.ts
@@ -268,7 +268,7 @@ describe('query-history', () => {
  });
 });

-function createMockQueryHistory(allHistory: {}[]) {
+function createMockQueryHistory(allHistory: Record<string, unknown>[]) {
  return {
    assertSingleQuery: (QueryHistoryManager.prototype as any).assertSingleQuery,
    findOtherQueryToCompare: (QueryHistoryManager.prototype as any).findOtherQueryToCompare,
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/test-adapter.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/test-adapter.test.ts
@@ -1,24 +1,61 @@
 import 'vscode-test';
 import 'mocha';
 import * as sinon from 'sinon';
+import * as fs from 'fs-extra';
 import { Uri, WorkspaceFolder } from 'vscode';
 import { expect } from 'chai';

 import { QLTestAdapter } from '../../test-adapter';
 import { CodeQLCliServer } from '../../cli';
+import { DatabaseItem, DatabaseItemImpl, DatabaseManager, FullDatabaseOptions } from '../../databases';

 describe('test-adapter', () => {
  let adapter: QLTestAdapter;
+  let fakeDatabaseManager: DatabaseManager;
+  let currentDatabaseItem: DatabaseItem | undefined;
+  let databaseItems: DatabaseItem[] = [];
+  let openDatabaseSpy: sinon.SinonStub;
+  let removeDatabaseItemSpy: sinon.SinonStub;
+  let renameDatabaseItemSpy: sinon.SinonStub;
+  let setCurrentDatabaseItemSpy: sinon.SinonStub;
  let runTestsSpy: sinon.SinonStub;
  let resolveTestsSpy: sinon.SinonStub;
  let resolveQlpacksSpy: sinon.SinonStub;
  let sandox: sinon.SinonSandbox;

+  const preTestDatabaseItem = new DatabaseItemImpl(
+    Uri.file('/path/to/test/dir/dir.testproj'),
+    undefined,
+    { displayName: 'custom display name' } as unknown as FullDatabaseOptions,
+    (_) => { /* no change event listener */ }
+  );
+  const postTestDatabaseItem = new DatabaseItemImpl(
+    Uri.file('/path/to/test/dir/dir.testproj'),
+    undefined,
+    { displayName: 'default name' } as unknown as FullDatabaseOptions,
+    (_) => { /* no change event listener */ }
+  );
+
  beforeEach(() => {
    sandox = sinon.createSandbox();
    mockRunTests();
+    openDatabaseSpy = sandox.stub().resolves(postTestDatabaseItem);
+    removeDatabaseItemSpy = sandox.stub().resolves();
+    renameDatabaseItemSpy = sandox.stub().resolves();
+    setCurrentDatabaseItemSpy = sandox.stub().resolves();
    resolveQlpacksSpy = sandox.stub().resolves({});
    resolveTestsSpy = sandox.stub().resolves([]);
+    fakeDatabaseManager = {
+      currentDatabaseItem: undefined,
+      databaseItems: undefined,
+      openDatabase: openDatabaseSpy,
+      removeDatabaseItem: removeDatabaseItemSpy,
+      renameDatabaseItem: renameDatabaseItemSpy,
+      setCurrentDatabaseItem: setCurrentDatabaseItemSpy,
+    } as unknown as DatabaseManager;
+    sandox.stub(fakeDatabaseManager, 'currentDatabaseItem').get(() => currentDatabaseItem);
+    sandox.stub(fakeDatabaseManager, 'databaseItems').get(() => databaseItems);
+    sandox.stub(preTestDatabaseItem, 'isAffectedByTest').resolves(true);
    adapter = new QLTestAdapter({
      name: 'ABC',
      uri: Uri.parse('file:/ab/c')
@@ -26,7 +63,8 @@ describe('test-adapter', () => {
      runTests: runTestsSpy,
      resolveQlpacks: resolveQlpacksSpy,
      resolveTests: resolveTestsSpy
-    } as unknown as CodeQLCliServer);
+    } as unknown as CodeQLCliServer,
+      fakeDatabaseManager);
  });

  afterEach(() => {
@@ -74,12 +112,33 @@ describe('test-adapter', () => {
    expect(listenerSpy).to.have.callCount(5);
  });

+  it('should reregister testproj databases around test run', async () => {
+    sandox.stub(fs, 'access').resolves();
+    currentDatabaseItem = preTestDatabaseItem;
+    databaseItems = [preTestDatabaseItem];
+    await adapter.run(['/path/to/test/dir']);
+
+    removeDatabaseItemSpy.getCall(0).calledBefore(runTestsSpy.getCall(0));
+    openDatabaseSpy.getCall(0).calledAfter(runTestsSpy.getCall(0));
+    renameDatabaseItemSpy.getCall(0).calledAfter(openDatabaseSpy.getCall(0));
+    setCurrentDatabaseItemSpy.getCall(0).calledAfter(openDatabaseSpy.getCall(0));
+
+    sinon.assert.calledOnceWithExactly(
+      removeDatabaseItemSpy, sinon.match.any, sinon.match.any, preTestDatabaseItem);
+    sinon.assert.calledOnceWithExactly(
+      openDatabaseSpy, sinon.match.any, sinon.match.any, preTestDatabaseItem.databaseUri);
+    sinon.assert.calledOnceWithExactly(
+      renameDatabaseItemSpy, postTestDatabaseItem, preTestDatabaseItem.name);
+    sinon.assert.calledOnceWithExactly(
+      setCurrentDatabaseItemSpy, postTestDatabaseItem, true);
+  });
+
  function mockRunTests() {
    // runTests is an async generator function. This is not directly supported in sinon
    // However, we can pretend the same thing by just returning an async array.
    runTestsSpy = sandox.stub();
    runTestsSpy.returns(
-      (async function*() {
+      (async function* () {
        yield Promise.resolve({
          test: Uri.parse('file:/ab/c/d.ql').fsPath,
          pass: true,
--- a/extensions/ql-vscode/src/vscode-tests/run-integration-tests.ts
+++ b/extensions/ql-vscode/src/vscode-tests/run-integration-tests.ts
@@ -105,7 +105,7 @@ async function main() {
  }
 }

-main();
+void main();


 function getLaunchArgs(dir: TestDir) {
@@ -128,6 +128,14 @@ function getLaunchArgs(dir: TestDir) {
      return [
        '--disable-gpu',
        path.resolve(__dirname, '../../test/data'),
+
+        // explicitly disable extensions that are known to interfere with the CLI integration tests
+        '--disable-extension',
+        'eamodio.gitlens',
+        '--disable-extension',
+        'github.codespaces',
+        '--disable-extension',
+        'github.copilot',
        process.env.TEST_CODEQL_PATH!
      ];

--- a/extensions/ql-vscode/test/pure-tests/logging.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/logging.test.ts
@@ -48,7 +48,7 @@ describe('OutputChannelLogger tests', () => {
  });

  it('should create a side log in the workspace area', async () => {
-    logger.init(tempFolders.storagePath.name);
+    await logger.setLogStoragePath(tempFolders.storagePath.name, false);

    await logger.log('xxx', { additionalLogLocation: 'first' });
    await logger.log('yyy', { additionalLogLocation: 'second' });
@@ -65,7 +65,7 @@ describe('OutputChannelLogger tests', () => {
  });

  it('should delete side logs on dispose', async () => {
-    logger.init(tempFolders.storagePath.name);
+    await logger.setLogStoragePath(tempFolders.storagePath.name, false);
    await logger.log('xxx', { additionalLogLocation: 'first' });
    await logger.log('yyy', { additionalLogLocation: 'second' });

@@ -79,8 +79,23 @@ describe('OutputChannelLogger tests', () => {
    expect(mockOutputChannel.dispose).to.have.been.calledWith();
  });

+  it('should not delete side logs on dispose in a custom directory', async () => {
+    await logger.setLogStoragePath(tempFolders.storagePath.name, true);
+    await logger.log('xxx', { additionalLogLocation: 'first' });
+    await logger.log('yyy', { additionalLogLocation: 'second' });
+
+    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
+    expect(fs.readdirSync(testLoggerFolder).length).to.equal(2);
+
+    await logger.dispose();
+    // need to wait for disposable-object to dispose
+    await waitABit();
+    expect(fs.readdirSync(testLoggerFolder).length).to.equal(2);
+    expect(mockOutputChannel.dispose).to.have.been.calledWith();
+  });
+
  it('should remove an additional log location', async () => {
-    logger.init(tempFolders.storagePath.name);
+    await logger.setLogStoragePath(tempFolders.storagePath.name, false);
    await logger.log('xxx', { additionalLogLocation: 'first' });
    await logger.log('yyy', { additionalLogLocation: 'second' });

@@ -94,11 +109,36 @@ describe('OutputChannelLogger tests', () => {
    expect(fs.readFileSync(path.join(testLoggerFolder, 'second'), 'utf8')).to.equal('yyy\n');
  });

-  it('should delete an existing folder on init', async () => {
+  it('should not remove an additional log location in a custom directory', async () => {
+    await logger.setLogStoragePath(tempFolders.storagePath.name, true);
+    await logger.log('xxx', { additionalLogLocation: 'first' });
+    await logger.log('yyy', { additionalLogLocation: 'second' });
+
+    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
+    expect(fs.readdirSync(testLoggerFolder).length).to.equal(2);
+
+    await logger.removeAdditionalLogLocation('first');
+    // need to wait for disposable-object to dispose
+    await waitABit();
+    expect(fs.readdirSync(testLoggerFolder).length).to.equal(2);
+    expect(fs.readFileSync(path.join(testLoggerFolder, 'second'), 'utf8')).to.equal('yyy\n');
+  });
+
+  it('should delete an existing folder when setting the log storage path', async () => {
    fs.createFileSync(path.join(tempFolders.storagePath.name, 'test-logger', 'xxx'));
-    logger.init(tempFolders.storagePath.name);
+    await logger.setLogStoragePath(tempFolders.storagePath.name, false);
    // should be empty dir

+    await waitABit();
+    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
+    expect(fs.existsSync(testLoggerFolder)).to.be.false;
+  });
+
+  it('should not delete an existing folder when setting the log storage path for a custom directory', async () => {
+    fs.createFileSync(path.join(tempFolders.storagePath.name, 'test-logger', 'xxx'));
+    await logger.setLogStoragePath(tempFolders.storagePath.name, true);
+    // should not be empty dir
+
    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
    expect(fs.readdirSync(testLoggerFolder).length).to.equal(1);
  });
@@ -130,7 +170,7 @@ describe('OutputChannelLogger tests', () => {
    });
  }

-  function  waitABit(ms = 50): Promise<void> {
+  function waitABit(ms = 50): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
 });
Author	SHA1	Message	Date
shati-patel	472008888c	v1.5.0 Some checks failed Release / Release (push) Has been cancelled Details Release / Publish to VS Code Marketplace (push) Has been cancelled Details Release / Publish to Open VSX Registry (push) Has been cancelled Details	2021-06-14 20:00:34 +01:00
shati-patel	aa0d844dc1	Add more context in changelog	2021-06-14 18:42:42 +01:00
shati-patel	2523f81640	Update changelog	2021-06-14 18:42:42 +01:00
shati-patel	9e8b1ffd50	Update to VS Code 1.57.0 This version of VS Code has workspace trust enabled by default	2021-06-14 18:42:42 +01:00
shati-patel	06b22511a7	Update to VS Code 1.48.0 partial cherry-pick from `qc-development` branch	2021-06-14 18:42:42 +01:00
shati-patel	61373209ff	Use the workspace trust feature	2021-06-14 18:42:42 +01:00
Andrew Eisenberg	b1e28f6b7d	Fix running integration tests The main fix is in `telemetry.ts:213`.	2021-06-11 14:08:25 -07:00
Andrew Eisenberg	1d414bac55	Update linting rules Add the `@typescript-eslint/no-floating-promises` rule with an allowance for floating promises if `void` is used. This increases safety and ensures that we are explicit when we avoid awaiting a promise. I already caught a few bugish locations. In general, we don't need to await the results of logging calls. databases-ui, we were using a deprecated method for removing a directory. `fs.rmdir` instead of `fs.remove`.	2021-06-11 14:08:25 -07:00
shati-patel	2f3be92a71	Make functions async + other review comments	2021-05-21 21:41:40 +01:00
shati-patel	a8fd6cc0ee	Add changelog note	2021-05-21 21:41:40 +01:00
shati-patel	e591236c4e	Update tests	2021-05-21 21:41:40 +01:00
shati-patel	41f4e04379	Create custom log directory, if possible (I haven't got the error handling to work asynchronously, so I stuck with `mkdirSync` for now)	2021-05-21 21:41:40 +01:00
shati-patel	7e27f20e0e	Specify custom directory for storing query server logs	2021-05-21 21:41:40 +01:00
Eric Kim	f550cbe98f	Increase font size and add margins to empty query message	2021-05-21 12:35:29 -07:00
Eric Kim	5315c16338	Adjust empty query message	2021-05-21 12:35:29 -07:00
Chuan-kai Lin	540cb99de4	Reregister testproj databases around test runs To deal with the problem of CodeQL tests modifying open testproj databases, this commit removes open databases from the extension prior to running tests, and tries to open those databases again after tests finish running.	2021-05-20 16:00:45 -07:00
Eric Kim	3abc8df8fc	Update ChangeLog	2021-05-17 19:01:03 -07:00
Eric Kim	ca93f0e84b	Add link to language guides for empty query results	2021-05-17 19:01:03 -07:00
Andrew Eisenberg	d9ff5bdca4	Update cli integration tests with new cli version	2021-05-17 12:39:25 -07:00
Andrew Eisenberg	c4b12250ba	Update ChangeLog	2021-05-14 08:00:25 -07:00
Andrew Eisenberg	d73f00196b	Add version info while downloading	2021-05-14 08:00:25 -07:00
Andrew Eisenberg	6bf616ff4d	Fix code scanning errors and dependabot issues * Log injection errors * Also, ran `npm audit fix`	2021-05-10 09:39:55 -07:00
Andrew Eisenberg	ff02d1da05	Add extra emphasis in contributing docs	2021-05-06 14:54:48 -07:00
shati-patel	72d57eec6e	Bump version to v1.4.9	2021-05-05 10:04:39 -07:00