v1.4.7

* Add a polyfill for the Node.js path module

Webpack >v5 doesn't include polyfills for core modules from Node.js by
default. Since we use `path` in the results table UI, we need to include
our own polyfill. This commit adds `path-browserify` to the
distributed extension.

As future work, we could move SARIF location rendering into the core
extension so we don't need to use `path.basename` in the UI. This would
allow us to remove the polyfill.

* Add changelog note

.github/codeql/codeql-config.yml

@@ -0,0 +1,12 @@
+name: "CodeQL config"
+queries:
+  - name: Run standard queries
+    uses: security-and-quality
+  - name: Run custom javascript queries
+    uses: ./.github/codeql/queries
+paths:
+  - ./extensions/ql-vscode
+paths-ignore:
+  - '**/node_modules'
+  - '**/build'
+  - '**/out'

.github/codeql/queries/assert-pure.ql

@@ -0,0 +1,21 @@
+/**
+ * @name Unwanted dependency on vscode API
+ * @kind problem
+ * @problem.severity error
+ * @id vscode-codeql/assert-pure
+ * @description The modules stored under `pure` and tested in the `pure-tests`
+ * are intended to be "pure".
+ */
+import javascript
+
+class VSCodeImport extends ASTNode {
+  VSCodeImport() {
+    this.(Import).getImportedPath().getValue() = "vscode"
+  }
+}
+
+from Module m, VSCodeImport v
+where
+  m.getFile().getRelativePath().regexpMatch(".*src/pure/.*")  and
+  m.getAnImportedModule*().getAnImport() = v
+select m, "This module is not pure: it has a transitive dependency on the vscode API imported $@", v, "here"

.github/codeql/queries/qlpack.yml

@@ -0,0 +1,3 @@
+name: vscode-codeql-custom-queries-javascript
+version: 0.0.0
+libraryPathDependencies: codeql-javascript

.github/pull_request_template.md

@@ -9,4 +9,4 @@ Replace this with a description of the changes your pull request makes.
 
 - [ ] [CHANGELOG.md](https://github.com/github/vscode-codeql/blob/main/extensions/ql-vscode/CHANGELOG.md) has been updated to incorporate all user visible changes made by this pull request.
 - [ ] Issues have been created for any UI or other user-facing changes made by this pull request.
-- [ ] `@github/docs-content-dsp` has been cc'd in all issues for UI or other user-facing changes made by this pull request.
+- [ ] `@github/docs-content-codeql` has been cc'd in all issues for UI or other user-facing changes made by this pull request.

.github/workflows/codeql.yml

@@ -2,14 +2,14 @@ name: "Code Scanning - CodeQL"
 
 on:
   push:
+    branches: [main]
   pull_request:
+    branches: [main]
   schedule:
     - cron: '0 0 * * 0'
 
 jobs:
   codeql:
-    strategy:
-      fail-fast: false
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
@@ -17,6 +17,9 @@ jobs:
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v1
+        with:
+            languages: javascript
+            config-file: ./.github/codeql/codeql-config.yml
 
       - name: Perform CodeQL Analysis
         uses: github/codeql-action/analyze@v1

.github/workflows/main.yml

@@ -1,5 +1,10 @@
 name: Build Extension
-on: [push, pull_request]
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - main
 
 jobs:
   build:
@@ -16,17 +21,19 @@ jobs:
 
       - uses: actions/setup-node@v1
         with:
-          node-version: '10.18.1'
+          node-version: '14.14.0'
 
       - name: Install dependencies
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           npm install
         shell: bash
 
       - name: Build
+        working-directory: extensions/ql-vscode
+        env:
+          APP_INSIGHTS_KEY: '${{ secrets.APP_INSIGHTS_KEY }}'
         run: |
-          cd extensions/ql-vscode
           npm run build
         shell: bash
 
@@ -37,7 +44,7 @@ jobs:
           cp dist/*.vsix artifacts
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@master
+        uses: actions/upload-artifact@v2
         if: matrix.os == 'ubuntu-latest'
         with:
           name: vscode-codeql-extension
@@ -57,24 +64,25 @@ jobs:
 
       - uses: actions/setup-node@v1
         with:
-          node-version: '10.18.1'
+          node-version: '14.14.0'
 
-      # We have to build the dependencies in `lib` before running any tests.
       - name: Install dependencies
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           npm install
         shell: bash
 
       - name: Build
+        working-directory: extensions/ql-vscode
+        env:
+          APP_INSIGHTS_KEY: '${{ secrets.APP_INSIGHTS_KEY }}'
         run: |
-          cd extensions/ql-vscode
           npm run build
         shell: bash
 
       - name: Lint
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           npm run lint
 
       - name: Install CodeQL
@@ -87,27 +95,76 @@ jobs:
         shell: bash
 
       - name: Run unit tests (Linux)
+        working-directory: extensions/ql-vscode
         if: matrix.os == 'ubuntu-latest'
         run: |
-          cd extensions/ql-vscode
           CODEQL_PATH=$GITHUB_WORKSPACE/codeql-home/codeql/codeql npm run test
 
       - name: Run unit tests (Windows)
         if: matrix.os == 'windows-latest'
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           $env:CODEQL_PATH=$(Join-Path $env:GITHUB_WORKSPACE -ChildPath 'codeql-home/codeql/codeql.exe')
           npm run test
 
       - name: Run integration tests (Linux)
         if: matrix.os == 'ubuntu-latest'
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           sudo apt-get install xvfb
           /usr/bin/xvfb-run npm run integration
 
       - name: Run integration tests (Windows)
         if: matrix.os == 'windows-latest'
+        working-directory: extensions/ql-vscode
         run: |
-          cd extensions/ql-vscode
           npm run integration
+
+  cli-test:
+    name: CLI Test
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        version: ['v2.2.6', 'v2.3.3', 'v2.4.5', 'v2.4.6', 'v2.5.1']
+    env:
+      CLI_VERSION: ${{ matrix.version }}
+      TEST_CODEQL_PATH: '${{ github.workspace }}/codeql'
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - uses: actions/setup-node@v1
+        with:
+          node-version: '14.14.0'
+
+      - name: Install dependencies
+        working-directory: extensions/ql-vscode
+        run: |
+          npm install
+        shell: bash
+
+      - name: Build
+        working-directory: extensions/ql-vscode
+        run: |
+          npm run build
+        shell: bash
+
+      - name: Checkout QL
+        uses: actions/checkout@v2
+        with:
+          repository: github/codeql
+          path: codeql
+
+      - name: Run CLI tests (Linux)
+        working-directory: extensions/ql-vscode
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          /usr/bin/xvfb-run npm run cli-integration
+
+      - name: Run CLI tests (Windows)
+        working-directory: extensions/ql-vscode
+        if: matrix.os == 'windows-latest'
+        run: |
+          npm run cli-integration

.github/workflows/release.yml

@@ -6,25 +6,20 @@
 
 name: Release
 on:
-  push:
-    # Path filters are not evaluated for pushes to tags.
-    # (source: https://help.github.com/en/github/automating-your-workflow-with-github-actions/workflow-syntax-for-github-actions#onpushpull_requestpaths)
-    # So this workflow is triggered in the following events:
-    # - Release event: a SemVer tag, e.g. v1.0.0 or v1.0.0-alpha, is pushed
-    tags:
-      - 'v[0-9]+.[0-9]+.[0-9]+*'
-    # OR
-    # - Test event: this file is modified on a branch in the main repo containing `/actions/` in the name.
-    branches:
-      - '**/actions/**'
+  pull_request:
     paths:
       - '**/workflows/release.yml'
 
+  workflow_dispatch:
+
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+*'
+
 jobs:
   build:
     name: Release
     runs-on: ubuntu-latest
-    # TODO Share steps with the main workflow.
     steps:
       - name: Checkout
         uses: actions/checkout@v2
@@ -36,11 +31,14 @@ jobs:
       - name: Install dependencies
         run: |
           cd extensions/ql-vscode
-          npm install
+          npm ci
         shell: bash
 
       - name: Build
+        env:
+          APP_INSIGHTS_KEY: '${{ secrets.APP_INSIGHTS_KEY }}'
         run: |
+          echo "APP INSIGHTS KEY LENGTH: ${#APP_INSIGHTS_KEY}"
           cd extensions/ql-vscode
           npm run build -- --release
         shell: bash
@@ -59,11 +57,8 @@ jobs:
           REF_NAME="$(echo ${{ github.ref }} | sed -e 's:^refs/tags/::' | sed -e 's:/:-:g')"
           echo "::set-output name=ref_name::$REF_NAME"
 
-      # Uploading artifacts is not necessary to create a release.
-      # This is just in case the release itself fails and we want to access the built artifacts from Actions.
-      # TODO Remove if not useful.
       - name: Upload artifacts
-        uses: actions/upload-artifact@master
+        uses: actions/upload-artifact@v2
         with:
           name: vscode-codeql-extension
           path: artifacts
@@ -97,6 +92,10 @@ jobs:
           asset_name: ${{ format('vscode-codeql-{0}.vsix', steps.prepare-artifacts.outputs.ref_name) }}
           asset_content_type: application/zip
 
+      ###
+      # Do Post release work: version bump and changelog PR
+      # Only do this if we are running from a PR (ie- this is part of the release process)
+
       # The checkout action does not fetch the main branch.
       # Fetch the main branch so that we can base the version bump PR against main.
       - name: Fetch main branch
@@ -114,8 +113,14 @@ jobs:
           NEXT_VERSION="$(npm version patch)"
           echo "::set-output name=next_version::$NEXT_VERSION"
 
+      - name: Add changelog for next release
+        if: success()
+        run: |
+          cd extensions/ql-vscode
+          perl -i -pe 's/^/## \[UNRELEASED\]\n\n/ if($.==3)' CHANGELOG.md
+
       - name: Create version bump PR
-        uses: peter-evans/create-pull-request@c7b64af0a489eae91f7890f2c1b63d13cc2d8ab7 # v2.4.2
+        uses: peter-evans/create-pull-request@c7f493a8000b8aeb17a1332e326ba76b57cb83eb # v3.4.1
         if: success()
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
@@ -124,3 +129,40 @@ jobs:
           body: This PR was automatically generated by the GitHub Actions release workflow in this repository.
           branch: ${{ format('version/bump-to-{0}', steps.bump-patch-version.outputs.next_version) }}
           base: main
+
+  vscode-publish:
+    name: Publish to VS Code Marketplace
+    needs: build
+    environment: publish-vscode-marketplace
+    runs-on: ubuntu-latest
+    env:
+      VSCE_TOKEN: ${{ secrets.VSCE_TOKEN }}
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v2
+        with:
+          name: vscode-codeql-extension
+
+      - name: Publish to Registry
+        run: |
+          npx vsce publish -p $VSCE_TOKEN --packagePath *.vsix || \
+            echo "Failed to publish to VS Code Marketplace. \
+                  If this was an authentication problem, please make sure the \
+                  auth token hasn't expired."
+
+  open-vsx-publish:
+    name: Publish to Open VSX Registry
+    needs: build
+    environment: publish-open-vsx
+    runs-on: ubuntu-latest
+    env:
+      OPEN_VSX_TOKEN: ${{ secrets.OPEN_VSX_TOKEN }}
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v2
+        with:
+          name: vscode-codeql-extension
+
+      - name: Publish to Registry
+        run: |
+          npx ovsx publish -p $OPEN_VSX_TOKEN *.vsix

.gitignore

@@ -4,6 +4,7 @@
 # Generated files
 /dist/
 out/
+build/
 server/
 node_modules/
 gen/

.vscode/extensions.json

@@ -1,5 +1,5 @@
 {
-  // See http://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
+  // See https://go.microsoft.com/fwlink/?LinkId=827846 to learn about workspace recommendations.
   // Extension identifier format: ${publisher}.${name}. Example: vscode.csharp
   // List of extensions which should be recommended for users of this workspace.
   "recommendations": [

.vscode/launch.json

@@ -8,17 +8,19 @@
       "request": "launch",
       "runtimeExecutable": "${execPath}",
       "args": [
-        "--extensionDevelopmentPath=${workspaceRoot}/extensions/ql-vscode"
+        "--extensionDevelopmentPath=${workspaceRoot}/extensions/ql-vscode",
+        // Add a reference to a workspace to open. Eg-
+        // "${workspaceRoot}/../vscode-codeql-starter/vscode-codeql-starter.code-workspace"
       ],
       "stopOnEntry": false,
       "sourceMaps": true,
       "outFiles": [
         "${workspaceRoot}/extensions/ql-vscode/out/**/*.js",
       ],
-      "preLaunchTask": "Build",
       "env": {
-        // uncomment to allow debugging the language server Java process from a remote java debugger
-        // "DEBUG_LANGUAGE_SERVER": "true"
+        // change to 'true' debug the IDE or Query servers
+        "IDE_SERVER_JAVA_DEBUG": "false",
+        "QUERY_SERVER_JAVA_DEBUG": "false",
       }
     },
     {
@@ -44,7 +46,6 @@
       "port": 9229,
       "stopOnEntry": false,
       "sourceMaps": true,
-      "preLaunchTask": "Build",
       "console": "integratedTerminal",
       "internalConsoleOptions": "neverOpen"
     },
@@ -62,7 +63,6 @@
       "outFiles": [
         "${workspaceRoot}/extensions/ql-vscode/out/**/*.js",
       ],
-      "preLaunchTask": "Build"
     },
     {
       "name": "Launch Integration Tests - Minimal Workspace (vscode-codeql)",
@@ -79,7 +79,25 @@
       "outFiles": [
         "${workspaceRoot}/extensions/ql-vscode/out/**/*.js",
       ],
-      "preLaunchTask": "Build"
+    },
+    {
+      "name": "Launch Integration Tests - With CLI",
+      "type": "extensionHost",
+      "request": "launch",
+      "runtimeExecutable": "${execPath}",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceRoot}/extensions/ql-vscode",
+        "--extensionTestsPath=${workspaceRoot}/extensions/ql-vscode/out/vscode-tests/cli-integration/index",
+        "${workspaceRoot}/extensions/ql-vscode/src/vscode-tests/cli-integration/data",
+        // Add a path to a checked out instance of the codeql repository so the libraries are
+        // available in the workspace for the tests.
+        // "${workspaceRoot}/../codeql"
+      ],
+      "stopOnEntry": false,
+      "sourceMaps": true,
+      "outFiles": [
+        "${workspaceRoot}/extensions/ql-vscode/out/**/*.js",
+      ],
     }
   ]
 }

CONTRIBUTING.md

@@ -25,12 +25,11 @@ Here are a few things you can do that will increase the likelihood of your pull
 * Follow the [style guide][style].
 * Write tests. Tests that don't require the VS Code API are located [here](extensions/ql-vscode/test). Integration tests that do require the VS Code API are located [here](extensions/ql-vscode/src/vscode-tests).
 * Keep your change as focused as possible. If there are multiple changes you would like to make that are not dependent upon each other, consider submitting them as separate pull requests.
-* Write a [good commit message](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
+* Write a [good commit message](https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html).
 
 ## Setting up a local build
 
-Make sure you have a fairly recent version of vscode (>1.32) and are using nodejs
-version >=v10.13.0. (Tested on v10.15.1 and v10.16.0).
+Make sure you have installed recent versions of vscode (>= v1.52), node (>=12.16), and npm (>= 7.5.2). Earlier versions will probably work, but we no longer test against them.
 
 ### Installing all packages
 
@@ -46,9 +45,18 @@ From the command line, go to the directory `extensions/ql-vscode` and run
 
 ```shell
 npm run build
+npm run watch
 ```
 
-Alternatively, you can build the extension within VS Code via `Terminal > Run Build Task...` (or `Ctrl+Shift+B` with the default key bindings).
+Alternatively, you can build the extension within VS Code via `Terminal > Run Build Task...` (or `Ctrl+Shift+B` with the default key bindings). And you can run the watch command via `Terminal > Run Task` and then select `npm watch` from the menu.
+
+Before running any of the launch commands, be sure to have run the `build` command to ensure that the JavaScript is compiled and the resources are copied to the proper location.
+
+We recommend that you keep `npm run watch` running in the backgound and you only need to re-run `npm run build` in the following situations:
+
+1. on first checkout
+2. whenever any of the non-TypeScript resources have changed
+3. on any change to files included in the webview
 
 ### Installing the extension
 
@@ -82,24 +90,55 @@ Alternatively, you can run the tests inside of vscode. There are several vscode
 
 ## Releasing (write access required)
 
-1. Double-check the `CHANGELOG.md` contains all desired change comments
-   and has the version to be released with date at the top.
-1. Double-check that the extension `package.json` has the version you intend to release.
-   If you are doing a patch release (as opposed to minor or major version) this should already
-   be correct.
-1. Trigger a release build on Actions by adding a new tag on branch `main` of the format `vxx.xx.xx`
+1. Double-check the `CHANGELOG.md` contains all desired change comments and has the version to be released with date at the top.
+    * Go through all recent PRs and make sure they are properly accounted for.
+    * Make sure all changelog entries have links back to their PR(s) if appropriate.
+1. Double-check that the extension `package.json` and `package-lock.json` have the version you intend to release. If you are doing a patch release (as opposed to minor or major version) this should already be correct.
+1. Create a PR for this release:
+    * This PR will contain any missing bits from steps 1 and 2. Most of the time, this will just be updating `CHANGELOG.md` with today's date.
+    * Create a new branch for the release named after the new version. For example: `v1.3.6`
+    * Create a new commit with a message the same as the branch name.
+    * Create a PR for this branch.
+    * Wait for the PR to be merged into `main`
+1. Trigger a release build on Actions by adding a new tag on branch `main` named after the release, as above. Note that when you push to upstream, you will need to fully qualify the ref. A command like this will work:
+
+    ```bash
+    git push upstream refs/tags/v1.3.6
+    ```
+
+    * **IMPORTANT** Make sure you are on the `main` branch and your local checkout is fully updated when you add the tag.
+    * If you accidentally add the tag to the wrong ref, you can just force push it to the right one later.
+
 1. Monitor the status of the release build in the `Release` workflow in the Actions tab.
 1. Download the VSIX from the draft GitHub release at the top of [the releases page](https://github.com/github/vscode-codeql/releases) that is created when the release build finishes.
-1. Optionally unzip the `.vsix` and inspect its `package.json` to make sure the version is what you expect,
+1. Unzip the `.vsix` and inspect its `package.json` to make sure the version is what you expect,
    or look at the source if there's any doubt the right code is being shipped.
-1. Log into the [Visual Studio Marketplace](https://marketplace.visualstudio.com/manage/publishers/github).
-1. Click the `...` menu in the CodeQL row and click **Update**.
-1. Drag the `.vsix` file you downloaded from the GitHub release into the Marketplace and click **Upload**.
-1. Go to the draft GitHub release, click 'Edit', add some summary description, and publish it.
+1. Go to the actions tab of the vscode-codeql repository and select the [Release workflow](https://github.com/github/vscode-codeql/actions?query=workflow%3ARelease).
+    - If there is an authentication failure when publishing, be sure to check that the authentication keys haven't expired. See below.
+1. Approve the deployments of the correct Release workflow. This will automatically publish to Open VSX and VS Code Marketplace.
+1. Go to the draft GitHub release in [the releases tab of the repository](https://github.com/github/vscode-codeql/releases), click 'Edit', add some summary description, and publish it.
 1. Confirm the new release is marked as the latest release at <https://github.com/github/vscode-codeql/releases>.
 1. If documentation changes need to be published, notify documentation team that release has been made.
 1. Review and merge the version bump PR that is automatically created by Actions.
 
+## Secrets and authentication for publishing
+
+Repository administrators, will need to manage the authentication keys for publishing to the VS Code marketplace and Open VSX. Each requires an authentication token. The VS Code marketplace token expires yearly.
+
+To regenerate the Open VSX token:
+
+1. Log in to the [user settings page on Open VSX](https://open-vsx.org/user-settings/namespaces).
+1. Make sure you are a member of the GitHub namespace.
+1. Go to the [Access Tokens](https://open-vsx.org/user-settings/tokens) page and generate a new token.
+1. Update the secret in the `publish-open-vsx` environment in the project settings.
+
+To regenerate the VSCode Marketplace token:
+
+1. Follow the instructions on [getting a PAT for Azure DevOps](https://code.visualstudio.com/api/working-with-extensions/publishing-extension#get-a-personal-access-token).
+1. Update the secret in the `publish-vscode-marketplace` environment in the project settings.
+
+Not that Azure DevOps PATs expire yearly and must be regenerated.
+
 ## Resources
 
 * [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)

README.md

@@ -16,7 +16,6 @@ To see what has changed in the last few versions of the extension, see the [Chan
 * Provides an easy way to run queries from the large, open source repository of [CodeQL security queries](https://github.com/github/codeql).
 * Adds IntelliSense to support you writing and editing your own CodeQL query and library files.
 
-
 ## Project goals and scope
 
 This project will track new feature development in CodeQL and, whenever appropriate, bring that functionality to the Visual Studio Code experience.

extensions/ql-vscode/CHANGELOG.md

@@ -1,5 +1,127 @@
 # CodeQL for Visual Studio Code: Changelog
 
+## 1.4.7 - 23 April 2021
+
+- Fix a bug that prevented the results view from being loaded. [#842](https://github.com/github/vscode-codeql/pull/842)
+
+## 1.4.6 - 21 April 2021
+
+- Avoid showing an error popup when running a query with `@kind table` metadata. [#814](https://github.com/github/vscode-codeql/pull/814)
+- Add an option to jump from a .qlref file to the .ql file it references. [#815](https://github.com/github/vscode-codeql/pull/815)
+- Avoid opening the results panel when a database is deleted. [#831](https://github.com/github/vscode-codeql/pull/831)
+- Forward all query metadata to the CLI when interpreting results. [#838](https://github.com/github/vscode-codeql/pull/838)
+
+## 1.4.5 - 22 March 2021
+
+- Avoid showing an error popup when user runs a query without `@kind` metadata. [#801](https://github.com/github/vscode-codeql/pull/801)
+- Fix running of tests when the `ms-python` extension is installed. [#803](https://github.com/github/vscode-codeql/pull/803)
+
+## 1.4.4 - 19 March 2021
+
+- Introduce evaluator options for saving intermediate results to the disk cache (`codeQL.runningQueries.saveCache`) and for limiting the size of this cache (`codeQL.runningQueries.cacheSize`). [#778](https://github.com/github/vscode-codeql/pull/778)
+- Respect the `codeQL.runningQueries.numberOfThreads` setting when creating SARIF files during result interpretation. [#771](https://github.com/github/vscode-codeql/pull/771)
+- Allow using raw LGTM project slugs for fetching LGTM databases. [#769](https://github.com/github/vscode-codeql/pull/769)
+- Better error messages when BQRS interpretation fails to produce SARIF. [#770](https://github.com/github/vscode-codeql/pull/770)
+- Implement sorting of the query history view by name, date, and results count. [#777](https://github.com/github/vscode-codeql/pull/777)
+- Add a configuration option to pass additional arguments to the CLI when running tests. [#785](https://github.com/github/vscode-codeql/pull/785)
+- Introduce option to view query results as CSV. [#784](https://github.com/github/vscode-codeql/pull/784)
+- Add some snippets for commonly used QL statements. [#782](https://github.com/github/vscode-codeql/pull/782)
+- More descriptive error messages on QL test failures. [#788](https://github.com/github/vscode-codeql/pull/788)
+
+## 1.4.3 - 22 February 2021
+
+- Avoid displaying an error when removing orphaned databases and the storage folder does not exist. [#748](https://github.com/github/vscode-codeql/pull/748)
+- Add better error messages when AST Viewer is unable to create an AST. [#753](https://github.com/github/vscode-codeql/pull/753)
+- Cache AST viewing operations so that subsequent calls to view the AST of a single file will be extremely fast. [#753](https://github.com/github/vscode-codeql/pull/753)
+- Ensure CodeQL version in status bar updates correctly when version changes. [#754](https://github.com/github/vscode-codeql/pull/754)
+- Avoid deleting the quick query file when it is re-opened. [#747](https://github.com/github/vscode-codeql/pull/747)
+
+## 1.4.2 - 2 February 2021
+
+- Add a status bar item for the CodeQL CLI to show the current version. [#741](https://github.com/github/vscode-codeql/pull/741)
+- Fix version constraint for flagging CLI support of non-destructive updates. [#744](https://github.com/github/vscode-codeql/pull/744)
+- Add a _More Information_ button in the telemetry popup that opens the [telemetry documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/about-telemetry-in-codeql-for-visual-studio-code) in a browser tab. [#742](https://github.com/github/vscode-codeql/pull/742)
+
+## 1.4.1 - 29 January 2021
+
+- Reword the telemetry modal dialog box. [#738](https://github.com/github/vscode-codeql/pull/738)
+
+## 1.4.0 - 29 January 2021
+
+- Fix bug where databases are not reregistered when the query server restarts. [#734](https://github.com/github/vscode-codeql/pull/734)
+- Fix bug where upgrade requests were erroneously being marked as failed. [#734](https://github.com/github/vscode-codeql/pull/734)
+- On a strictly opt-in basis, collect anonymized usage data from the VS Code extension, helping improve CodeQL's usability and performance. See the [telemetry documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/about-telemetry-in-codeql-for-visual-studio-code) for more information on exactly what data is collected and what it is used for. [#611](https://github.com/github/vscode-codeql/pull/611)
+
+## 1.3.10 - 20 January 2021
+
+- Include the full stack in error log messages to help with debugging. [#726](https://github.com/github/vscode-codeql/pull/726)
+
+## 1.3.9 - 12 January 2021
+
+- No changes visible to end users.
+
+## 1.3.8 - 17 December 2020
+
+- Ensure databases are unlocked when removing them from the workspace. This will ensure that after a database is removed from VS Code, queries can be run on it from the command line without restarting the IDE. Requires CodeQL CLI 2.4.1 or later. [#681](https://github.com/github/vscode-codeql/pull/681)
+- Fix bug when removing databases where sometimes the source folder would not also be removed from the workspace or the database files would not be deleted from the workspace storage location. [#692](https://github.com/github/vscode-codeql/pull/692)
+- Query results with no string representation will now be displayed with placeholder text in query results. Previously, they were omitted. [#694](https://github.com/github/vscode-codeql/pull/694)
+- Add a label for the language of a database in the databases view. This will only take effect for new databases created with the CodeQL CLI v2.4.1 or later. [#697](https://github.com/github/vscode-codeql/pull/697)
+- Add clearer error message when running a query using a missing or invalid qlpack. [#702](https://github.com/github/vscode-codeql/pull/702)
+- Add clearer error message when trying to run a command from the query history view if no item in the history is selected. [#702](https://github.com/github/vscode-codeql/pull/702)
+- Fix a bug where it is not possible to download some database archives. This fix specifically addresses large archives and archives whose central directories do not align with file headers. [#700](https://github.com/github/vscode-codeql/pull/700)
+- Avoid error dialogs when QL test discovery or database cleanup encounters a missing directory. [#706](https://github.com/github/vscode-codeql/pull/706)
+- Add descriptive text and a link in the results view. [#711](https://github.com/github/vscode-codeql/pull/711)
+- Fix the _Set Label_ command in the query history view. [#710](https://github.com/github/vscode-codeql/pull/710)
+- Add the _CodeQL: View AST_ command to the right-click context menu when a source file in a database source archive is open in the editor. [#712](https://github.com/github/vscode-codeql/pull/712)
+
+## 1.3.7 - 24 November 2020
+
+- Editors opened by navigating from the results view are no longer opened in _preview mode_. Now they are opened as a persistent editor. [#630](https://github.com/github/vscode-codeql/pull/630)
+- When comparing the results of a failed QL test run and the `.expected` file does not exist, an empty `.expected` file is created and compared against the `.actual` file. [#669](https://github.com/github/vscode-codeql/pull/669)
+- Alter structure of the _Test Explorer_ tree. It now follows the structure of the filesystem instead of the QL Packs. [#624](https://github.com/github/vscode-codeql/pull/624)
+- Alter structure of the _Test Explorer_ tree. It now follows the structure of the filesystem instead of the QL Packs. [#624](https://github.com/github/vscode-codeql/pull/624)
+- Add more structured output for tests. [#626](https://github.com/github/vscode-codeql/pull/626)
+- Whenever the extension restarts, orphaned databases will be cleaned up. These are databases whose files are located inside of the extension's storage area, but are not imported into the workspace.
+- After renaming a database, the database list is re-sorted. [#685](https://github.com/github/vscode-codeql/pull/685)
+- Add a `codeQl.resultsDisplay.pageSize` setting to configure the number of results displayed in a single results view page. Increase the default page size from 100 to 200. [#686](https://github.com/github/vscode-codeql/pull/686)
+- Update the AST Viewer to include edge labels (if available) in addition to the target node labels. So far, only C/C++ databases take advantage of this change. [#688](https://github.com/github/vscode-codeql/pull/688)
+
+## 1.3.6 - 4 November 2020
+
+- Fix URI encoding for databases that were created with special characters in their paths. [#648](https://github.com/github/vscode-codeql/pull/648)
+- Disable CodeQL Test commands from the command palette [#667](https://github.com/github/vscode-codeql/pull/667)
+- Fix display of booleans in results view. [#657](https://github.com/github/vscode-codeql/pull/657)
+- Avoid recursive selection changes in AST Viewer. [#668](https://github.com/github/vscode-codeql/pull/668)
+
+## 1.3.5 - 27 October 2020
+
+- Fix a bug where archived source folders for databases were not showing any contents.
+- Fix URI encoding for databases that were created with special characters in their paths.
+
+## 1.3.4 - 22 October 2020
+
+- Add friendly welcome message when the databases view is empty.
+- Add open query, open results, and remove query commands in the query history view title bar.
+- The maximum number of simultaneous queries launchable by the `CodeQL: Run Queries in Selected Files` command is now configurable by changing the `codeQL.runningQueries.maxQueries` setting.
+- Allow simultaneously run queries to be canceled in a single-click.
+- Prevent multiple upgrade dialogs from appearing when running simultaneous queries on upgradeable databases.
+- Fix sorting of results. Some pages of results would have the wrong sort order and columns.
+- Remember previous sort order when reloading query results.
+- Fix proper escaping of backslashes in SARIF message strings.
+- Allow setting `codeQL.runningQueries.numberOfThreads` and `codeQL.runningTests.numberOfThreads` to 0, (which is interpreted as 'use one thread per core on the machine').
+- Clear the problems view of all CodeQL query results when a database is removed.
+- Add a `View DIL` command on query history items. This opens a text editor containing the Datalog Intermediary Language representation of the compiled query.
+- Remove feature flag for the AST Viewer. For more information on how to use the AST Viewer, [see the documentation](https://help.semmle.com/codeql/codeql-for-vscode/procedures/exploring-the-structure-of-your-source-code.html).
+- The `codeQL.runningTests.numberOfThreads` setting is now used correctly when running tests.
+- Alter structure of the _Test Explorer_ tree. It now follows the structure of the filesystem instead of the qlpacks.
+- Ensure output of CodeQL test runs includes compilation error messages and test failure messages.
+
+## 1.3.3 - 16 September 2020
+
+- Fix display of raw results entities with label but no url.
+- Fix bug where sort order is forgotten when changing raw results page.
+- Avoid showing a location link in results view when a result item has an empty location.
+
 ## 1.3.2 - 12 August 2020
 
 - Fix error with choosing qlpack search path.

extensions/ql-vscode/README.md

@@ -1,6 +1,6 @@
 # CodeQL extension for Visual Studio Code
 
-This project is an extension for Visual Studio Code that adds rich language support for [CodeQL](https://help.semmle.com/codeql) and allows you to easily find problems in codebases. In particular, the extension:
+This project is an extension for Visual Studio Code that adds rich language support for [CodeQL](https://codeql.github.com/docs/) and allows you to easily find problems in codebases. In particular, the extension:
 
 - Enables you to use CodeQL to query databases generated from source code.
 - Shows the flow of data through the results of path queries, which is essential for triaging security results.
@@ -12,7 +12,7 @@ To see what has changed in the last few versions of the extension, see the [Chan
 ## Quick start overview
 
 The information in this `README` file describes the quickest way to start using CodeQL.
-For information about other configurations, see the separate [CodeQL help](https://help.semmle.com/codeql/codeql-for-vscode.html).
+For information about other configurations, see the separate [CodeQL help](https://codeql.github.com/docs/codeql-for-visual-studio-code/).
 
 ### Quick start: Installing and configuring the extension
 
@@ -40,9 +40,9 @@ The CodeQL extension requires a minimum of Visual Studio Code 1.39. Older versio
 
 ### Checking access to the CodeQL CLI
 
-The extension uses the [CodeQL CLI](https://help.semmle.com/codeql/codeql-cli.html) to compile and run queries. The extension automatically manages access to the CLI for you by default (recommended). To check for updates to the CodeQL CLI, you can use the **CodeQL: Check for CLI Updates** command.
+The extension uses the [CodeQL CLI](https://codeql.github.com/docs/codeql-cli/) to compile and run queries. The extension automatically manages access to the CLI for you by default (recommended). To check for updates to the CodeQL CLI, you can use the **CodeQL: Check for CLI Updates** command.
 
-If you want to override the default behavior and use a CodeQL CLI that's already on your machine, see [Configuring access to the CodeQL CLI](https://help.semmle.com/codeql/codeql-for-vscode/procedures/setting-up.html#configuring-access-to-the-codeql-cli).
+If you want to override the default behavior and use a CodeQL CLI that's already on your machine, see [Configuring access to the CodeQL CLI](https://codeql.github.com/docs/codeql-for-visual-studio-code/setting-up-codeql-in-visual-studio-code/#configuring-access-to-the-codeql-cli).
 
 If you have any difficulty with CodeQL CLI access, see the **CodeQL Extension Log** in the **Output** view for any error messages.
 
@@ -52,7 +52,7 @@ When you're working with CodeQL, you need access to the standard CodeQL librarie
 Initially, we recommend that you clone and use the ready-to-use [starter workspace](https://github.com/github/vscode-codeql-starter/).
 This includes libraries and queries for the main supported languages, with folders set up ready for your custom queries. After cloning the workspace (use `git clone --recursive`), you can use it in the same way as any other VS Code workspace—with the added advantage that you can easily update the CodeQL libraries.
 
-For information about configuring an existing workspace for CodeQL, [see the documentation](https://help.semmle.com/codeql/codeql-for-vscode/procedures/setting-up.html#updating-an-existing-workspace-for-codeql).
+For information about configuring an existing workspace for CodeQL, [see the documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/setting-up-codeql-in-visual-studio-code/#updating-an-existing-workspace-for-codeql).
 
 ## Upgrading CodeQL standard libraries
 
@@ -75,7 +75,7 @@ You can find all the commands contributed by the extension in the Command Palett
 
 ### Importing a database from LGTM
 
-While you can use the [CodeQL CLI to create your own databases](https://help.semmle.com/codeql/codeql-cli/procedures/create-codeql-database.html), the simplest way to start is by downloading a database from LGTM.com.
+While you can use the [CodeQL CLI to create your own databases](https://codeql.github.com/docs/codeql-cli/creating-codeql-databases/), the simplest way to start is by downloading a database from LGTM.com.
 
 1. Open [LGTM.com](https://lgtm.com/#explore) in your browser.
 1. Search for a project you're interested in, for example [Apache Kafka](https://lgtm.com/projects/g/apache/kafka).
@@ -100,13 +100,17 @@ If there are any problems running a query, a notification is displayed in the bo
 
 ## What next?
 
-For more information about the CodeQL extension, [see the documentation](https://help.semmle.com/codeql/codeql-for-vscode.html). Otherwise, you could:
+For more information about the CodeQL extension, [see the documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/). Otherwise, you could:
 
-- [Create a database for a different codebase](https://help.semmle.com/codeql/codeql-cli/procedures/create-codeql-database.html).
+- [Create a database for a different codebase](https://codeql.github.com/docs/codeql-cli/creating-codeql-databases/).
 - [Try out variant analysis](https://help.semmle.com/QL/learn-ql/ql-training.html).
-- [Learn more about CodeQL](https://help.semmle.com/QL/learn-ql/).
+- [Learn more about CodeQL](https://codeql.github.com/docs/).
 - [Read how security researchers use CodeQL to find CVEs](https://securitylab.github.com/research).
 
 ## License
 
 The CodeQL extension for Visual Studio Code is [licensed](LICENSE.md) under the MIT License. The version of CodeQL used by the CodeQL extension is subject to the [GitHub CodeQL Terms & Conditions](https://securitylab.github.com/tools/codeql/license).
+
+## Data and Telemetry
+
+If you specifically opt-in to permit GitHub to do so, GitHub will collect usage data and metrics for the purposes of helping the core developers to improve the CodeQL extension for VS Code. This data will not be shared with any parties outside of GitHub. IP addresses and installation IDs will be retained for a maximum of 30 days. Anonymous data will be retained for a maximum of 180 days. For more information about telemetry, [see the documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/about-telemetry-in-codeql-for-visual-studio-code).

extensions/ql-vscode/gulpfile.ts/appInsights.ts

@@ -0,0 +1,16 @@
+import * as gulp from 'gulp';
+import * as replace from 'gulp-replace';
+
+/** Inject the application insights key into the telemetry file */
+export function injectAppInsightsKey() {
+  if (!process.env.APP_INSIGHTS_KEY) {
+    // noop
+    console.log('APP_INSIGHTS_KEY environment variable is not set. So, cannot inject it into the application.');
+    return Promise.resolve();
+  }
+
+  // replace the key
+  return gulp.src(['out/telemetry.js'])
+    .pipe(replace(/REPLACE-APP-INSIGHTS-KEY/, process.env.APP_INSIGHTS_KEY))
+    .pipe(gulp.dest('out/'));
+}

extensions/ql-vscode/gulpfile.ts/deploy.ts

@@ -13,6 +13,7 @@ const packageFiles = [
   'CHANGELOG.md',
   'README.md',
   'language-configuration.json',
+  'snippets.json',
   'media',
   'node_modules',
   'out'

extensions/ql-vscode/gulpfile.ts/index.ts

@@ -4,7 +4,12 @@ import { compileTextMateGrammar } from './textmate';
 import { copyTestData } from './tests';
 import { compileView } from './webpack';
 import { packageExtension } from './package';
+import { injectAppInsightsKey } from './appInsights';
 
-export const buildWithoutPackage = gulp.parallel(compileTypeScript, compileTextMateGrammar, compileView, copyTestData, copyViewCss);
-export { compileTextMateGrammar, watchTypeScript, compileTypeScript };
-exports.default = gulp.series(exports.buildWithoutPackage, packageExtension);
+export const buildWithoutPackage =
+  gulp.parallel(
+    compileTypeScript, compileTextMateGrammar, compileView, copyTestData, copyViewCss
+  );
+
+export { compileTextMateGrammar, watchTypeScript, compileTypeScript, copyTestData, injectAppInsightsKey };
+export default gulp.series(buildWithoutPackage, injectAppInsightsKey, packageExtension);

extensions/ql-vscode/gulpfile.ts/tests.ts

@@ -1,6 +1,17 @@
 import * as gulp from 'gulp';
 
 export function copyTestData() {
+  copyNoWorkspaceData();
+  copyCliIntegrationData();
+  return Promise.resolve();
+}
+
+function copyNoWorkspaceData() {
   return gulp.src('src/vscode-tests/no-workspace/data/**/*')
     .pipe(gulp.dest('out/vscode-tests/no-workspace/data'));
 }
+
+function copyCliIntegrationData() {
+  return gulp.src('src/vscode-tests/cli-integration/data/**/*')
+    .pipe(gulp.dest('out/vscode-tests/cli-integration/data'));
+}

extensions/ql-vscode/gulpfile.ts/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "$schema": "http://json.schemastore.org/tsconfig",
+  "$schema": "https://json.schemastore.org/tsconfig",
   "compilerOptions": {
     "declaration": true,
     "strict": true,

extensions/ql-vscode/gulpfile.ts/webpack.config.ts

@@ -13,7 +13,10 @@ export const config: webpack.Configuration = {
   },
   devtool: 'inline-source-map',
   resolve: {
-    extensions: ['.js', '.ts', '.tsx', '.json']
+    extensions: ['.js', '.ts', '.tsx', '.json'],
+    fallback: {
+      path: require.resolve('path-browserify')
+    }
   },
   module: {
     rules: [

extensions/ql-vscode/gulpfile.ts/webpack.ts

@@ -6,21 +6,23 @@ export function compileView(cb: (err?: Error) => void) {
     if (error) {
       cb(error);
     }
-    console.log(stats.toString({
-      errorDetails: true,
-      colors: true,
-      assets: false,
-      builtAt: false,
-      version: false,
-      hash: false,
-      entrypoints: false,
-      timings: false,
-      modules: false,
-      errors: true
-    }));
-    if (stats.hasErrors()) {
-      cb(new Error('Compilation errors detected.'));
-      return;
+    if (stats) {
+      console.log(stats.toString({
+        errorDetails: true,
+        colors: true,
+        assets: false,
+        builtAt: false,
+        version: false,
+        hash: false,
+        entrypoints: false,
+        timings: false,
+        modules: false,
+        errors: true
+      }));
+      if (stats.hasErrors()) {
+        cb(new Error('Compilation errors detected.'));
+        return;
+      }
     }
 
     cb();

extensions/ql-vscode/media/dark/edit.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.23 1H11.77L3.52002 9.25L3.35999 9.46997L1 13.59L2.41003 15L6.53003 12.64L6.75 12.48L15 4.22998V2.77002L13.23 1ZM2.41003 13.59L3.92004 10.59L5.37 12.04L2.41003 13.59ZM6.23999 11.53L4.46997 9.76001L12.47 1.76001L14.24 3.53003L6.23999 11.53Z" fill="#C5C5C5"/>
+</svg>

extensions/ql-vscode/media/dark/preview.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M2 2H14L15 3V13L14 14H2L1 13V3L2 2ZM2 13H14V3H2V13ZM13 4H3V7H13V4ZM12 6H4V5H12V6ZM9 12H13V8H9V12ZM10 9H12V11H10V9ZM7 8H3V9H7V8ZM3 11H7V12H3V11Z" fill="#C5C5C5"/>
+</svg>

extensions/ql-vscode/media/dark/sort-num.svg

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" fill="none"
+	 viewBox="0 0 432 432" style="enable-background:new 0 0 432 432;" xml:space="preserve">
+<g>
+	<g>
+		<g>
+			<polygon points="234.24,9.067 183.893,59.413 284.587,59.413" fill="#C5C5C5"/>
+			<path d="m 259.24622,341.40906 v -32.34375 q 13.35937,6.32812 27.07031,9.66797 13.71094,3.33984 26.89453,3.33984 35.15625,0 53.61328,-23.55469 18.63282,-23.73047 21.26953,-71.89453 -10.19531,15.11719 -25.83984,23.20313 -15.64453,8.08593 -34.62891,8.08593 -39.375,0 -62.40234,-23.73046 -22.85156,-23.90625 -22.85156,-65.21485 0,-40.42969 23.90625,-64.86328 23.90625,-24.433594 63.63281,-24.433594 45.52734,0 69.43359,34.980474 24.08204,34.80468 24.08204,101.25 0,62.05078 -29.53125,99.14062 -29.35547,36.91406 -79.10157,36.91406 -13.35937,0 -27.07031,-2.63672 -13.71094,-2.63671 -28.47656,-7.91015 z m 70.66406,-111.26953 q 23.90625,0 37.79297,-16.34766 14.0625,-16.34766 14.0625,-44.82422 0,-28.30078 -14.0625,-44.64844 -13.88672,-16.52343 -37.79297,-16.52343 -23.90625,0 -37.96875,16.52343 -13.88672,16.34766 -13.88672,44.64844 0,28.47656 13.88672,44.82422 14.0625,16.34766 37.96875,16.34766 z" fill="#C5C5C5" />
+			<polygon points="234.24,422.933 283.947,373.227 184.533,373.227" fill="#C5C5C5"/>
+			<path d="M 35.300905,316.97546 H 93.308718 V 116.76062 L 30.203249,129.41687 V 97.07312 L 92.957155,84.41687 h 35.507815 v 232.55859 h 58.00781 v 29.88282 H 35.300905 Z" fill="#C5C5C5"/>
+		</g>
+	</g>
+</g>
+</svg>

extensions/ql-vscode/media/dark/trash.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10 3H12H13V4H12V13L11 14H4L3 13V4H2V3H5V2C5 1.73478 5.10531 1.48038 5.29285 1.29285C5.48038 1.10531 5.73478 1 6 1H9C9.26522 1 9.51962 1.10531 9.70715 1.29285C9.89469 1.48038 10 1.73478 10 2V3ZM9 2H6V3H9V2ZM4 13H11V4H4V13ZM6 5H5V12H6V5ZM7 5H8V12H7V5ZM9 5H10V12H9V5Z" fill="#C5C5C5"/>
+</svg>

extensions/ql-vscode/media/light/edit.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M13.2302 1H11.7703L3.52026 9.25L3.36023 9.46997L1.00024 13.59L2.41028 15L6.53027 12.64L6.75024 12.48L15.0002 4.22998V2.77002L13.2302 1ZM2.41028 13.59L3.92029 10.59L5.37024 12.04L2.41028 13.59ZM6.24023 11.53L4.47021 9.76001L12.4702 1.76001L14.2402 3.53003L6.24023 11.53Z" fill="#424242"/>
+</svg>

extensions/ql-vscode/media/light/preview.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M2.00024 2H14.0002L15.0002 3V13L14.0002 14H2.00024L1.00024 13V3L2.00024 2ZM2.00024 13H14.0002V3H2.00024V13ZM13.0002 4H3.00024V7H13.0002V4ZM12.0002 6H4.00024V5H12.0002V6ZM9.00024 12H13.0002V8H9.00024V12ZM10.0002 9H12.0002V11H10.0002V9ZM7.00024 8H3.00024V9H7.00024V8ZM3.00024 11H7.00024V12H3.00024V11Z" fill="#424242"/>
+</svg>

extensions/ql-vscode/media/light/sort-num.svg

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 19.0.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Capa_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="0 0 432 432" style="enable-background:new 0 0 432 432;" xml:space="preserve">
+<g>
+	<g>
+		<g>
+			<polygon points="234.24,9.067 183.893,59.413 284.587,59.413" />
+			<path d="m 259.24622,341.40906 v -32.34375 q 13.35937,6.32812 27.07031,9.66797 13.71094,3.33984 26.89453,3.33984 35.15625,0 53.61328,-23.55469 18.63282,-23.73047 21.26953,-71.89453 -10.19531,15.11719 -25.83984,23.20313 -15.64453,8.08593 -34.62891,8.08593 -39.375,0 -62.40234,-23.73046 -22.85156,-23.90625 -22.85156,-65.21485 0,-40.42969 23.90625,-64.86328 23.90625,-24.433594 63.63281,-24.433594 45.52734,0 69.43359,34.980474 24.08204,34.80468 24.08204,101.25 0,62.05078 -29.53125,99.14062 -29.35547,36.91406 -79.10157,36.91406 -13.35937,0 -27.07031,-2.63672 -13.71094,-2.63671 -28.47656,-7.91015 z m 70.66406,-111.26953 q 23.90625,0 37.79297,-16.34766 14.0625,-16.34766 14.0625,-44.82422 0,-28.30078 -14.0625,-44.64844 -13.88672,-16.52343 -37.79297,-16.52343 -23.90625,0 -37.96875,16.52343 -13.88672,16.34766 -13.88672,44.64844 0,28.47656 13.88672,44.82422 14.0625,16.34766 37.96875,16.34766 z" />
+			<polygon points="234.24,422.933 283.947,373.227 184.533,373.227" />
+			<path d="M 35.300905,316.97546 H 93.308718 V 116.76062 L 30.203249,129.41687 V 97.07312 L 92.957155,84.41687 h 35.507815 v 232.55859 h 58.00781 v 29.88282 H 35.300905 Z" />
+		</g>
+	</g>
+</g>
+</svg>

extensions/ql-vscode/media/light/trash.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M10.0002 3H12.0002H13.0002V4H12.0002V13L11.0002 14H4.00024L3.00024 13V4H2.00024V3H5.00024V2C5.00024 1.73478 5.10555 1.48038 5.29309 1.29285C5.48063 1.10531 5.73503 1 6.00024 1H9.00024C9.26546 1 9.51986 1.10531 9.7074 1.29285C9.89493 1.48038 10.0002 1.73478 10.0002 2V3ZM9.00024 2H6.00024V3H9.00024V2ZM4.00024 13H11.0002V4H4.00024V13ZM6.00024 5H5.00024V12H6.00024V5ZM7.00024 5H8.00024V12H7.00024V5ZM9.00024 5H10.0002V12H9.00024V5Z" fill="#424242"/>
+</svg>

extensions/ql-vscode/package.json

@@ -4,7 +4,7 @@
   "description": "CodeQL for Visual Studio Code",
   "author": "GitHub",
   "private": true,
-  "version": "1.3.2",
+  "version": "1.4.7",
   "publisher": "GitHub",
   "license": "MIT",
   "icon": "media/VS-marketplace-CodeQL-icon.png",
@@ -34,6 +34,7 @@
     "onCommand:codeQLDatabases.chooseDatabaseLgtm",
     "onCommand:codeQL.setCurrentDatabase",
     "onCommand:codeQL.viewAst",
+    "onCommand:codeQL.openReferencedFile",
     "onCommand:codeQL.chooseDatabaseFolder",
     "onCommand:codeQL.chooseDatabaseArchive",
     "onCommand:codeQL.chooseDatabaseInternet",
@@ -106,6 +107,12 @@
         "path": "./out/syntaxes/dbscheme.tmLanguage.json"
       }
     ],
+    "snippets": [
+      {
+        "language": "ql",
+        "path": "./snippets.json"
+      }
+    ],
     "configuration": {
       "type": "object",
       "title": "CodeQL",
@@ -114,15 +121,30 @@
           "scope": "machine",
           "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. This overrides all other CodeQL CLI settings."
+          "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."
         },
         "codeQL.runningQueries.numberOfThreads": {
           "type": "integer",
           "default": 1,
-          "minimum": 1,
+          "minimum": 0,
           "maximum": 1024,
           "description": "Number of threads for running queries."
         },
+        "codeQL.runningQueries.saveCache": {
+          "type": "boolean",
+          "default": false,
+          "scope": "window",
+          "description": "Aggressively save intermediate results to the disk cache. This may speed up subsequent queries if they are similar. Be aware that using this option will greatly increase disk usage and initial evaluation time."
+        },
+        "codeQL.runningQueries.cacheSize": {
+          "type": [
+            "integer",
+            "null"
+          ],
+          "default": null,
+          "minimum": 1024,
+          "description": "Maximum size of the disk cache (in MB). Leave blank to allow the evaluator to automatically adjust the size of the disk cache based on the size of the codebase and the complexity of the queries being executed."
+        },
         "codeQL.runningQueries.timeout": {
           "type": [
             "integer",
@@ -152,18 +174,46 @@
           "default": false,
           "description": "Enable automatically saving a modified query file when running a query."
         },
+        "codeQL.runningQueries.maxQueries": {
+          "type": "integer",
+          "default": 20,
+          "description": "Max number of simultaneous queries to run using the 'CodeQL: Run Queries' command."
+        },
+        "codeQL.resultsDisplay.pageSize": {
+          "type": "integer",
+          "default": 200,
+          "description": "Max number of query results to display per page in the results view."
+        },
         "codeQL.queryHistory.format": {
           "type": "string",
-          "default": "[%t] %q on %d - %s",
-          "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, and %s is a status string."
+          "default": "%q on %d - %s, %r result count [%t]",
+          "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",
+          "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."
         },
         "codeQL.runningTests.numberOfThreads": {
           "scope": "window",
           "type": "integer",
           "default": 1,
-          "minimum": 1,
+          "minimum": 0,
           "maximum": 1024,
           "description": "Number of threads for running CodeQL tests."
+        },
+        "codeQL.telemetry.enableTelemetry": {
+          "type": "boolean",
+          "default": false,
+          "scope": "application",
+          "markdownDescription": "Specifies whether to send CodeQL usage telemetry. This setting AND the global `#telemetry.enableTelemetry#` setting must be checked for telemetry to be sent to GitHub. For more information, see the [telemetry documentation](https://codeql.github.com/docs/codeql-for-visual-studio-code/about-telemetry-in-codeql-for-visual-studio-code)"
+        },
+        "codeQL.telemetry.logTelemetry": {
+          "type": "boolean",
+          "default": false,
+          "scope": "application",
+          "description": "Specifies whether or not to write telemetry events to the extension log."
         }
       }
     },
@@ -180,10 +230,18 @@
         "command": "codeQL.quickEval",
         "title": "CodeQL: Quick Evaluation"
       },
+      {
+        "command": "codeQL.openReferencedFile",
+        "title": "CodeQL: Open Referenced File"
+      },
       {
         "command": "codeQL.quickQuery",
         "title": "CodeQL: Quick Query"
       },
+      {
+        "command": "codeQL.openDocumentation",
+        "title": "CodeQL: Open Documentation"
+      },
       {
         "command": "codeQLDatabases.chooseDatabaseFolder",
         "title": "Choose Database from Folder",
@@ -192,6 +250,10 @@
           "dark": "media/dark/folder-opened-plus.svg"
         }
       },
+      {
+        "command": "codeQLDatabases.removeOrphanedDatabases",
+        "title": "Delete unused databases"
+      },
       {
         "command": "codeQLDatabases.chooseDatabaseArchive",
         "title": "Choose Database from Archive",
@@ -290,15 +352,51 @@
       },
       {
         "command": "codeQLQueryHistory.openQuery",
-        "title": "Open Query"
-      },
-      {
-        "command": "codeQLQueryHistory.removeHistoryItem",
-        "title": "Remove History Item"
+        "title": "Open the query that produced these results",
+        "icon": {
+          "light": "media/light/edit.svg",
+          "dark": "media/dark/edit.svg"
+        }
       },
       {
         "command": "codeQLQueryHistory.itemClicked",
-        "title": "Query History Item"
+        "title": "Open Query Results",
+        "icon": {
+          "light": "media/light/preview.svg",
+          "dark": "media/dark/preview.svg"
+        }
+      },
+      {
+        "command": "codeQLQueryHistory.removeHistoryItem",
+        "title": "Remove History Item(s)",
+        "icon": {
+          "light": "media/light/trash.svg",
+          "dark": "media/dark/trash.svg"
+        }
+      },
+      {
+        "command": "codeQLQueryHistory.sortByName",
+        "title": "Sort by Name",
+        "icon": {
+          "light": "media/light/sort-alpha.svg",
+          "dark": "media/dark/sort-alpha.svg"
+        }
+      },
+      {
+        "command": "codeQLQueryHistory.sortByDate",
+        "title": "Sort by Query Date",
+        "icon": {
+          "light": "media/light/sort-date.svg",
+          "dark": "media/dark/sort-date.svg"
+        }
+      },
+      {
+        "command": "codeQLQueryHistory.sortByCount",
+        "title": "Sort by Results Count",
+        "icon": {
+          "light": "media/light/sort-num.svg",
+          "dark": "media/dark/sort-num.svg"
+        }
       },
       {
         "command": "codeQLQueryHistory.showQueryLog",
@@ -309,8 +407,16 @@
         "title": "Show Query Text"
       },
       {
-        "command": "codeQLQueryHistory.viewSarif",
-        "title": "View SARIF"
+        "command": "codeQLQueryHistory.viewCsvResults",
+        "title": "View Results (CSV)"
+      },
+      {
+        "command": "codeQLQueryHistory.viewSarifResults",
+        "title": "View Results (SARIF)"
+      },
+      {
+        "command": "codeQLQueryHistory.viewDil",
+        "title": "View DIL"
       },
       {
         "command": "codeQLQueryHistory.setLabel",
@@ -334,11 +440,11 @@
       },
       {
         "command": "codeQLTests.showOutputDifferences",
-        "title": "CodeQL: Show Test Output Differences"
+        "title": "Show Test Output Differences"
       },
       {
         "command": "codeQLTests.acceptOutput",
-        "title": "CodeQL: Accept Test Output"
+        "title": "Accept Test Output"
       },
       {
         "command": "codeQLAstViewer.gotoCode",
@@ -385,9 +491,39 @@
           "when": "view == codeQLDatabases",
           "group": "navigation"
         },
+        {
+          "command": "codeQLQueryHistory.openQuery",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLQueryHistory.itemClicked",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLQueryHistory.removeHistoryItem",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLQueryHistory.sortByName",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLQueryHistory.sortByDate",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLQueryHistory.sortByCount",
+          "when": "view == codeQLQueryHistory",
+          "group": "navigation"
+        },
         {
           "command": "codeQLAstViewer.clear",
-          "when": "view == codeQLAstViewer && config.codeQL.experimentalAstViewer == true",
+          "when": "view == codeQLAstViewer",
           "group": "navigation"
         }
       ],
@@ -448,10 +584,20 @@
           "when": "view == codeQLQueryHistory"
         },
         {
-          "command": "codeQLQueryHistory.viewSarif",
+          "command": "codeQLQueryHistory.viewCsvResults",
           "group": "9_qlCommands",
           "when": "view == codeQLQueryHistory && viewItem == interpretedResultsItem"
         },
+        {
+          "command": "codeQLQueryHistory.viewSarifResults",
+          "group": "9_qlCommands",
+          "when": "view == codeQLQueryHistory && viewItem == interpretedResultsItem"
+        },
+        {
+          "command": "codeQLQueryHistory.viewDil",
+          "group": "9_qlCommands",
+          "when": "view == codeQLQueryHistory"
+        },
         {
           "command": "codeQLTests.showOutputDifferences",
           "group": "qltest@1",
@@ -472,11 +618,17 @@
         {
           "command": "codeQL.viewAst",
           "group": "9_qlCommands",
-          "when": "resourceScheme == codeql-zip-archive && config.codeQL.experimentalAstViewer == true"
+          "when": "resourceScheme == codeql-zip-archive"
         },
         {
           "command": "codeQL.runQueries",
-          "group": "9_qlCommands"
+          "group": "9_qlCommands",
+          "when": "resourceScheme != codeql-zip-archive"
+        },
+        {
+          "command": "codeQL.openReferencedFile",
+          "group": "9_qlCommands",
+          "when": "resourceExtname == .qlref"
         }
       ],
       "commandPalette": [
@@ -492,6 +644,10 @@
           "command": "codeQL.quickEval",
           "when": "editorLangId == ql"
         },
+        {
+          "command": "codeQL.openReferencedFile",
+          "when": "resourceExtname == .qlref"
+        },
         {
           "command": "codeQL.setCurrentDatabase",
           "when": "false"
@@ -532,6 +688,10 @@
           "command": "codeQLDatabases.chooseDatabaseArchive",
           "when": "false"
         },
+        {
+          "command": "codeQLDatabases.removeOrphanedDatabases",
+          "when": "false"
+        },
         {
           "command": "codeQLDatabases.chooseDatabaseInternet",
           "when": "false"
@@ -565,7 +725,15 @@
           "when": "false"
         },
         {
-          "command": "codeQLQueryHistory.viewSarif",
+          "command": "codeQLQueryHistory.viewCsvResults",
+          "when": "false"
+        },
+        {
+          "command": "codeQLQueryHistory.viewSarifResults",
+          "when": "false"
+        },
+        {
+          "command": "codeQLQueryHistory.viewDil",
           "when": "false"
         },
         {
@@ -576,6 +744,18 @@
           "command": "codeQLQueryHistory.compareWith",
           "when": "false"
         },
+        {
+          "command": "codeQLQueryHistory.sortByName",
+          "when": "false"
+        },
+        {
+          "command": "codeQLQueryHistory.sortByDate",
+          "when": "false"
+        },
+        {
+          "command": "codeQLQueryHistory.sortByCount",
+          "when": "false"
+        },
         {
           "command": "codeQLAstViewer.gotoCode",
           "when": "false"
@@ -583,6 +763,14 @@
         {
           "command": "codeQLAstViewer.clear",
           "when": "false"
+        },
+        {
+          "command": "codeQLTests.acceptOutput",
+          "when": "false"
+        },
+        {
+          "command": "codeQLTests.showOutputDifferences",
+          "when": "false"
         }
       ],
       "editor/context": [
@@ -590,9 +778,17 @@
           "command": "codeQL.runQuery",
           "when": "editorLangId == ql && resourceExtname == .ql"
         },
+        {
+          "command": "codeQL.viewAst",
+          "when": "resourceScheme == codeql-zip-archive"
+        },
         {
           "command": "codeQL.quickEval",
           "when": "editorLangId == ql"
+        },
+        {
+          "command": "codeQL.openReferencedFile",
+          "when": "resourceExtname == .qlref"
         }
       ]
     },
@@ -617,20 +813,22 @@
         },
         {
           "id": "codeQLAstViewer",
-          "name": "AST Viewer",
-          "when": "config.codeQL.experimentalAstViewer == true"
+          "name": "AST Viewer"
         }
       ]
     },
     "viewsWelcome": [
       {
         "view": "codeQLAstViewer",
-        "contents": "Run the 'CodeQL: View AST' command on an open source file from a Code QL database.\n[View AST](command:codeQL.viewAst)",
-        "when": "config.codeQL.experimentalAstViewer == true"
+        "contents": "Run the 'CodeQL: View AST' command on an open source file from a CodeQL database.\n[View AST](command:codeQL.viewAst)"
       },
       {
         "view": "codeQLQueryHistory",
-        "contents": "Run the 'CodeQL: Run Query' command on QL query.\n[Run Query](command:codeQL.runQuery)"
+        "contents": "Run the 'CodeQL: Run Query' command on a QL query.\n[Run Query](command:codeQL.runQuery)"
+      },
+      {
+        "view": "codeQLDatabases",
+        "contents": "Add a CodeQL database:\n[From a folder](command:codeQLDatabases.chooseDatabaseFolder)\n[From an archive](command:codeQLDatabases.chooseDatabaseArchive)\n[From a URL (as a zip file)](command:codeQLDatabases.chooseDatabaseInternet)\n[From LGTM](command:codeQLDatabases.chooseDatabaseLgtm)"
       }
     ]
   },
@@ -640,7 +838,8 @@
     "watch:extension": "tsc --watch",
     "test": "mocha --exit -r ts-node/register test/pure-tests/**/*.ts",
     "preintegration": "rm -rf ./out/vscode-tests && gulp",
-    "integration": "node ./out/vscode-tests/run-integration-tests.js",
+    "integration": "node ./out/vscode-tests/run-integration-tests.js no-workspace,minimal-workspace",
+    "cli-integration": "npm run preintegration && node ./out/vscode-tests/run-integration-tests.js cli-integration",
     "update-vscode": "node ./node_modules/vscode/bin/install",
     "format": "tsfmt -r && eslint src test --ext .ts,.tsx --fix",
     "lint": "eslint src test --ext .ts,.tsx --max-warnings=0",
@@ -649,11 +848,12 @@
   "dependencies": {
     "child-process-promise": "^2.2.1",
     "classnames": "~2.2.6",
-    "fs-extra": "^8.1.0",
+    "fs-extra": "^9.0.1",
     "glob-promise": "^3.4.0",
     "js-yaml": "^3.14.0",
     "minimist": "~1.2.5",
     "node-fetch": "~2.6.0",
+    "path-browserify": "^1.0.1",
     "react": "^16.8.6",
     "react-dom": "^16.8.6",
     "semver": "~7.3.2",
@@ -661,6 +861,7 @@
     "tmp-promise": "~3.0.2",
     "tree-kill": "~1.2.2",
     "unzipper": "~0.10.5",
+    "vscode-extension-telemetry": "^0.1.6",
     "vscode-jsonrpc": "^5.0.1",
     "vscode-languageclient": "^6.1.3",
     "vscode-test-adapter-api": "~1.7.0",
@@ -668,25 +869,26 @@
     "zip-a-folder": "~0.0.12"
   },
   "devDependencies": {
-    "@types/semver": "~7.2.0",
     "@types/chai": "^4.1.7",
     "@types/chai-as-promised": "~7.1.2",
     "@types/child-process-promise": "^2.2.1",
     "@types/classnames": "~2.2.9",
-    "@types/fs-extra": "^8.0.0",
+    "@types/fs-extra": "^9.0.6",
     "@types/glob": "^7.1.1",
     "@types/google-protobuf": "^3.2.7",
     "@types/gulp": "^4.0.6",
+    "@types/gulp-replace": "0.0.31",
     "@types/gulp-sourcemaps": "0.0.32",
-    "@types/js-yaml": "~3.12.2",
+    "@types/js-yaml": "^3.12.5",
     "@types/jszip": "~3.1.6",
-    "@types/mocha": "~5.2.7",
-    "@types/node": "^12.0.8",
+    "@types/mocha": "^8.2.0",
+    "@types/node": "^12.14.1",
     "@types/node-fetch": "~2.5.2",
     "@types/proxyquire": "~1.3.28",
     "@types/react": "^16.8.17",
     "@types/react-dom": "^16.8.4",
     "@types/sarif": "~2.1.2",
+    "@types/semver": "~7.2.0",
     "@types/sinon": "~7.5.2",
     "@types/sinon-chai": "~3.2.3",
     "@types/through2": "^2.0.36",
@@ -698,6 +900,7 @@
     "@typescript-eslint/eslint-plugin": "~2.23.0",
     "@typescript-eslint/parser": "~2.23.0",
     "ansi-colors": "^4.1.1",
+    "applicationinsights": "^1.8.7",
     "chai": "^4.2.0",
     "chai-as-promised": "~7.1.1",
     "css-loader": "~3.1.0",
@@ -705,12 +908,13 @@
     "eslint-plugin-react": "~7.19.0",
     "glob": "^7.1.4",
     "gulp": "^4.0.2",
+    "gulp-replace": "^1.0.0",
     "gulp-sourcemaps": "^2.6.5",
     "gulp-typescript": "^5.0.1",
     "husky": "~4.2.5",
     "jsonc-parser": "^2.3.0",
     "lint-staged": "~10.2.2",
-    "mocha": "~6.2.1",
+    "mocha": "^8.2.1",
     "mocha-sinon": "~2.1.0",
     "npm-run-all": "^4.1.5",
     "prettier": "~2.0.5",
@@ -719,15 +923,15 @@
     "sinon-chai": "~3.5.0",
     "style-loader": "~0.23.1",
     "through2": "^3.0.1",
-    "ts-loader": "^5.4.5",
+    "ts-loader": "^8.1.0",
     "ts-node": "^8.3.0",
     "ts-protoc-gen": "^0.9.0",
     "typescript": "~3.8.3",
     "typescript-formatter": "^7.2.2",
     "vsce": "^1.65.0",
     "vscode-test": "^1.4.0",
-    "webpack": "^4.38.0",
-    "webpack-cli": "^3.3.2"
+    "webpack": "^5.28.0",
+    "webpack-cli": "^4.6.0"
   },
   "husky": {
     "hooks": {

extensions/ql-vscode/snippets.json

@@ -0,0 +1,134 @@
+{
+  "Query Metadata": {
+    "prefix": "querymetadata",
+    "body": [
+      "/**",
+      " * @name $1",
+      " * @description $2",
+      " * @kind $3",
+      " * @id $4",
+      " * @tags $5",
+      " */"
+    ],
+    "description": "Metadata for a query"
+  },
+  "Class": {
+    "prefix": "class",
+    "body": ["class $1 extends $2 {", "\t$0", "}"],
+    "description": "A class"
+  },
+  "From/Where/Select": {
+    "prefix": "from",
+    "body": ["from $1", "where $2", "select $3"],
+    "description": "A from/where/select statement"
+  },
+  "Predicate": {
+    "prefix": "predicate",
+    "body": ["predicate $1($2) {", "\t$0", "}"],
+    "description": "A predicate"
+  },
+  "Dataflow Tracking Class": {
+    "prefix": "dataflowtracking",
+    "body": [
+      "class $1 extends DataFlow::Configuration {",
+      "\t$1() { this = \"$1\" }",
+      "\t",
+      "\toverride predicate isSource(DataFlow::Node node) {",
+      "\t\t${2:none()}",
+      "\t}",
+      "\t",
+      "\toverride predicate isSink(DataFlow::Node node) {",
+      "\t\t${3:none()}",
+      "\t}",
+      "}"
+    ],
+    "description": "Boilerplate for a dataflow tracking class"
+  },
+  "Taint Tracking Class": {
+    "prefix": "tainttracking",
+    "body": [
+      "class $1 extends TaintTracking::Configuration {",
+      "\t$1() { this = \"$1\" }",
+      "\t",
+      "\toverride predicate isSource(DataFlow::Node node) {",
+      "\t\t${2:none()}",
+      "\t}",
+      "\t",
+      "\toverride predicate isSink(DataFlow::Node node) {",
+      "\t\t${3:none()}",
+      "\t}",
+      "}"
+    ],
+    "description": "Boilerplate for a taint tracking class"
+  },
+  "Count": {
+    "prefix": "count",
+    "body": ["count($1 | $2 | $3)"],
+    "description": "A count aggregate"
+  },
+  "Max": {
+    "prefix": "max",
+    "body": ["max($1 | $2 | $3)"],
+    "description": "A max aggregate"
+  },
+  "Min": {
+    "prefix": "min",
+    "body": ["min($1 | $2 | $3)"],
+    "description": "A min aggregate"
+  },
+  "Average": {
+    "prefix": "avg",
+    "body": ["avg($1 | $2 | $3)"],
+    "description": "An average aggregate"
+  },
+  "Sum": {
+    "prefix": "sum",
+    "body": ["sum($1 | $2 | $3)"],
+    "description": "A sum aggregate"
+  },
+  "Concatenation": {
+    "prefix": "concat",
+    "body": ["concat($1 | $2 | $3)"],
+    "description": "A concatenation aggregate"
+  },
+  "Rank": {
+    "prefix": "rank",
+    "body": ["rank[$1]($2 | $3 | $4)"],
+    "description": "A rank aggregate"
+  },
+  "Strict Sum": {
+    "prefix": "strictsum",
+    "body": ["strictsum($1 | $2 | $3)"],
+    "description": "A strict sum aggregate"
+  },
+  "Strict Concatenation": {
+    "prefix": "strictconcat",
+    "body": ["strictconcat($1 | $2 | $3)"],
+    "description": "A strict concatenation aggregate"
+  },
+  "Strict Count": {
+    "prefix": "strictcount",
+    "body": ["strictcount($1 | $2 | $3)"],
+    "description": "A strict count aggregate"
+  },
+  "Unique": {
+    "prefix": "unique",
+    "body": ["unique($1 | $2 | $3)"],
+    "description": "A unique aggregate"
+  },
+  "Exists": {
+    "prefix": "exists",
+    "body": ["exists($1 | $2 | $3)"],
+    "description": "An exists quantifier"
+  },
+  "For All": {
+    "prefix": "forall",
+    "body": ["forall($1 | $2 | $3)"],
+    "description": "A for all quantifier"
+  },
+  "For All and Exists": {
+    "prefix": "forex",
+    "body": ["forex($1 | $2 | $3)"],
+    "description": "A for all and exists quantifier"
+  }
+}

extensions/ql-vscode/src/adapt.ts

@@ -1,113 +0,0 @@
-import { DecodedBqrsChunk, ResultSetSchema, ColumnKind, Column, ColumnValue } from './bqrs-cli-types';
-import { LocationValue, ResultSetSchema as AdaptedSchema, ColumnSchema, ColumnType, LocationStyle } from './bqrs-types';
-import { ResultSet } from './interface-types';
-
-// FIXME: This is a temporary bit of impedance matching to convert
-// from the types provided by ./bqrs-cli-types, to the types used by
-// the view layer.
-//
-// The reason that it is benign for now is that it is only used by
-// feature-flag-guarded codepaths that won't be encountered by normal
-// users. It is not yet guaranteed to produce correct output for raw
-// results.
-//
-// Eventually, the view layer should be refactored to directly accept data
-// of types coming from bqrs-cli-types, and this file can be deleted.
-
-export type ResultRow = ResultValue[];
-
-export interface ResultElement {
-  label: string;
-  location?: LocationValue;
-}
-
-export interface ResultUri {
-  uri: string;
-}
-
-export type ResultValue = ResultElement | ResultUri | string;
-
-export interface RawResultSet {
-  readonly schema: AdaptedSchema;
-  readonly rows: readonly ResultRow[];
-}
-
-function adaptKind(kind: ColumnKind): ColumnType {
-  // XXX what about 'u'?
-  if (kind === 'e') {
-    return { type: 'e', primitiveType: 's', locationStyle: LocationStyle.FivePart, hasLabel: true };
-  }
-  else {
-    return { type: kind };
-  }
-}
-
-function adaptColumn(col: Column): ColumnSchema {
-  return { name: col.name!, type: adaptKind(col.kind) };
-}
-
-export function adaptSchema(schema: ResultSetSchema): AdaptedSchema {
-  return {
-    columns: schema.columns.map(adaptColumn),
-    name: schema.name,
-    tupleCount: schema.rows,
-    version: 0,
-  };
-}
-
-export function adaptValue(val: ColumnValue): ResultValue {
-  // XXX taking a lot of incorrect shortcuts here
-
-  if (typeof val === 'string') {
-    return val;
-  }
-
-  if (typeof val === 'number' || typeof val === 'boolean') {
-    return val + '';
-  }
-
-  const url = val.url;
-
-  if (typeof url === 'string') {
-    return url;
-  }
-
-  if (url === undefined) {
-    return 'none';
-  }
-
-  return {
-    label: val.label || '',
-    location: {
-      t: LocationStyle.FivePart,
-      lineStart: url.startLine,
-      lineEnd: url.endLine,
-      colStart: url.startColumn,
-      colEnd: url.endColumn,
-      // FIXME: This seems definitely wrong. Should we be using
-      // something like the code in sarif-utils.ts?
-      file: url.uri.replace(/file:/, ''),
-    }
-  };
-
-}
-
-export function adaptRow(row: ColumnValue[]): ResultRow {
-  return row.map(adaptValue);
-}
-
-export function adaptBqrs(schema: AdaptedSchema, page: DecodedBqrsChunk): RawResultSet {
-  return {
-    schema,
-    rows: page.tuples.map(adaptRow),
-  };
-}
-
-export interface ParsedResultSets {
-  pageNumber: number;
-  numPages: number;
-  numInterpretedPages: number;
-  selectedTable?: string; // when undefined, means 'show default table'
-  resultSetNames: string[];
-  resultSet: ResultSet;
-}

extensions/ql-vscode/src/archive-filesystem-provider.ts

@@ -84,12 +84,25 @@ export function encodeSourceArchiveUri(ref: ZipFileReference): vscode.Uri {
   // This lets us separate the paths, ignoring the leading slash if we added one.
   const sourceArchiveZipPathEndIndex = sourceArchiveZipPathStartIndex + sourceArchiveZipPath.length;
   const authority = `${sourceArchiveZipPathStartIndex}-${sourceArchiveZipPathEndIndex}`;
-  return vscode.Uri.parse(zipArchiveScheme + ':/').with({
+  return vscode.Uri.parse(zipArchiveScheme + ':/', true).with({
     path: encodedPath,
     authority,
   });
 }
 
+/**
+ * Convenience method to create a codeql-zip-archive with a path to the root
+ * archive
+ *
+ * @param pathToArchive the filesystem path to the root of the archive
+ */
+export function encodeArchiveBasePath(sourceArchiveZipPath: string) {
+  return encodeSourceArchiveUri({
+    sourceArchiveZipPath,
+    pathWithinSourceArchive: ''
+  });
+}
+
 const sourceArchiveUriAuthorityPattern = /^(\d+)-(\d+)$/;
 
 class InvalidSourceArchiveUriError extends Error {
@@ -100,6 +113,14 @@ class InvalidSourceArchiveUriError extends Error {
 
 /** Decodes an encoded source archive URI into its corresponding paths. Inverse of `encodeSourceArchiveUri`. */
 export function decodeSourceArchiveUri(uri: vscode.Uri): ZipFileReference {
+  if (!uri.authority) {
+    // Uri is malformed, but this is recoverable
+    logger.log(`Warning: ${new InvalidSourceArchiveUriError(uri).message}`);
+    return {
+      pathWithinSourceArchive: '/',
+      sourceArchiveZipPath: uri.path
+    };
+  }
   const match = sourceArchiveUriAuthorityPattern.exec(uri.authority);
   if (match === null)
     throw new InvalidSourceArchiveUriError(uri);
@@ -108,7 +129,7 @@ export function decodeSourceArchiveUri(uri: vscode.Uri): ZipFileReference {
   if (isNaN(zipPathStartIndex) || isNaN(zipPathEndIndex))
     throw new InvalidSourceArchiveUriError(uri);
   return {
-    pathWithinSourceArchive: uri.path.substring(zipPathEndIndex),
+    pathWithinSourceArchive: uri.path.substring(zipPathEndIndex) || '/',
     sourceArchiveZipPath: uri.path.substring(zipPathStartIndex, zipPathEndIndex),
   };
 }

extensions/ql-vscode/src/astViewer.ts

@@ -1,61 +1,79 @@
-import * as vscode from 'vscode';
+import {
+  window,
+  TreeDataProvider,
+  EventEmitter,
+  Event,
+  ProviderResult,
+  TreeItemCollapsibleState,
+  TreeItem,
+  TreeView,
+  TextEditorSelectionChangeEvent,
+  TextEditorSelectionChangeKind,
+  Location,
+  Range
+} from 'vscode';
+import * as path from 'path';
 
 import { DatabaseItem } from './databases';
-import { UrlValue, BqrsId } from './bqrs-cli-types';
-import fileRangeFromURI from './contextual/fileRangeFromURI';
+import { UrlValue, BqrsId } from './pure/bqrs-cli-types';
 import { showLocation } from './interface-utils';
+import { isStringLoc, isWholeFileLoc, isLineColumnLoc } from './pure/bqrs-utils';
+import { commandRunner } from './commandRunner';
+import { DisposableObject } from './pure/disposable-object';
+import { showAndLogErrorMessage } from './helpers';
 
 export interface AstItem {
   id: BqrsId;
   label?: string;
   location?: UrlValue;
-  parent: AstItem | RootAstItem;
-  children: AstItem[];
+  fileLocation?: Location;
+  children: ChildAstItem[];
   order: number;
 }
 
-export type RootAstItem = Omit<AstItem, 'parent'>;
+export interface ChildAstItem extends AstItem {
+  parent: ChildAstItem | AstItem;
+}
 
-class AstViewerDataProvider implements vscode.TreeDataProvider<AstItem | RootAstItem> {
+class AstViewerDataProvider extends DisposableObject implements TreeDataProvider<AstItem> {
 
-  public roots: RootAstItem[] = [];
+  public roots: AstItem[] = [];
   public db: DatabaseItem | undefined;
 
   private _onDidChangeTreeData =
-    new vscode.EventEmitter<AstItem | undefined>();
-  readonly onDidChangeTreeData: vscode.Event<AstItem | undefined> =
+    this.push(new EventEmitter<AstItem | undefined>());
+  readonly onDidChangeTreeData: Event<AstItem | undefined> =
     this._onDidChangeTreeData.event;
 
   constructor() {
-    vscode.commands.registerCommand('codeQLAstViewer.gotoCode',
-      async (location: UrlValue, db: DatabaseItem) => {
-        if (location) {
-          await showLocation(fileRangeFromURI(location, db));
-        }
-      });
-    }
+    super();
+    this.push(
+      commandRunner('codeQLAstViewer.gotoCode',
+        async (item: AstItem) => {
+          await showLocation(item.fileLocation);
+        })
+    );
+  }
 
   refresh(): void {
     this._onDidChangeTreeData.fire();
   }
-  getChildren(item?: AstItem): vscode.ProviderResult<(AstItem | RootAstItem)[]> {
+  getChildren(item?: AstItem): ProviderResult<AstItem[]> {
     const children = item ? item.children : this.roots;
     return children.sort((c1, c2) => (c1.order - c2.order));
   }
 
-  getParent(item: AstItem): vscode.ProviderResult<AstItem> {
-    return item.parent as AstItem;
+  getParent(item: ChildAstItem): ProviderResult<AstItem> {
+    return item.parent;
   }
 
-  getTreeItem(item: AstItem): vscode.TreeItem {
-    const line = typeof item.location === 'string'
-      ? item.location
-      : item.location?.startLine;
+  getTreeItem(item: AstItem): TreeItem {
+    const line = this.extractLineInfo(item?.location);
 
     const state = item.children.length
-      ? vscode.TreeItemCollapsibleState.Collapsed
-      : vscode.TreeItemCollapsibleState.None;
-    const treeItem = new vscode.TreeItem(item.label || '', state);
+      ? TreeItemCollapsibleState.Collapsed
+      : TreeItemCollapsibleState.None;
+    const treeItem = new TreeItem(item.label || '', state);
     treeItem.description = line ? `Line ${line}` : '';
     treeItem.id = String(item.id);
     treeItem.tooltip = `${treeItem.description} ${treeItem.label}`;
@@ -63,34 +81,117 @@ class AstViewerDataProvider implements vscode.TreeDataProvider<AstItem | RootAst
       command: 'codeQLAstViewer.gotoCode',
       title: 'Go To Code',
       tooltip: `Go To ${item.location}`,
-      arguments: [item.location, this.db]
+      arguments: [item]
     };
     return treeItem;
   }
+
+  private extractLineInfo(loc?: UrlValue) {
+    if (!loc) {
+      return '';
+    } else if (isStringLoc(loc)) {
+      return loc;
+    } else if (isWholeFileLoc(loc)) {
+      return loc.uri;
+    } else if (isLineColumnLoc(loc)) {
+      return loc.startLine;
+    } else {
+      return '';
+    }
+  }
 }
 
-export class AstViewer {
-  private treeView: vscode.TreeView<AstItem | RootAstItem>;
+export class AstViewer extends DisposableObject {
+  private treeView: TreeView<AstItem>;
   private treeDataProvider: AstViewerDataProvider;
+  private currentFile: string | undefined;
 
   constructor() {
+    super();
+
     this.treeDataProvider = new AstViewerDataProvider();
-    this.treeView = vscode.window.createTreeView('codeQLAstViewer', {
+    this.treeView = window.createTreeView('codeQLAstViewer', {
       treeDataProvider: this.treeDataProvider,
       showCollapseAll: true
     });
 
-    vscode.commands.registerCommand('codeQLAstViewer.clear', () => {
-      this.clear();
-    });
+    this.push(this.treeView);
+    this.push(this.treeDataProvider);
+    this.push(
+      commandRunner('codeQLAstViewer.clear', async () => {
+        this.clear();
+      })
+    );
+    this.push(window.onDidChangeTextEditorSelection(this.updateTreeSelection, this));
   }
 
-  updateRoots(roots: RootAstItem[], db: DatabaseItem, fileName: string) {
+  updateRoots(roots: AstItem[], db: DatabaseItem, fileName: string) {
     this.treeDataProvider.roots = roots;
     this.treeDataProvider.db = db;
     this.treeDataProvider.refresh();
-    this.treeView.message = `AST for ${fileName}`;
-    this.treeView.reveal(roots[0], { focus: true });
+    this.treeView.message = `AST for ${path.basename(fileName)}`;
+    this.currentFile = fileName;
+    // Handle error on reveal. This could happen if
+    // the tree view is disposed during the reveal.
+    this.treeView.reveal(roots[0], { focus: false })?.then(
+      () => { /**/ },
+      err => showAndLogErrorMessage(err)
+    );
+  }
+
+  private updateTreeSelection(e: TextEditorSelectionChangeEvent) {
+    function isInside(selectedRange: Range, astRange?: Range): boolean {
+      return !!astRange?.contains(selectedRange);
+    }
+
+    // Recursively iterate all children until we find the node with the smallest
+    // range that contains the selection.
+    // Some nodes do not have a location, but their children might, so must
+    // recurse though location-less AST nodes to see if children are correct.
+    function findBest(selectedRange: Range, items?: AstItem[]): AstItem | undefined {
+      if (!items || !items.length) {
+        return;
+      }
+      for (const item of items) {
+        let candidate: AstItem | undefined = undefined;
+        if (isInside(selectedRange, item.fileLocation?.range)) {
+          candidate = item;
+        }
+        // always iterate through children since the location of an AST node in code QL does not
+        // always cover the complete text of the node.
+        candidate = findBest(selectedRange, item.children) || candidate;
+        if (candidate) {
+          return candidate;
+        }
+      }
+      return;
+    }
+
+    // Avoid recursive tree-source code updates.
+    if (e.kind === TextEditorSelectionChangeKind.Command) {
+      return;
+    }
+
+    if (
+      this.treeView.visible &&
+      e.textEditor.document.uri.fsPath === this.currentFile &&
+      e.selections.length === 1
+    ) {
+      const selection = e.selections[0];
+      const range = selection.anchor.isBefore(selection.active)
+        ? new Range(selection.anchor, selection.active)
+        : new Range(selection.active, selection.anchor);
+
+      const targetItem = findBest(range, this.treeDataProvider.roots);
+      if (targetItem) {
+        // Handle error on reveal. This could happen if
+        // the tree view is disposed during the reveal.
+        this.treeView.reveal(targetItem)?.then(
+          () => { /**/ },
+          err => showAndLogErrorMessage(err)
+        );
+      }
+    }
   }
 
   private clear() {
@@ -98,5 +199,6 @@ export class AstViewer {
     this.treeDataProvider.db = undefined;
     this.treeDataProvider.refresh();
     this.treeView.message = undefined;
+    this.currentFile = undefined;
   }
 }

extensions/ql-vscode/src/bqrs-types.ts

@@ -1,102 +0,0 @@
-/**
- * TODO: Types in this file are deprecated, and uses of them should be
- * migrated to the analogous types in bqrs-cli-types.
- */
-
-export enum LocationStyle {
-  None = 0,
-  String,
-  FivePart,
-  /** Does not occur in BQRS files. Used only to distinguish whole-file locations in client code. */
-  WholeFile
-}
-
-/**
- * A primitive type (any type other than an element).
- */
-export type PrimitiveTypeKind = 's' | 'b' | 'i' | 'f' | 'd' | 'u';
-
-/**
- * A kind of type that a column may have.
- */
-export type ColumnTypeKind = PrimitiveTypeKind | 'e';
-
-/**
- * A column type that is a primitive type.
- */
-export interface PrimitiveColumnType {
-  type: PrimitiveTypeKind;
-}
-
-/**
- * A column type that is an element type.
- */
-export interface ElementColumnType {
-  type: 'e';
-  primitiveType: PrimitiveTypeKind;
-  locationStyle: LocationStyle;
-  hasLabel: boolean;
-}
-
-/**
- * The type of a column.
- */
-export type ColumnType = PrimitiveColumnType | ElementColumnType;
-
-/**
- * The schema describing a single column in a `ResultSet`.
- */
-export interface ColumnSchema {
-  readonly name: string;
-  readonly type: ColumnType;
-}
-
-/**
- * The schema of a single `ResultSet` in a BQRS file.
- */
-export interface ResultSetSchema {
-  readonly version: number;
-  readonly name: string;
-  readonly tupleCount: number;
-  readonly columns: readonly ColumnSchema[];
-}
-
-/**
- * The schema describing the contents of a BQRS file.
- */
-export interface ResultSetsSchema {
-  readonly version: number;
-  readonly stringPoolSize: number;
-  readonly resultSets: readonly ResultSetSchema[];
-}
-
-// See https://help.semmle.com/QL/learn-ql/ql/locations.html for how these are used.
-export interface FivePartLocation {
-  t: LocationStyle.FivePart;
-  file: string;
-  lineStart: number;
-  colStart: number;
-  lineEnd: number;
-  colEnd: number;
-}
-
-export interface StringLocation {
-  t: LocationStyle.String;
-  loc: string;
-}
-
-/**
- * A location representing an entire filesystem resource.
- * This is usually derived from a `StringLocation` with the entire filesystem URL.
- */
-export interface WholeFileLocation {
-  t: LocationStyle.WholeFile;
-  file: string;
-}
-
-export type RawLocationValue = FivePartLocation | StringLocation;
-
-export type LocationValue = RawLocationValue | WholeFileLocation;
-
-/** A location that may be resolved to a source code element. */
-export type ResolvableLocationValue = FivePartLocation | WholeFileLocation;

extensions/ql-vscode/src/bqrs-utils.ts

@@ -1,64 +0,0 @@
-import { StringLocation, LocationValue, LocationStyle, ResolvableLocationValue } from './bqrs-types';
-
-/**
- * The CodeQL filesystem libraries use this pattern in `getURL()` predicates
- * to describe the location of an entire filesystem resource.
- * Such locations appear as `StringLocation`s instead of `FivePartLocation`s.
- *
- * Folder resources also get similar URLs, but with the `folder` scheme.
- * They are deliberately ignored here, since there is no suitable location to show the user.
- */
-const FILE_LOCATION_REGEX = /file:\/\/(.+):([0-9]+):([0-9]+):([0-9]+):([0-9]+)/;
-/**
- * Gets a resolvable source file location for the specified `LocationValue`, if possible.
- * @param loc The location to test.
- */
-export function tryGetResolvableLocation(
-  loc: LocationValue | undefined
-): ResolvableLocationValue | undefined {
-  if (loc === undefined) {
-    return undefined;
-  } else if (loc.t === LocationStyle.FivePart && loc.file) {
-    return loc;
-  } else if (loc.t === LocationStyle.WholeFile && loc.file) {
-    return loc;
-  } else if (loc.t === LocationStyle.String && loc.loc) {
-    return tryGetLocationFromString(loc);
-  } else {
-    return undefined;
-  }
-}
-
-export function tryGetLocationFromString(
-  loc: StringLocation
-): ResolvableLocationValue | undefined {
-  const matches = FILE_LOCATION_REGEX.exec(loc.loc);
-  if (matches && matches.length > 1 && matches[1]) {
-    if (isWholeFileMatch(matches)) {
-      return {
-        t: LocationStyle.WholeFile,
-        file: matches[1],
-      };
-    } else {
-      return {
-        t: LocationStyle.FivePart,
-        file: matches[1],
-        lineStart: Number(matches[2]),
-        colStart: Number(matches[3]),
-        lineEnd: Number(matches[4]),
-        colEnd: Number(matches[5]),
-      };
-    }
-  } else {
-    return undefined;
-  }
-}
-
-function isWholeFileMatch(matches: RegExpExecArray): boolean {
-  return (
-    matches[2] === '0' &&
-    matches[3] === '0' &&
-    matches[4] === '0' &&
-    matches[5] === '0'
-  );
-}

extensions/ql-vscode/src/cli.ts

@@ -4,22 +4,31 @@ import * as child_process from 'child_process';
 import * as fs from 'fs-extra';
 import * as path from 'path';
 import * as sarif from 'sarif';
+import { SemVer } from 'semver';
 import { Readable } from 'stream';
 import { StringDecoder } from 'string_decoder';
 import * as tk from 'tree-kill';
-import * as util from 'util';
+import { promisify } from 'util';
 import { CancellationToken, Disposable } from 'vscode';
-import { BQRSInfo, DecodedBqrsChunk } from './bqrs-cli-types';
-import { DistributionProvider } from './distribution';
-import { assertNever } from './helpers-pure';
-import { QueryMetadata, SortDirection } from './interface-types';
+
+import { BQRSInfo, DecodedBqrsChunk } from './pure/bqrs-cli-types';
+import { CliConfig } from './config';
+import { DistributionProvider, FindDistributionResultKind } from './distribution';
+import { assertNever } from './pure/helpers-pure';
+import { QueryMetadata, SortDirection } from './pure/interface-types';
 import { Logger, ProgressReporter } from './logging';
+import { CompilationMessage } from './pure/messages';
 
 /**
  * The version of the SARIF format that we are using.
  */
 const SARIF_FORMAT = 'sarifv2.1.0';
 
+/**
+ * The string used to specify CSV format.
+ */
+const CSV_FORMAT = 'csv';
+
 /**
  * Flags to pass to all cli commands.
  */
@@ -46,6 +55,7 @@ export interface DbInfo {
   sourceArchiveRoot: string;
   datasetFolder: string;
   logsFolder: string;
+  languages: string[];
 }
 
 /**
@@ -54,6 +64,7 @@ export interface DbInfo {
 export interface UpgradesInfo {
   scripts: string[];
   finalDbscheme: string;
+  matchesTarget?: boolean;
 }
 
 /**
@@ -61,6 +72,11 @@ export interface UpgradesInfo {
  */
 export type QlpacksInfo = { [name: string]: string[] };
 
+/**
+ * The expected output of `codeql resolve qlref`.
+ */
+export type QlrefInfo = { resolvedPath: string };
+
 // `codeql bqrs interpret` requires both of these to be present or
 // both absent.
 export interface SourceInfo {
@@ -87,10 +103,12 @@ export interface TestRunOptions {
 export interface TestCompleted {
   test: string;
   pass: boolean;
-  messages: string[];
+  messages: CompilationMessage[];
   compilationMs: number;
   evaluationMs: number;
   expected: string;
+  diff: string[] | undefined;
+  failureDescription?: string;
 }
 
 /**
@@ -113,6 +131,7 @@ interface BqrsDecodeOptions {
  */
 export class CodeQLCliServer implements Disposable {
 
+
   /** The process for the cli server, or undefined if one doesn't exist yet */
   process?: child_process.ChildProcessWithoutNullStreams;
   /** Queue of future commands*/
@@ -122,18 +141,41 @@ export class CodeQLCliServer implements Disposable {
   /**  A buffer with a single null byte. */
   nullBuffer: Buffer;
 
-  constructor(private config: DistributionProvider, private logger: Logger) {
+  /** Version of current cli, lazily computed by the `getVersion()` method */
+  private _version: SemVer | undefined;
+
+  /** Path to current codeQL executable, or undefined if not running yet. */
+  codeQlPath: string | undefined;
+
+  cliConstraints = new CliVersionConstraint(this);
+
+  /**
+   * When set to true, ignore some modal popups and assume user has clicked "yes".
+   */
+  public quiet = false;
+
+  constructor(
+    private distributionProvider: DistributionProvider,
+    private cliConfig: CliConfig,
+    private logger: Logger
+  ) {
     this.commandQueue = [];
     this.commandInProcess = false;
     this.nullBuffer = Buffer.alloc(1);
-    if (this.config.onDidChangeDistribution) {
-      this.config.onDidChangeDistribution(() => {
+    if (this.distributionProvider.onDidChangeDistribution) {
+      this.distributionProvider.onDidChangeDistribution(() => {
         this.restartCliServer();
+        this._version = undefined;
+      });
+    }
+    if (this.cliConfig.onDidChangeConfiguration) {
+      this.cliConfig.onDidChangeConfiguration(() => {
+        this.restartCliServer();
+        this._version = undefined;
       });
     }
   }
 
-
   dispose(): void {
     this.killProcessIfRunning();
   }
@@ -188,7 +230,7 @@ export class CodeQLCliServer implements Disposable {
    * Get the path to the CodeQL CLI distribution, or throw an exception if not found.
    */
   private async getCodeQlPath(): Promise<string> {
-    const codeqlPath = await this.config.getCodeQlPathWithoutVersionCheck();
+    const codeqlPath = await this.distributionProvider.getCodeQlPathWithoutVersionCheck();
     if (!codeqlPath) {
       throw new Error('Failed to find CodeQL distribution.');
     }
@@ -199,8 +241,15 @@ export class CodeQLCliServer implements Disposable {
    * Launch the cli server
    */
   private async launchProcess(): Promise<child_process.ChildProcessWithoutNullStreams> {
-    const config = await this.getCodeQlPath();
-    return spawnServer(config, 'CodeQL CLI Server', ['execute', 'cli-server'], [], this.logger, _data => { /**/ });
+    const codeQlPath = await this.getCodeQlPath();
+    return await spawnServer(
+      codeQlPath,
+      'CodeQL CLI Server',
+      ['execute', 'cli-server'],
+      [],
+      this.logger,
+      _data => { /**/ }
+    );
   }
 
   private async runCodeQlCliInternal(command: string[], commandArgs: string[], description: string): Promise<string> {
@@ -224,7 +273,7 @@ export class CodeQLCliServer implements Disposable {
       const argsString = args.join(' ');
       this.logger.log(`${description} using CodeQL CLI: ${argsString}...`);
       try {
-        await new Promise((resolve, reject) => {
+        await new Promise<void>((resolve, reject) => {
           // Start listening to stdout
           process.stdout.addListener('data', (newData: Buffer) => {
             stdoutBuffers.push(newData);
@@ -403,12 +452,15 @@ export class CodeQLCliServer implements Disposable {
    * @param command The `codeql` command to be run, provided as an array of command/subcommand names.
    * @param commandArgs The arguments to pass to the `codeql` command.
    * @param description Description of the action being run, to be shown in log and error messages.
+   * @param addFormat Whether or not to add commandline arguments to specify the format as JSON.
    * @param progressReporter Used to output progress messages, e.g. to the status bar.
    * @returns The contents of the command's stdout, if the command succeeded.
    */
-  async runJsonCodeQlCliCommand<OutputType>(command: string[], commandArgs: string[], description: string, progressReporter?: ProgressReporter): Promise<OutputType> {
-    // Add format argument first, in case commandArgs contains positional parameters.
-    const args = ['--format', 'json'].concat(commandArgs);
+  async runJsonCodeQlCliCommand<OutputType>(command: string[], commandArgs: string[], description: string, addFormat = true, progressReporter?: ProgressReporter): Promise<OutputType> {
+    let args: string[] = [];
+    if (addFormat) // Add format argument first, in case commandArgs contains positional parameters.
+      args = args.concat(['--format', 'json']);
+    args = args.concat(commandArgs);
     const result = await this.runCodeQlCliCommand(command, args, description, progressReporter);
     try {
       return JSON.parse(result) as OutputType;
@@ -440,7 +492,23 @@ export class CodeQLCliServer implements Disposable {
     const subcommandArgs = [
       testPath
     ];
-    return await this.runJsonCodeQlCliCommand<ResolvedTests>(['resolve', 'tests'], subcommandArgs, 'Resolving tests');
+    return await this.runJsonCodeQlCliCommand<ResolvedTests>(
+      ['resolve', 'tests', '--strict-test-discovery'],
+      subcommandArgs,
+      'Resolving tests'
+    );
+  }
+
+  public async resolveQlref(qlref: string): Promise<QlrefInfo> {
+    const subcommandArgs = [
+      qlref
+    ];
+    return await this.runJsonCodeQlCliCommand<QlrefInfo>(
+      ['resolve', 'qlref'],
+      subcommandArgs,
+      'Resolving qlref',
+      false
+    );
   }
 
   /**
@@ -453,11 +521,12 @@ export class CodeQLCliServer implements Disposable {
     testPaths: string[], workspaces: string[], options: TestRunOptions
   ): AsyncGenerator<TestCompleted, void, unknown> {
 
-    const subcommandArgs = [
+    const subcommandArgs = this.cliConfig.additionalTestArguments.concat([
       '--additional-packs', workspaces.join(path.delimiter),
-      '--threads', '8',
+      '--threads',
+      this.cliConfig.numberTestThreads.toString(),
       ...testPaths
-    ];
+    ]);
 
     for await (const event of await this.runAsyncCodeQlCliCommand<TestCompleted>(['test', 'run'],
       subcommandArgs, 'Run CodeQL Tests', options.cancellationToken, options.logger)) {
@@ -486,7 +555,7 @@ export class CodeQLCliServer implements Disposable {
     if (queryMemoryMb !== undefined) {
       args.push('--ram', queryMemoryMb.toString());
     }
-    return await this.runJsonCodeQlCliCommand<string[]>(['resolve', 'ram'], args, 'Resolving RAM settings', progressReporter);
+    return await this.runJsonCodeQlCliCommand<string[]>(['resolve', 'ram'], args, 'Resolving RAM settings', true, progressReporter);
   }
   /**
    * Gets the headers (and optionally pagination info) of a bqrs.
@@ -525,33 +594,48 @@ export class CodeQLCliServer implements Disposable {
     return await this.runJsonCodeQlCliCommand<DecodedBqrsChunk>(['bqrs', 'decode'], subcommandArgs, 'Reading bqrs data');
   }
 
-
-  async interpretBqrs(metadata: { kind: string; id: string }, resultsPath: string, interpretedResultsPath: string, sourceInfo?: SourceInfo): Promise<sarif.Log> {
+  async runInterpretCommand(format: string, metadata: QueryMetadata, resultsPath: string, interpretedResultsPath: string, sourceInfo?: SourceInfo) {
     const args = [
-      `-t=kind=${metadata.kind}`,
-      `-t=id=${metadata.id}`,
       '--output', interpretedResultsPath,
-      '--format', SARIF_FORMAT,
+      '--format', format,
+      // Forward all of the query metadata.
+      ...Object.entries(metadata).map(([key, value]) => `-t=${key}=${value}`)
+    ];
+    if (format == SARIF_FORMAT) {
       // TODO: This flag means that we don't group interpreted results
       // by primary location. We may want to revisit whether we call
       // interpretation with and without this flag, or do some
       // grouping client-side.
-      '--no-group-results',
-    ];
+      args.push('--no-group-results');
+    }
     if (sourceInfo !== undefined) {
       args.push(
         '--source-archive', sourceInfo.sourceArchive,
         '--source-location-prefix', sourceInfo.sourceLocationPrefix
       );
     }
+
+    args.push(
+      '--threads',
+      this.cliConfig.numberThreads.toString(),
+    );
+
     args.push(resultsPath);
     await this.runCodeQlCliCommand(['bqrs', 'interpret'], args, 'Interpreting query results');
+  }
+
+  async interpretBqrs(metadata: QueryMetadata, resultsPath: string, interpretedResultsPath: string, sourceInfo?: SourceInfo): Promise<sarif.Log> {
+    await this.runInterpretCommand(SARIF_FORMAT, metadata, resultsPath, interpretedResultsPath, sourceInfo);
 
     let output: string;
     try {
       output = await fs.readFile(interpretedResultsPath, 'utf8');
-    } catch (err) {
-      throw new Error(`Reading output of interpretation failed: ${err.stderr || err}`);
+    } catch (e) {
+      const rawMessage = e.stderr || e.message;
+      const errorMessage = rawMessage.startsWith('Cannot create a string')
+        ? `SARIF too large. ${rawMessage}`
+        : rawMessage;
+      throw new Error(`Reading output of interpretation failed: ${errorMessage}`);
     }
     try {
       return JSON.parse(output) as sarif.Log;
@@ -560,6 +644,9 @@ export class CodeQLCliServer implements Disposable {
     }
   }
 
+  async generateResultsCsv(metadata: QueryMetadata, resultsPath: string, csvPath: string, sourceInfo?: SourceInfo): Promise<void> {
+    await this.runInterpretCommand(CSV_FORMAT, metadata, resultsPath, csvPath, sourceInfo);
+  }
 
   async sortBqrs(resultsPath: string, sortedResultsPath: string, resultSet: string, sortKeys: number[], sortDirections: SortDirection[]): Promise<void> {
     const sortDirectionStrings = sortDirections.map(direction => {
@@ -599,12 +686,19 @@ export class CodeQLCliServer implements Disposable {
    * Gets information necessary for upgrading a database.
    * @param dbScheme the path to the dbscheme of the database to be upgraded.
    * @param searchPath A list of directories to search for upgrade scripts.
+   * @param allowDowngradesIfPossible Whether we should try and include downgrades of we can.
+   * @param targetDbScheme The dbscheme to try to upgrade to.
    * @returns A list of database upgrade script directories
    */
-  resolveUpgrades(dbScheme: string, searchPath: string[]): Promise<UpgradesInfo> {
+  async resolveUpgrades(dbScheme: string, searchPath: string[], allowDowngradesIfPossible: boolean, targetDbScheme?: string): Promise<UpgradesInfo> {
     const args = ['--additional-packs', searchPath.join(path.delimiter), '--dbscheme', dbScheme];
-
-    return this.runJsonCodeQlCliCommand<UpgradesInfo>(
+    if (targetDbScheme) {
+      args.push('--target-dbscheme', targetDbScheme);
+      if (allowDowngradesIfPossible && await this.cliConstraints.supportsDowngrades()) {
+        args.push('--allow-downgrades');
+      }
+    }
+    return await this.runJsonCodeQlCliCommand<UpgradesInfo>(
       ['resolve', 'upgrades'],
       args,
       'Resolving database upgrade scripts',
@@ -651,6 +745,39 @@ export class CodeQLCliServer implements Disposable {
       'Resolving queries',
     );
   }
+
+  async generateDil(qloFile: string, outFile: string): Promise<void> {
+    const extraArgs = await this.cliConstraints.supportsDecompileDil()
+      ? ['--kind', 'dil', '-o', outFile, qloFile]
+      : ['-o', outFile, qloFile];
+    await this.runCodeQlCliCommand(
+      ['query', 'decompile'],
+      extraArgs,
+      'Generating DIL',
+    );
+  }
+
+  public async getVersion() {
+    if (!this._version) {
+      this._version = await this.refreshVersion();
+    }
+    return this._version;
+  }
+
+  private async refreshVersion() {
+    const distribution = await this.distributionProvider.getDistribution();
+    switch (distribution.kind) {
+      case FindDistributionResultKind.CompatibleDistribution:
+      // eslint-disable-next-line no-fallthrough
+      case FindDistributionResultKind.IncompatibleDistribution:
+        return distribution.version;
+
+      default:
+        // We should not get here because if no distributions are available, then
+        // the cli class is never instantiated.
+        throw new Error('No distribution found');
+    }
+  }
 }
 
 /**
@@ -708,7 +835,7 @@ export function spawnServer(
 
 /**
  * Runs a CodeQL CLI command without invoking the CLI server, returning the output as a string.
- * @param config The configuration containing the path to the CLI.
+ * @param codeQlPath The path to the CLI.
  * @param command The `codeql` command to be run, provided as an array of command/subcommand names.
  * @param commandArgs The arguments to pass to the `codeql` command.
  * @param description Description of the action being run, to be shown in log and error messages.
@@ -716,7 +843,14 @@ export function spawnServer(
  * @param progressReporter Used to output progress messages, e.g. to the status bar.
  * @returns The contents of the command's stdout, if the command succeeded.
  */
-export async function runCodeQlCliCommand(codeQlPath: string, command: string[], commandArgs: string[], description: string, logger: Logger, progressReporter?: ProgressReporter): Promise<string> {
+export async function runCodeQlCliCommand(
+  codeQlPath: string,
+  command: string[],
+  commandArgs: string[],
+  description: string,
+  logger: Logger,
+  progressReporter?: ProgressReporter
+): Promise<string> {
   // Add logging arguments first, in case commandArgs contains positional parameters.
   const args = command.concat(LOGGING_FLAGS).concat(commandArgs);
   const argsString = args.join(' ');
@@ -725,7 +859,7 @@ export async function runCodeQlCliCommand(codeQlPath: string, command: string[],
       progressReporter.report({ message: description });
     }
     logger.log(`${description} using CodeQL CLI: ${codeQlPath} ${argsString}...`);
-    const result = await util.promisify(child_process.execFile)(codeQlPath, args);
+    const result = await promisify(child_process.execFile)(codeQlPath, args);
     logger.log(result.stderr);
     logger.log('CLI command succeeded.');
     return result.stdout;
@@ -763,6 +897,20 @@ class SplitBuffer {
     this.buffer += this.separators[0];  // Append a separator to the end to ensure the last line is returned.
   }
 
+  /**
+   * A version of startsWith that isn't overriden by a broken version of ms-python.
+   *
+   * The definition comes from
+   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+   * which is CC0/public domain
+   *
+   * See https://github.com/github/vscode-codeql/issues/802 for more context as to why we need it.
+   */
+  private static startsWith(s: string, searchString: string, position: number): boolean {
+    const pos = position > 0 ? position | 0 : 0;
+    return s.substring(pos, pos + searchString.length) === searchString;
+  }
+
   /**
    * Extract the next full line from the buffer, if one is available.
    * @returns The text of the next available full line (without the separator), or `undefined` if no
@@ -771,7 +919,7 @@ class SplitBuffer {
   public getNextLine(): string | undefined {
     while (this.searchIndex <= (this.buffer.length - this.maxSeparatorLength)) {
       for (const separator of this.separators) {
-        if (this.buffer.startsWith(separator, this.searchIndex)) {
+        if (SplitBuffer.startsWith(this.buffer, separator, this.searchIndex)) {
           const line = this.buffer.substr(0, this.searchIndex);
           this.buffer = this.buffer.substr(this.searchIndex + separator.length);
           this.searchIndex = 0;
@@ -831,3 +979,73 @@ async function logStream(stream: Readable, logger: Logger): Promise<void> {
     logger.log(line);
   }
 }
+
+
+export function shouldDebugIdeServer() {
+  return 'IDE_SERVER_JAVA_DEBUG' in process.env
+    && process.env.IDE_SERVER_JAVA_DEBUG !== '0'
+    && process.env.IDE_SERVER_JAVA_DEBUG?.toLocaleLowerCase() !== 'false';
+}
+
+export function shouldDebugQueryServer() {
+  return 'QUERY_SERVER_JAVA_DEBUG' in process.env
+    && process.env.QUERY_SERVER_JAVA_DEBUG !== '0'
+    && process.env.QUERY_SERVER_JAVA_DEBUG?.toLocaleLowerCase() !== 'false';
+}
+
+export class CliVersionConstraint {
+
+  /**
+   * CLI version where --kind=DIL was introduced
+   */
+  public static CLI_VERSION_WITH_DECOMPILE_KIND_DIL = new SemVer('2.3.0');
+
+  /**
+   * CLI version where languages are exposed during a `codeql resolve database` command.
+   */
+  public static CLI_VERSION_WITH_LANGUAGE = new SemVer('2.4.1');
+
+  /**
+   * CLI version where `codeql resolve upgrades` supports
+   * the `--allow-downgrades` flag
+   */
+  public static CLI_VERSION_WITH_DOWNGRADES = new SemVer('2.4.4');
+
+  /**
+   * CLI version where the `codeql resolve qlref` command is available.
+   */
+  public static CLI_VERSION_WITH_RESOLVE_QLREF = new SemVer('2.5.1');
+
+  /**
+   * CLI version where database registration was introduced
+   */
+  public static CLI_VERSION_WITH_DB_REGISTRATION = new SemVer('2.4.1');
+
+  constructor(private readonly cli: CodeQLCliServer) {
+    /**/
+  }
+
+  private async isVersionAtLeast(v: SemVer) {
+    return (await this.cli.getVersion()).compare(v) >= 0;
+  }
+
+  public async supportsDecompileDil() {
+    return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_DECOMPILE_KIND_DIL);
+  }
+
+  public async supportsLanguageName() {
+    return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_LANGUAGE);
+  }
+
+  public async supportsDowngrades() {
+    return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_DOWNGRADES);
+  }
+
+  public async supportsResolveQlref() {
+    return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_RESOLVE_QLREF);
+  }
+
+  async supportsDatabaseRegistration() {
+    return this.isVersionAtLeast(CliVersionConstraint.CLI_VERSION_WITH_DB_REGISTRATION);
+  }
+}

extensions/ql-vscode/src/commandRunner.ts

@@ -0,0 +1,241 @@
+import {
+  CancellationToken,
+  ProgressOptions,
+  window as Window,
+  commands,
+  Disposable,
+  ProgressLocation
+} from 'vscode';
+import { showAndLogErrorMessage, showAndLogWarningMessage } from './helpers';
+import { logger } from './logging';
+import { telemetryListener } from './telemetry';
+
+export class UserCancellationException extends Error {
+  /**
+   * @param message The error message
+   * @param silent If silent is true, then this exception will avoid showing a warning message to the user.
+   */
+  constructor(message?: string, public readonly silent = false) {
+    super(message);
+  }
+}
+
+export interface ProgressUpdate {
+  /**
+   * The current step
+   */
+  step: number;
+  /**
+   * The maximum step. This *should* be constant for a single job.
+   */
+  maxStep: number;
+  /**
+   * The current progress message
+   */
+  message: string;
+}
+
+export type ProgressCallback = (p: ProgressUpdate) => void;
+
+/**
+ * A task that handles command invocations from `commandRunner`
+ * and includes a progress monitor.
+ *
+ *
+ * Arguments passed to the command handler are passed along,
+ * untouched to this `ProgressTask` instance.
+ *
+ * @param progress a progress handler function. Call this
+ * function with a `ProgressUpdate` instance in order to
+ * denote some progress being achieved on this task.
+ * @param token a cencellation token
+ * @param args arguments passed to this task passed on from
+ * `commands.registerCommand`.
+ */
+export type ProgressTask<R> = (
+  progress: ProgressCallback,
+  token: CancellationToken,
+  ...args: any[]
+) => Thenable<R>;
+
+/**
+ * A task that handles command invocations from `commandRunner`.
+ * Arguments passed to the command handler are passed along,
+ * untouched to this `NoProgressTask` instance.
+ *
+ * @param args arguments passed to this task passed on from
+ * `commands.registerCommand`.
+ */
+type NoProgressTask = ((...args: any[]) => Promise<any>);
+
+/**
+ * This mediates between the kind of progress callbacks we want to
+ * write (where we *set* current progress position and give
+ * `maxSteps`) and the kind vscode progress api expects us to write
+ * (which increment progress by a certain amount out of 100%).
+ *
+ * Where possible, the `commandRunner` function below should be used
+ * instead of this function. The commandRunner is meant for wrapping
+ * top-level commands and provides error handling and other support
+ * automatically.
+ *
+ * Only use this function if you need a progress monitor and the
+ * control flow does not always come from a command (eg- during
+ * extension activation, or from an internal language server
+ * request).
+ */
+export function withProgress<R>(
+  options: ProgressOptions,
+  task: ProgressTask<R>,
+  ...args: any[]
+): Thenable<R> {
+  let progressAchieved = 0;
+  return Window.withProgress(options,
+    (progress, token) => {
+      return task(p => {
+        const { message, step, maxStep } = p;
+        const increment = 100 * (step - progressAchieved) / maxStep;
+        progressAchieved = step;
+        progress.report({ message, increment });
+      }, token, ...args);
+    });
+}
+
+/**
+ * A generic wrapper for command registration. This wrapper adds uniform error handling for commands.
+ *
+ * In this variant of the command runner, no progress monitor is used.
+ *
+ * @param commandId The ID of the command to register.
+ * @param task The task to run. It is passed directly to `commands.registerCommand`. Any
+ * arguments to the command handler are passed on to the task.
+ */
+export function commandRunner(
+  commandId: string,
+  task: NoProgressTask,
+): Disposable {
+  return commands.registerCommand(commandId, async (...args: any[]) => {
+    const startTime = Date.now();
+    let error: Error | undefined;
+
+    try {
+      return await task(...args);
+    } catch (e) {
+      error = e;
+      const errorMessage = `${e.message || e} (${commandId})`;
+      if (e instanceof UserCancellationException) {
+        // User has cancelled this action manually
+        if (e.silent) {
+          logger.log(errorMessage);
+        } else {
+          showAndLogWarningMessage(errorMessage);
+        }
+      } else {
+        // Include the full stack in the error log only.
+        const fullMessage = e.stack
+          ? `${errorMessage}\n${e.stack}`
+          : errorMessage;
+        showAndLogErrorMessage(errorMessage, {
+          fullMessage
+        });
+      }
+      return undefined;
+    } finally {
+      const executionTime = Date.now() - startTime;
+      telemetryListener.sendCommandUsage(commandId, executionTime, error);
+    }
+  });
+}
+
+/**
+ * A generic wrapper for command registration.  This wrapper adds uniform error handling,
+ * progress monitoring, and cancellation for commands.
+ *
+ * @param commandId The ID of the command to register.
+ * @param task The task to run. It is passed directly to `commands.registerCommand`. Any
+ * arguments to the command handler are passed on to the task after the progress callback
+ * and cancellation token.
+ * @param progressOptions Progress options to be sent to the progress monitor.
+ */
+export function commandRunnerWithProgress<R>(
+  commandId: string,
+  task: ProgressTask<R>,
+  progressOptions: Partial<ProgressOptions>
+): Disposable {
+  return commands.registerCommand(commandId, async (...args: any[]) => {
+    const startTime = Date.now();
+    let error: Error | undefined;
+    const progressOptionsWithDefaults = {
+      location: ProgressLocation.Notification,
+      ...progressOptions
+    };
+    try {
+      return await withProgress(progressOptionsWithDefaults, task, ...args);
+    } catch (e) {
+      error = e;
+      const errorMessage = `${e.message || e} (${commandId})`;
+      if (e instanceof UserCancellationException) {
+        // User has cancelled this action manually
+        if (e.silent) {
+          logger.log(errorMessage);
+        } else {
+          showAndLogWarningMessage(errorMessage);
+        }
+      } else {
+        // Include the full stack in the error log only.
+        const fullMessage = e.stack
+          ? `${errorMessage}\n${e.stack}`
+          : errorMessage;
+        showAndLogErrorMessage(errorMessage, {
+          fullMessage
+        });
+      }
+      return undefined;
+    } finally {
+      const executionTime = Date.now() - startTime;
+      telemetryListener.sendCommandUsage(commandId, executionTime, error);
+    }
+  });
+}
+
+/**
+ * Displays a progress monitor that indicates how much progess has been made
+ * reading from a stream.
+ *
+ * @param readable The stream to read progress from
+ * @param messagePrefix A prefix for displaying the message
+ * @param totalNumBytes Total number of bytes in this stream
+ * @param progress The progress callback used to set messages
+ */
+export function reportStreamProgress(
+  readable: NodeJS.ReadableStream,
+  messagePrefix: string,
+  totalNumBytes?: number,
+  progress?: ProgressCallback
+) {
+  if (progress && totalNumBytes) {
+    let numBytesDownloaded = 0;
+    const bytesToDisplayMB = (numBytes: number): string => `${(numBytes / (1024 * 1024)).toFixed(1)} MB`;
+    const updateProgress = () => {
+      progress({
+        step: numBytesDownloaded,
+        maxStep: totalNumBytes,
+        message: `${messagePrefix} [${bytesToDisplayMB(numBytesDownloaded)} of ${bytesToDisplayMB(totalNumBytes)}]`,
+      });
+    };
+
+    // Display the progress straight away rather than waiting for the first chunk.
+    updateProgress();
+
+    readable.on('data', data => {
+      numBytesDownloaded += data.length;
+      updateProgress();
+    });
+  } else if (progress) {
+    progress({
+      step: 1,
+      maxStep: 2,
+      message: `${messagePrefix} (Size unknown)`,
+    });
+  }
+}

extensions/ql-vscode/src/compare/compare-interface.ts

@@ -1,4 +1,4 @@
-import { DisposableObject } from '../vscode-utils/disposable-object';
+import { DisposableObject } from '../pure/disposable-object';
 import {
   WebviewPanel,
   ExtensionContext,
@@ -14,13 +14,12 @@ import {
   FromCompareViewMessage,
   ToCompareViewMessage,
   QueryCompareResult,
-} from '../interface-types';
+} from '../pure/interface-types';
 import { Logger } from '../logging';
 import { CodeQLCliServer } from '../cli';
 import { DatabaseManager } from '../databases';
 import { getHtmlForWebview, jumpToLocation } from '../interface-utils';
-import { adaptSchema, adaptBqrs, RawResultSet } from '../adapt';
-import { BQRSInfo } from '../bqrs-cli-types';
+import { transformBqrsResultSet, RawResultSet, BQRSInfo } from '../pure/bqrs-cli-types';
 import resultsDiff from './resultsDiff';
 
 interface ComparePair {
@@ -257,8 +256,7 @@ export class CompareInterfaceManager extends DisposableObject {
       resultsPath,
       resultSetName
     );
-    const adaptedSchema = adaptSchema(schema);
-    return adaptBqrs(adaptedSchema, chunk);
+    return transformBqrsResultSet(schema, chunk);
   }
 
   private compareResults(

extensions/ql-vscode/src/compare/resultsDiff.ts

@@ -1,5 +1,5 @@
-import { RawResultSet } from '../adapt';
-import { QueryCompareResult } from '../interface-types';
+import { RawResultSet } from '../pure/bqrs-cli-types';
+import { QueryCompareResult } from '../pure/interface-types';
 
 /**
  * Compare the rows of two queries. Use deep equality to determine if

extensions/ql-vscode/src/compare/view/Compare.tsx

@@ -5,7 +5,7 @@ import * as Rdom from 'react-dom';
 import {
   ToCompareViewMessage,
   SetComparisonsMessage,
-} from '../../interface-types';
+} from '../../pure/interface-types';
 import CompareSelector from './CompareSelector';
 import { vscode } from '../../view/vscode-api';
 import CompareTable from './CompareTable';

extensions/ql-vscode/src/compare/view/CompareTable.tsx

@@ -1,9 +1,9 @@
 import * as React from 'react';
 
-import { SetComparisonsMessage } from '../../interface-types';
+import { SetComparisonsMessage } from '../../pure/interface-types';
 import RawTableHeader from '../../view/RawTableHeader';
 import { className } from '../../view/result-table-utils';
-import { ResultRow } from '../../adapt';
+import { ResultRow } from '../../pure/bqrs-cli-types';
 import RawTableRow from '../../view/RawTableRow';
 import { vscode } from '../../view/vscode-api';
 

extensions/ql-vscode/src/config.ts

@@ -1,10 +1,10 @@
-import { DisposableObject } from './vscode-utils/disposable-object';
+import { DisposableObject } from './pure/disposable-object';
 import { workspace, Event, EventEmitter, ConfigurationChangeEvent, ConfigurationTarget } from 'vscode';
 import { DistributionManager } from './distribution';
 import { logger } from './logging';
 
 /** Helper class to look up a labelled (and possibly nested) setting. */
-class Setting {
+export class Setting {
   name: string;
   parent?: Setting;
 
@@ -39,10 +39,19 @@ class Setting {
 
 const ROOT_SETTING = new Setting('codeQL');
 
-// Distribution configuration
+// Global configuration
+const TELEMETRY_SETTING = new Setting('telemetry', ROOT_SETTING);
+const AST_VIEWER_SETTING = new Setting('astViewer', ROOT_SETTING);
+const GLOBAL_TELEMETRY_SETTING = new Setting('telemetry');
 
+export const LOG_TELEMETRY = new Setting('logTelemetry', TELEMETRY_SETTING);
+export const ENABLE_TELEMETRY = new Setting('enableTelemetry', TELEMETRY_SETTING);
+
+export const GLOBAL_ENABLE_TELEMETRY = new Setting('enableTelemetry', GLOBAL_TELEMETRY_SETTING);
+
+// Distribution configuration
 const DISTRIBUTION_SETTING = new Setting('cli', ROOT_SETTING);
-const CUSTOM_CODEQL_PATH_SETTING = new Setting('executablePath', DISTRIBUTION_SETTING);
+export const CUSTOM_CODEQL_PATH_SETTING = new Setting('executablePath', DISTRIBUTION_SETTING);
 const INCLUDE_PRERELEASE_SETTING = new Setting('includePrerelease', DISTRIBUTION_SETTING);
 const PERSONAL_ACCESS_TOKEN_SETTING = new Setting('personalAccessToken', DISTRIBUTION_SETTING);
 const QUERY_HISTORY_SETTING = new Setting('queryHistory', ROOT_SETTING);
@@ -52,33 +61,45 @@ const QUERY_HISTORY_FORMAT_SETTING = new Setting('format', QUERY_HISTORY_SETTING
 const DISTRIBUTION_CHANGE_SETTINGS = [CUSTOM_CODEQL_PATH_SETTING, INCLUDE_PRERELEASE_SETTING, PERSONAL_ACCESS_TOKEN_SETTING];
 
 export interface DistributionConfig {
-  customCodeQlPath?: string;
+  readonly customCodeQlPath?: string;
+  updateCustomCodeQlPath: (newPath: string | undefined) => Promise<void>;
   includePrerelease: boolean;
   personalAccessToken?: string;
   ownerName?: string;
   repositoryName?: string;
-  onDidChangeDistributionConfiguration?: Event<void>;
+  onDidChangeConfiguration?: Event<void>;
 }
 
 // Query server configuration
 
 const RUNNING_QUERIES_SETTING = new Setting('runningQueries', ROOT_SETTING);
 const NUMBER_OF_THREADS_SETTING = new Setting('numberOfThreads', RUNNING_QUERIES_SETTING);
+const SAVE_CACHE_SETTING = new Setting('saveCache', RUNNING_QUERIES_SETTING);
+const CACHE_SIZE_SETTING = new Setting('cacheSize', RUNNING_QUERIES_SETTING);
 const TIMEOUT_SETTING = new Setting('timeout', RUNNING_QUERIES_SETTING);
 const MEMORY_SETTING = new Setting('memory', RUNNING_QUERIES_SETTING);
 const DEBUG_SETTING = new Setting('debug', RUNNING_QUERIES_SETTING);
+const RUNNING_TESTS_SETTING = new Setting('runningTests', ROOT_SETTING);
+const RESULTS_DISPLAY_SETTING = new Setting('resultsDisplay', ROOT_SETTING);
+
+export const ADDITIONAL_TEST_ARGUMENTS_SETTING = new Setting('additionalTestArguments', RUNNING_TESTS_SETTING);
+export const NUMBER_OF_TEST_THREADS_SETTING = new Setting('numberOfThreads', RUNNING_TESTS_SETTING);
+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);
 
 /** When these settings change, the running query server should be restarted. */
-const QUERY_SERVER_RESTARTING_SETTINGS = [NUMBER_OF_THREADS_SETTING, MEMORY_SETTING, DEBUG_SETTING];
+const QUERY_SERVER_RESTARTING_SETTINGS = [NUMBER_OF_THREADS_SETTING, SAVE_CACHE_SETTING, CACHE_SIZE_SETTING, MEMORY_SETTING, DEBUG_SETTING];
 
 export interface QueryServerConfig {
   codeQlPath: string;
   debug: boolean;
   numThreads: number;
+  saveCache: boolean;
+  cacheSize: number;
   queryMemoryMb?: number;
   timeoutSecs: number;
-  onDidChangeQueryServerConfiguration?: Event<void>;
+  onDidChangeConfiguration?: Event<void>;
 }
 
 /** When these settings change, the query history should be refreshed. */
@@ -86,10 +107,20 @@ const QUERY_HISTORY_SETTINGS = [QUERY_HISTORY_FORMAT_SETTING];
 
 export interface QueryHistoryConfig {
   format: string;
-  onDidChangeQueryHistoryConfiguration: Event<void>;
+  onDidChangeConfiguration: Event<void>;
 }
 
-abstract class ConfigListener extends DisposableObject {
+const CLI_SETTINGS = [ADDITIONAL_TEST_ARGUMENTS_SETTING, NUMBER_OF_TEST_THREADS_SETTING, NUMBER_OF_THREADS_SETTING];
+
+export interface CliConfig {
+  additionalTestArguments: string[];
+  numberTestThreads: number;
+  numberThreads: number;
+  onDidChangeConfiguration?: Event<void>;
+}
+
+
+export abstract class ConfigListener extends DisposableObject {
   protected readonly _onDidChangeConfiguration = this.push(new EventEmitter<void>());
 
   constructor() {
@@ -116,6 +147,10 @@ abstract class ConfigListener extends DisposableObject {
   private updateConfiguration(): void {
     this._onDidChangeConfiguration.fire();
   }
+
+  public get onDidChangeConfiguration(): Event<void> {
+    return this._onDidChangeConfiguration.event;
+  }
 }
 
 export class DistributionConfigListener extends ConfigListener implements DistributionConfig {
@@ -131,8 +166,8 @@ export class DistributionConfigListener extends ConfigListener implements Distri
     return PERSONAL_ACCESS_TOKEN_SETTING.getValue() || undefined;
   }
 
-  public get onDidChangeDistributionConfiguration(): Event<void> {
-    return this._onDidChangeConfiguration.event;
+  public async updateCustomCodeQlPath(newPath: string | undefined) {
+    await CUSTOM_CODEQL_PATH_SETTING.updateValue(newPath, ConfigurationTarget.Global);
   }
 
   protected handleDidChangeConfiguration(e: ConfigurationChangeEvent): void {
@@ -141,7 +176,7 @@ export class DistributionConfigListener extends ConfigListener implements Distri
 }
 
 export class QueryServerConfigListener extends ConfigListener implements QueryServerConfig {
-  private constructor(private _codeQlPath: string) {
+  public constructor(private _codeQlPath = '') {
     super();
   }
 
@@ -166,6 +201,14 @@ export class QueryServerConfigListener extends ConfigListener implements QuerySe
     return NUMBER_OF_THREADS_SETTING.getValue<number>();
   }
 
+  public get saveCache(): boolean {
+    return SAVE_CACHE_SETTING.getValue<boolean>();
+  }
+
+  public get cacheSize(): number {
+    return CACHE_SIZE_SETTING.getValue<number | null>() || 0;
+  }
+
   /** Gets the configured query timeout, in seconds. This looks up the setting at the time of access. */
   public get timeoutSecs(): number {
     return TIMEOUT_SETTING.getValue<number | null>() || 0;
@@ -187,10 +230,6 @@ export class QueryServerConfigListener extends ConfigListener implements QuerySe
     return DEBUG_SETTING.getValue<boolean>();
   }
 
-  public get onDidChangeQueryServerConfiguration(): Event<void> {
-    return this._onDidChangeConfiguration.event;
-  }
-
   protected handleDidChangeConfiguration(e: ConfigurationChangeEvent): void {
     this.handleDidChangeConfigurationForRelevantSettings(QUERY_SERVER_RESTARTING_SETTINGS, e);
   }
@@ -201,15 +240,29 @@ export class QueryHistoryConfigListener extends ConfigListener implements QueryH
     this.handleDidChangeConfigurationForRelevantSettings(QUERY_HISTORY_SETTINGS, e);
   }
 
-  public get onDidChangeQueryHistoryConfiguration(): Event<void> {
-    return this._onDidChangeConfiguration.event;
-  }
-
   public get format(): string {
     return QUERY_HISTORY_FORMAT_SETTING.getValue<string>();
   }
 }
 
+export class CliConfigListener extends ConfigListener implements CliConfig {
+  public get additionalTestArguments(): string[] {
+    return ADDITIONAL_TEST_ARGUMENTS_SETTING.getValue();
+  }
+
+  public get numberTestThreads(): number {
+    return NUMBER_OF_TEST_THREADS_SETTING.getValue();
+  }
+
+  public get numberThreads(): number {
+    return NUMBER_OF_THREADS_SETTING.getValue<number>();
+  }
+
+  protected handleDidChangeConfiguration(e: ConfigurationChangeEvent): void {
+    this.handleDidChangeConfigurationForRelevantSettings(CLI_SETTINGS, e);
+  }
+}
+
 // Enable experimental features
 
 /**
@@ -219,5 +272,16 @@ export class QueryHistoryConfigListener extends ConfigListener implements QueryH
  * their vscode settings json file.
  */
 
-/* Advanced setting: used to enable the AST Viewer. */
-export const EXPERIMENTAL_AST_VIEWER = new Setting('experimentalAstViewer', ROOT_SETTING);
+/**
+ * Enables canary features of this extension. Recommended for all internal users.
+ */
+export const CANARY_FEATURES = new Setting('canary', ROOT_SETTING);
+
+export function isCanary() {
+  return !!CANARY_FEATURES.getValue<boolean>();
+}
+
+/**
+ * Avoids caching in the AST viewer if the user is also a canary user.
+ */
+export const NO_CACHE_AST_VIEWER = new Setting('disableCache', AST_VIEWER_SETTING);

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

@@ -1,8 +1,9 @@
 import { QueryWithResults } from '../run-queries';
 import { CodeQLCliServer } from '../cli';
-import { DecodedBqrsChunk, BqrsId, EntityValue } from '../bqrs-cli-types';
+import { DecodedBqrsChunk, BqrsId, EntityValue } from '../pure/bqrs-cli-types';
 import { DatabaseItem } from '../databases';
-import { AstItem, RootAstItem } from '../astViewer';
+import { ChildAstItem, AstItem } from '../astViewer';
+import fileRangeFromURI from './fileRangeFromURI';
 
 /**
  * A class that wraps a tree of QL results from a query that
@@ -10,7 +11,7 @@ import { AstItem, RootAstItem } from '../astViewer';
  */
 export default class AstBuilder {
 
-  private roots: RootAstItem[] | undefined;
+  private roots: AstItem[] | undefined;
   private bqrsPath: string;
   constructor(
     queryResults: QueryWithResults,
@@ -21,14 +22,14 @@ export default class AstBuilder {
     this.bqrsPath = queryResults.query.resultsPaths.resultsPath;
   }
 
-  async getRoots(): Promise<RootAstItem[]> {
+  async getRoots(): Promise<AstItem[]> {
     if (!this.roots) {
       this.roots = await this.parseRoots();
     }
     return this.roots;
   }
 
-  private async parseRoots(): Promise<RootAstItem[]> {
+  private async parseRoots(): Promise<AstItem[]> {
     const options = { entities: ['id', 'url', 'string'] };
     const [nodeTuples, edgeTuples, graphProperties] = await Promise.all([
       await this.cli.bqrsDecode(this.bqrsPath, 'nodes', options),
@@ -40,21 +41,22 @@ export default class AstBuilder {
       throw new Error('AST is invalid');
     }
 
-    const idToItem = new Map<BqrsId, AstItem | RootAstItem>();
+    const idToItem = new Map<BqrsId, AstItem>();
     const parentToChildren = new Map<BqrsId, BqrsId[]>();
     const childToParent = new Map<BqrsId, BqrsId>();
     const astOrder = new Map<BqrsId, number>();
+    const edgeLabels = new Map<BqrsId, string>();
     const roots = [];
 
     // Build up the parent-child relationships
     edgeTuples.tuples.forEach(tuple => {
-      const [source, target, tupleType, orderValue] = tuple as [EntityValue, EntityValue, string, string];
+      const [source, target, tupleType, value] = tuple as [EntityValue, EntityValue, string, string];
       const sourceId = source.id!;
       const targetId = target.id!;
 
       switch (tupleType) {
         case 'semmle.order':
-          astOrder.set(targetId, Number(orderValue));
+          astOrder.set(targetId, Number(value));
           break;
 
         case 'semmle.label': {
@@ -64,6 +66,11 @@ export default class AstBuilder {
             parentToChildren.set(sourceId, children = []);
           }
           children.push(targetId);
+
+          // ignore values that indicate a numeric order.
+          if (!Number.isFinite(Number(value))) {
+            edgeLabels.set(targetId, value);
+          }
           break;
         }
 
@@ -74,34 +81,39 @@ export default class AstBuilder {
 
     // populate parents and children
     nodeTuples.tuples.forEach(tuple => {
-      const [entity, tupleType, orderValue] = tuple as [EntityValue, string, string];
+      const [entity, tupleType, value] = tuple as [EntityValue, string, string];
       const id = entity.id!;
 
       switch (tupleType) {
         case 'semmle.order':
-          astOrder.set(id, Number(orderValue));
+          astOrder.set(id, Number(value));
           break;
 
         case 'semmle.label': {
+          // If an edge label exists, include it and separate from the node label using ':'
+          const nodeLabel = value ?? entity.label;
+          const edgeLabel = edgeLabels.get(id);
+          const label = [edgeLabel, nodeLabel].filter(e => e).join(': ');
           const item = {
             id,
-            label: entity.label,
+            label,
             location: entity.url,
-            children: [] as AstItem[],
+            fileLocation: fileRangeFromURI(entity.url, this.db),
+            children: [] as ChildAstItem[],
             order: Number.MAX_SAFE_INTEGER
           };
 
-          idToItem.set(id, item as RootAstItem);
+          idToItem.set(id, item);
           const parent = idToItem.get(childToParent.has(id) ? childToParent.get(id)! : -1);
 
           if (parent) {
-            const astItem = item as AstItem;
+            const astItem = item as ChildAstItem;
             astItem.parent = parent;
             parent.children.push(astItem);
           }
           const children = parentToChildren.has(id) ? parentToChildren.get(id)! : [];
           children.forEach(childId => {
-            const child = idToItem.get(childId) as AstItem | undefined;
+            const child = idToItem.get(childId) as ChildAstItem | undefined;
             if (child) {
               child.parent = item;
               item.children.push(child);

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

@@ -1,24 +1,27 @@
 import * as vscode from 'vscode';
 
-import { UrlValue, LineColumnLocation } from '../bqrs-cli-types';
+import { UrlValue, LineColumnLocation } from '../pure/bqrs-cli-types';
+import { isEmptyPath } from '../pure/bqrs-utils';
 import { DatabaseItem } from '../databases';
 
 
-export default function fileRangeFromURI(uri: UrlValue, db: DatabaseItem): vscode.Location | undefined {
-  if (typeof uri === 'string') {
+export default function fileRangeFromURI(uri: UrlValue | undefined, db: DatabaseItem): vscode.Location | undefined {
+  if (!uri || typeof uri === 'string') {
     return undefined;
   } else if ('startOffset' in uri) {
     return undefined;
   } else {
     const loc = uri as LineColumnLocation;
+    if (isEmptyPath(loc.uri)) {
+      return undefined;
+    }
     const range = new vscode.Range(Math.max(0, (loc.startLine || 0) - 1),
       Math.max(0, (loc.startColumn || 0) - 1),
       Math.max(0, (loc.endLine || 0) - 1),
       Math.max(0, (loc.endColumn || 0)));
     try {
-      const parsed = vscode.Uri.parse(uri.uri, true);
-      if (parsed.scheme === 'file') {
-        return new vscode.Location(db.resolveSourceFile(parsed.fsPath), range);
+      if (uri.uri.startsWith('file:')) {
+        return new vscode.Location(db.resolveSourceFile(uri.uri), range);
       }
       return undefined;
     } catch (e) {

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

@@ -1,13 +1,14 @@
 import * as vscode from 'vscode';
 
-import { decodeSourceArchiveUri, zipArchiveScheme } from '../archive-filesystem-provider';
-import { ColumnKindCode, EntityValue, getResultSetSchema } from '../bqrs-cli-types';
+import { decodeSourceArchiveUri, encodeArchiveBasePath } from '../archive-filesystem-provider';
+import { ColumnKindCode, EntityValue, getResultSetSchema, ResultSetSchema } from '../pure/bqrs-cli-types';
 import { CodeQLCliServer } from '../cli';
 import { DatabaseManager, DatabaseItem } from '../databases';
 import fileRangeFromURI from './fileRangeFromURI';
-import * as messages from '../messages';
+import * as messages from '../pure/messages';
 import { QueryServerClient } from '../queryserver-client';
 import { QueryWithResults, compileAndRunQueryAgainstDatabase } from '../run-queries';
+import { ProgressCallback } from '../commandRunner';
 import { KeyType } from './keyType';
 import { qlpackOfDatabase, resolveQueries } from './queryResolver';
 
@@ -28,6 +29,8 @@ export interface FullLocationLink extends vscode.LocationLink {
  * @param dbm The database manager
  * @param uriString The selected source file and location
  * @param keyType The contextual query type to run
+ * @param progress A progress callback
+ * @param token A CancellationToken
  * @param filter A function that will filter extraneous results
  */
 export async function getLocationsForUriString(
@@ -36,37 +39,39 @@ export async function getLocationsForUriString(
   dbm: DatabaseManager,
   uriString: string,
   keyType: KeyType,
+  progress: ProgressCallback,
+  token: vscode.CancellationToken,
   filter: (src: string, dest: string) => boolean
 ): Promise<FullLocationLink[]> {
-  const uri = decodeSourceArchiveUri(vscode.Uri.parse(uriString));
-  const sourceArchiveUri = vscode.Uri.file(uri.sourceArchiveZipPath).with({ scheme: zipArchiveScheme });
+  const uri = decodeSourceArchiveUri(vscode.Uri.parse(uriString, true));
+  const sourceArchiveUri = encodeArchiveBasePath(uri.sourceArchiveZipPath);
 
   const db = dbm.findDatabaseItemBySourceArchive(sourceArchiveUri);
-  if (db) {
-    const qlpack = await qlpackOfDatabase(cli, db);
-    if (qlpack === undefined) {
-      throw new Error('Can\'t infer qlpack from database source archive');
-    }
-    const links: FullLocationLink[] = [];
-    for (const query of await resolveQueries(cli, qlpack, keyType)) {
-      const templates: messages.TemplateDefinitions = {
-        [TEMPLATE_NAME]: {
-          values: {
-            tuples: [[{
-              stringValue: uri.pathWithinSourceArchive
-            }]]
-          }
-        }
-      };
-      const results = await compileAndRunQueryAgainstDatabase(cli, qs, db, false, vscode.Uri.file(query), templates);
-      if (results.result.resultType == messages.QueryResultType.SUCCESS) {
-        links.push(...await getLinksFromResults(results, cli, db, filter));
-      }
-    }
-    return links;
-  } else {
+  if (!db) {
     return [];
   }
+
+  const qlpack = await qlpackOfDatabase(cli, db);
+  const templates = createTemplates(uri.pathWithinSourceArchive);
+
+  const links: FullLocationLink[] = [];
+  for (const query of await resolveQueries(cli, qlpack, keyType)) {
+    const results = await compileAndRunQueryAgainstDatabase(
+      cli,
+      qs,
+      db,
+      false,
+      vscode.Uri.file(query),
+      progress,
+      token,
+      templates
+    );
+
+    if (results.result.resultType == messages.QueryResultType.SUCCESS) {
+      links.push(...await getLinksFromResults(results, cli, db, filter));
+    }
+  }
+  return links;
 }
 
 async function getLinksFromResults(
@@ -79,10 +84,7 @@ async function getLinksFromResults(
   const bqrsPath = results.query.resultsPaths.resultsPath;
   const info = await cli.bqrsInfo(bqrsPath);
   const selectInfo = getResultSetSchema(SELECT_QUERY_NAME, info);
-  if (selectInfo && selectInfo.columns.length == 3
-    && selectInfo.columns[0].kind == ColumnKindCode.ENTITY
-    && selectInfo.columns[1].kind == ColumnKindCode.ENTITY
-    && selectInfo.columns[2].kind == ColumnKindCode.STRING) {
+  if (isValidSelect(selectInfo)) {
     // TODO: Page this
     const allTuples = await cli.bqrsDecode(bqrsPath, SELECT_QUERY_NAME);
     for (const tuple of allTuples.tuples) {
@@ -101,3 +103,22 @@ async function getLinksFromResults(
   }
   return localLinks;
 }
+
+function createTemplates(path: string): messages.TemplateDefinitions {
+  return {
+    [TEMPLATE_NAME]: {
+      values: {
+        tuples: [[{
+          stringValue: path
+        }]]
+      }
+    }
+  };
+}
+
+function isValidSelect(selectInfo: ResultSetSchema | undefined) {
+  return selectInfo && selectInfo.columns.length == 3
+    && selectInfo.columns[0].kind == ColumnKindCode.ENTITY
+    && selectInfo.columns[1].kind == ColumnKindCode.ENTITY
+    && selectInfo.columns[2].kind == ColumnKindCode.STRING;
+}

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

@@ -12,12 +12,13 @@ import {
 import { CodeQLCliServer } from '../cli';
 import { DatabaseItem } from '../databases';
 
-export async function qlpackOfDatabase(cli: CodeQLCliServer, db: DatabaseItem): Promise<string | undefined> {
-  if (db.contents === undefined)
-    return undefined;
+export async function qlpackOfDatabase(cli: CodeQLCliServer, db: DatabaseItem): Promise<string> {
+  if (db.contents === undefined) {
+    throw new Error('Database is invalid and cannot infer QLPack.');
+  }
   const datasetPath = db.contents.datasetUri.fsPath;
-  const { qlpack } = await helpers.resolveDatasetFolder(cli, datasetPath);
-  return qlpack;
+  const dbscheme = await helpers.getPrimaryDbscheme(datasetPath);
+  return await helpers.getQlPackForDbscheme(cli, dbscheme);
 }
 
 
@@ -37,7 +38,9 @@ export async function resolveQueries(cli: CodeQLCliServer, qlpack: string, keyTy
   const queries = await cli.resolveQueriesInSuite(suiteFile, helpers.getOnDiskWorkspaceFolders());
   if (queries.length === 0) {
     helpers.showAndLogErrorMessage(
-      `No ${nameOfKeyType(keyType)} queries (tagged "${tagOfKeyType(keyType)}") could be found in the current library path. It might be necessary to upgrade the CodeQL libraries.`
+      `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.`
     );
     throw new Error(`Couldn't find any queries tagged ${tagOfKeyType(keyType)} for qlpack ${qlpack}`);
   }

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

@@ -1,11 +1,22 @@
-import * as vscode from 'vscode';
-import * as path from 'path';
+import {
+  CancellationToken,
+  DefinitionProvider,
+  Location,
+  LocationLink,
+  Position,
+  ProgressLocation,
+  ReferenceContext,
+  ReferenceProvider,
+  TextDocument,
+  Uri
+} from 'vscode';
 
-import { decodeSourceArchiveUri, zipArchiveScheme } from '../archive-filesystem-provider';
+import { decodeSourceArchiveUri, encodeArchiveBasePath, zipArchiveScheme } from '../archive-filesystem-provider';
 import { CodeQLCliServer } from '../cli';
 import { DatabaseManager } from '../databases';
 import { CachedOperation } from '../helpers';
-import * as messages from '../messages';
+import { ProgressCallback, withProgress } from '../commandRunner';
+import * as messages from '../pure/messages';
 import { QueryServerClient } from '../queryserver-client';
 import { compileAndRunQueryAgainstDatabase, QueryWithResults } from '../run-queries';
 import AstBuilder from './astBuilder';
@@ -14,6 +25,7 @@ import {
 } from './keyType';
 import { FullLocationLink, getLocationsForUriString, TEMPLATE_NAME } from './locationFinder';
 import { qlpackOfDatabase, resolveQueries } from './queryResolver';
+import { isCanary, NO_CACHE_AST_VIEWER } from '../config';
 
 /**
  * Run templated CodeQL queries to find definitions and references in
@@ -22,20 +34,20 @@ import { qlpackOfDatabase, resolveQueries } from './queryResolver';
  * or from a selected identifier.
  */
 
-export class TemplateQueryDefinitionProvider implements vscode.DefinitionProvider {
-  private cache: CachedOperation<vscode.LocationLink[]>;
+export class TemplateQueryDefinitionProvider implements DefinitionProvider {
+  private cache: CachedOperation<LocationLink[]>;
 
   constructor(
     private cli: CodeQLCliServer,
     private qs: QueryServerClient,
     private dbm: DatabaseManager,
   ) {
-    this.cache = new CachedOperation<vscode.LocationLink[]>(this.getDefinitions.bind(this));
+    this.cache = new CachedOperation<LocationLink[]>(this.getDefinitions.bind(this));
   }
 
-  async provideDefinition(document: vscode.TextDocument, position: vscode.Position, _token: vscode.CancellationToken): Promise<vscode.LocationLink[]> {
+  async provideDefinition(document: TextDocument, position: Position, _token: CancellationToken): Promise<LocationLink[]> {
     const fileLinks = await this.cache.get(document.uri.toString());
-    const locLinks: vscode.LocationLink[] = [];
+    const locLinks: LocationLink[] = [];
     for (const link of fileLinks) {
       if (link.originSelectionRange!.contains(position)) {
         locLinks.push(link);
@@ -44,19 +56,27 @@ export class TemplateQueryDefinitionProvider implements vscode.DefinitionProvide
     return locLinks;
   }
 
-  private async getDefinitions(uriString: string): Promise<vscode.LocationLink[]> {
-    return getLocationsForUriString(
-      this.cli,
-      this.qs,
-      this.dbm,
-      uriString,
-      KeyType.DefinitionQuery,
-      (src, _dest) => src === uriString
-    );
+  private async getDefinitions(uriString: string): Promise<LocationLink[]> {
+    return withProgress({
+      location: ProgressLocation.Notification,
+      cancellable: true,
+      title: 'Finding definitions'
+    }, async (progress, token) => {
+      return getLocationsForUriString(
+        this.cli,
+        this.qs,
+        this.dbm,
+        uriString,
+        KeyType.DefinitionQuery,
+        progress,
+        token,
+        (src, _dest) => src === uriString
+      );
+    });
   }
 }
 
-export class TemplateQueryReferenceProvider implements vscode.ReferenceProvider {
+export class TemplateQueryReferenceProvider implements ReferenceProvider {
   private cache: CachedOperation<FullLocationLink[]>;
 
   constructor(
@@ -68,13 +88,13 @@ export class TemplateQueryReferenceProvider implements vscode.ReferenceProvider
   }
 
   async provideReferences(
-    document: vscode.TextDocument,
-    position: vscode.Position,
-    _context: vscode.ReferenceContext,
-    _token: vscode.CancellationToken
-  ): Promise<vscode.Location[]> {
+    document: TextDocument,
+    position: Position,
+    _context: ReferenceContext,
+    _token: CancellationToken
+  ): Promise<Location[]> {
     const fileLinks = await this.cache.get(document.uri.toString());
-    const locLinks: vscode.Location[] = [];
+    const locLinks: Location[] = [];
     for (const link of fileLinks) {
       if (link.targetRange!.contains(position)) {
         locLinks.push({ range: link.originSelectionRange!, uri: link.originUri });
@@ -84,52 +104,71 @@ export class TemplateQueryReferenceProvider implements vscode.ReferenceProvider
   }
 
   private async getReferences(uriString: string): Promise<FullLocationLink[]> {
-    return getLocationsForUriString(
-      this.cli,
-      this.qs,
-      this.dbm,
-      uriString,
-      KeyType.ReferenceQuery,
-      (_src, dest) => dest === uriString
-    );
+    return withProgress({
+      location: ProgressLocation.Notification,
+      cancellable: true,
+      title: 'Finding references'
+    }, async (progress, token) => {
+      return getLocationsForUriString(
+        this.cli,
+        this.qs,
+        this.dbm,
+        uriString,
+        KeyType.DefinitionQuery,
+        progress,
+        token,
+        (src, _dest) => src === uriString
+      );
+    });
   }
 }
 
 export class TemplatePrintAstProvider {
-  private cache: CachedOperation<QueryWithResults | undefined>;
+  private cache: CachedOperation<QueryWithResults>;
 
   constructor(
     private cli: CodeQLCliServer,
     private qs: QueryServerClient,
     private dbm: DatabaseManager,
   ) {
-    this.cache = new CachedOperation<QueryWithResults | undefined>(this.getAst.bind(this));
+    this.cache = new CachedOperation<QueryWithResults>(this.getAst.bind(this));
   }
 
-  async provideAst(document?: vscode.TextDocument): Promise<AstBuilder | undefined> {
+  async provideAst(
+    progress: ProgressCallback,
+    token: CancellationToken,
+    document?: TextDocument
+  ): Promise<AstBuilder | undefined> {
     if (!document) {
-      return;
-    }
-    const queryResults = await this.cache.get(document.uri.toString());
-    if (!queryResults) {
-      return;
+      throw new Error('Cannot view the AST. Please select a valid source file inside a CodeQL database.');
     }
+    const queryResults = this.shouldCache()
+      ? await this.cache.get(document.uri.toString(), progress, token)
+      : await this.getAst(document.uri.toString(), progress, token);
 
     return new AstBuilder(
       queryResults, this.cli,
-      this.dbm.findDatabaseItem(vscode.Uri.parse(queryResults.database.databaseUri!))!,
-      path.basename(document.fileName)
+      this.dbm.findDatabaseItem(Uri.parse(queryResults.database.databaseUri!, true))!,
+      document.fileName
     );
   }
 
-  private async getAst(uriString: string): Promise<QueryWithResults> {
-    const uri = vscode.Uri.parse(uriString, true);
+  private shouldCache() {
+    return !(isCanary() && NO_CACHE_AST_VIEWER.getValue<boolean>());
+  }
+
+  private async getAst(
+    uriString: string,
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<QueryWithResults> {
+    const uri = Uri.parse(uriString, true);
     if (uri.scheme !== zipArchiveScheme) {
-      throw new Error('AST Viewing is only available for databases with zipped source archives.');
+      throw new Error('Cannot view the AST. Please select a valid source file inside a CodeQL database.');
     }
 
     const zippedArchive = decodeSourceArchiveUri(uri);
-    const sourceArchiveUri = vscode.Uri.file(zippedArchive.sourceArchiveZipPath).with({ scheme: zipArchiveScheme });
+    const sourceArchiveUri = encodeArchiveBasePath(zippedArchive.sourceArchiveZipPath);
     const db = this.dbm.findDatabaseItemBySourceArchive(sourceArchiveUri);
 
     if (!db) {
@@ -137,9 +176,6 @@ export class TemplatePrintAstProvider {
     }
 
     const qlpack = await qlpackOfDatabase(this.cli, db);
-    if (!qlpack) {
-      throw new Error('Can\'t infer qlpack from database source archive');
-    }
     const queries = await resolveQueries(this.cli, qlpack, KeyType.PrintAstQuery);
     if (queries.length > 1) {
       throw new Error('Found multiple Print AST queries. Can\'t continue');
@@ -158,12 +194,15 @@ export class TemplatePrintAstProvider {
         }
       }
     };
+
     return await compileAndRunQueryAgainstDatabase(
       this.cli,
       this.qs,
       db,
       false,
-      vscode.Uri.file(query),
+      Uri.file(query),
+      progress,
+      token,
       templates
     );
   }

extensions/ql-vscode/src/databaseFetcher.ts

@@ -3,8 +3,7 @@ import * as unzipper from 'unzipper';
 import { zip } from 'zip-a-folder';
 import {
   Uri,
-  ProgressOptions,
-  ProgressLocation,
+  CancellationToken,
   commands,
   window,
 } from 'vscode';
@@ -13,57 +12,50 @@ import * as path from 'path';
 
 import { DatabaseManager, DatabaseItem } from './databases';
 import {
-  ProgressCallback,
-  showAndLogErrorMessage,
-  withProgress,
   showAndLogInformationMessage,
 } from './helpers';
+import {
+  reportStreamProgress,
+  ProgressCallback,
+} from './commandRunner';
 import { logger } from './logging';
+import { tmpDir } from './run-queries';
 
 /**
  * Prompts a user to fetch a database from a remote location. Database is assumed to be an archive file.
  *
- * @param databasesManager the DatabaseManager
+ * @param databaseManager the DatabaseManager
  * @param storagePath where to store the unzipped database.
  */
 export async function promptImportInternetDatabase(
-  databasesManager: DatabaseManager,
-  storagePath: string
+  databaseManager: DatabaseManager,
+  storagePath: string,
+  progress: ProgressCallback,
+  token: CancellationToken,
 ): Promise<DatabaseItem | undefined> {
-  let item: DatabaseItem | undefined = undefined;
-
-  try {
-    const databaseUrl = await window.showInputBox({
-      prompt: 'Enter URL of zipfile of database to download',
-    });
-    if (databaseUrl) {
-      validateHttpsUrl(databaseUrl);
-
-      const progressOptions: ProgressOptions = {
-        location: ProgressLocation.Notification,
-        title: 'Adding database from URL',
-        cancellable: false,
-      };
-      await withProgress(
-        progressOptions,
-        async (progress) =>
-          (item = await databaseArchiveFetcher(
-            databaseUrl,
-            databasesManager,
-            storagePath,
-            progress
-          ))
-      );
-      if (item) {
-        commands.executeCommand('codeQLDatabases.focus');
-        showAndLogInformationMessage('Database downloaded and imported successfully.');
-      }
-    }
-  } catch (e) {
-    showAndLogErrorMessage(e.message);
+  const databaseUrl = await window.showInputBox({
+    prompt: 'Enter URL of zipfile of database to download',
+  });
+  if (!databaseUrl) {
+    return;
   }
 
+  validateHttpsUrl(databaseUrl);
+
+  const item = await databaseArchiveFetcher(
+    databaseUrl,
+    databaseManager,
+    storagePath,
+    progress,
+    token
+  );
+
+  if (item) {
+    commands.executeCommand('codeQLDatabases.focus');
+    showAndLogInformationMessage('Database downloaded and imported successfully.');
+  }
   return item;
+
 }
 
 /**
@@ -71,97 +63,80 @@ export async function promptImportInternetDatabase(
  * User enters a project url and then the user is asked which language
  * to download (if there is more than one)
  *
- * @param databasesManager the DatabaseManager
+ * @param databaseManager the DatabaseManager
  * @param storagePath where to store the unzipped database.
  */
 export async function promptImportLgtmDatabase(
-  databasesManager: DatabaseManager,
-  storagePath: string
+  databaseManager: DatabaseManager,
+  storagePath: string,
+  progress: ProgressCallback,
+  token: CancellationToken
 ): Promise<DatabaseItem | undefined> {
-  let item: DatabaseItem | undefined = undefined;
-
-  try {
-    const lgtmUrl = await window.showInputBox({
-      prompt:
-        'Enter the project URL on LGTM (e.g., https://lgtm.com/projects/g/github/codeql)',
-    });
-    if (!lgtmUrl) {
-      return;
-    }
-    if (looksLikeLgtmUrl(lgtmUrl)) {
-      const databaseUrl = await convertToDatabaseUrl(lgtmUrl);
-      if (databaseUrl) {
-        const progressOptions: ProgressOptions = {
-          location: ProgressLocation.Notification,
-          title: 'Adding database from LGTM',
-          cancellable: false,
-        };
-        await withProgress(
-          progressOptions,
-          async (progress) =>
-            (item = await databaseArchiveFetcher(
-              databaseUrl,
-              databasesManager,
-              storagePath,
-              progress
-            ))
-        );
-        if (item) {
-          commands.executeCommand('codeQLDatabases.focus');
-          showAndLogInformationMessage('Database downloaded and imported successfully.');
-        }
-      }
-    } else {
-      throw new Error(`Invalid LGTM URL: ${lgtmUrl}`);
-    }
-  } catch (e) {
-    showAndLogErrorMessage(e.message);
+  const lgtmUrl = await window.showInputBox({
+    prompt:
+      'Enter the project slug or URL on LGTM (e.g., g/github/codeql or https://lgtm.com/projects/g/github/codeql)',
+  });
+  if (!lgtmUrl) {
+    return;
   }
 
-  return item;
+  if (looksLikeLgtmUrl(lgtmUrl)) {
+    const databaseUrl = await convertToDatabaseUrl(lgtmUrl);
+    if (databaseUrl) {
+      const item = await databaseArchiveFetcher(
+        databaseUrl,
+        databaseManager,
+        storagePath,
+        progress,
+        token
+      );
+      if (item) {
+        commands.executeCommand('codeQLDatabases.focus');
+        showAndLogInformationMessage('Database downloaded and imported successfully.');
+      }
+      return item;
+    }
+  } else {
+    throw new Error(`Invalid LGTM URL: ${lgtmUrl}`);
+  }
+  return;
 }
 
 /**
  * Imports a database from a local archive.
  *
  * @param databaseUrl the file url of the archive to import
- * @param databasesManager the DatabaseManager
+ * @param databaseManager the DatabaseManager
  * @param storagePath where to store the unzipped database.
  */
 export async function importArchiveDatabase(
   databaseUrl: string,
-  databasesManager: DatabaseManager,
-  storagePath: string
+  databaseManager: DatabaseManager,
+  storagePath: string,
+  progress: ProgressCallback,
+  token: CancellationToken,
 ): Promise<DatabaseItem | undefined> {
-  let item: DatabaseItem | undefined = undefined;
   try {
-    const progressOptions: ProgressOptions = {
-      location: ProgressLocation.Notification,
-      title: 'Importing database from archive',
-      cancellable: false,
-    };
-    await withProgress(
-      progressOptions,
-      async (progress) =>
-        (item = await databaseArchiveFetcher(
-          databaseUrl,
-          databasesManager,
-          storagePath,
-          progress
-        ))
+    const item = await databaseArchiveFetcher(
+      databaseUrl,
+      databaseManager,
+      storagePath,
+      progress,
+      token
     );
     if (item) {
       commands.executeCommand('codeQLDatabases.focus');
       showAndLogInformationMessage('Database unzipped and imported successfully.');
     }
+    return item;
   } catch (e) {
     if (e.message.includes('unexpected end of file')) {
-      showAndLogErrorMessage('Database is corrupt or too large. Try unzipping outside of VS Code and importing the unzipped folder instead.');
+      throw new Error('Database is corrupt or too large. Try unzipping outside of VS Code and importing the unzipped folder instead.');
     } else {
-      showAndLogErrorMessage(e.message);
+      // delegate
+      throw e;
     }
   }
-  return item;
 }
 
 /**
@@ -169,17 +144,19 @@ export async function importArchiveDatabase(
  * or in the local filesystem.
  *
  * @param databaseUrl URL from which to grab the database
- * @param databasesManager the DatabaseManager
+ * @param databaseManager the DatabaseManager
  * @param storagePath where to store the unzipped database.
- * @param progressCallback optional callback to send progress messages to
+ * @param progress callback to send progress messages to
+ * @param token cancellation token
  */
 async function databaseArchiveFetcher(
   databaseUrl: string,
-  databasesManager: DatabaseManager,
+  databaseManager: DatabaseManager,
   storagePath: string,
-  progressCallback?: ProgressCallback
+  progress: ProgressCallback,
+  token: CancellationToken
 ): Promise<DatabaseItem> {
-  progressCallback?.({
+  progress({
     message: 'Getting database',
     step: 1,
     maxStep: 4,
@@ -191,12 +168,12 @@ async function databaseArchiveFetcher(
   const unzipPath = await getStorageFolder(storagePath, databaseUrl);
 
   if (isFile(databaseUrl)) {
-    await readAndUnzip(databaseUrl, unzipPath);
+    await readAndUnzip(databaseUrl, unzipPath, progress);
   } else {
-    await fetchAndUnzip(databaseUrl, unzipPath, progressCallback);
+    await fetchAndUnzip(databaseUrl, unzipPath, progress);
   }
 
-  progressCallback?.({
+  progress({
     message: 'Opening database',
     step: 3,
     maxStep: 4,
@@ -209,15 +186,15 @@ async function databaseArchiveFetcher(
     'codeql-database.yml'
   );
   if (dbPath) {
-    progressCallback?.({
+    progress({
       message: 'Validating and fixing source location',
       step: 4,
       maxStep: 4,
     });
     await ensureZippedSourceLocation(dbPath);
 
-    const item = await databasesManager.openDatabase(Uri.file(dbPath));
-    databasesManager.setCurrentDatabaseItem(item);
+    const item = await databaseManager.openDatabase(progress, token, Uri.file(dbPath));
+    await databaseManager.setCurrentDatabaseItem(item);
     return item;
   } else {
     throw new Error('Database not found in archive.');
@@ -264,48 +241,67 @@ function validateHttpsUrl(databaseUrl: string) {
   }
 }
 
-async function readAndUnzip(databaseUrl: string, unzipPath: string) {
-  const databaseFile = Uri.parse(databaseUrl).fsPath;
-  const directory = await unzipper.Open.file(databaseFile);
+async function readAndUnzip(
+  zipUrl: string,
+  unzipPath: string,
+  progress?: ProgressCallback
+) {
+  // TODO: Providing progress as the file is unzipped is currently blocked
+  // on https://github.com/ZJONSSON/node-unzipper/issues/222
+  const zipFile = Uri.parse(zipUrl).fsPath;
+  progress?.({
+    maxStep: 10,
+    step: 9,
+    message: `Unzipping into ${path.basename(unzipPath)}`
+  });
+  // Must get the zip central directory since streaming the
+  // zip contents may not have correct local file headers.
+  // Instead, we can only rely on the central directory.
+  const directory = await unzipper.Open.file(zipFile);
   await directory.extract({ path: unzipPath });
 }
 
 async function fetchAndUnzip(
   databaseUrl: string,
   unzipPath: string,
-  progressCallback?: ProgressCallback
+  progress?: ProgressCallback
 ) {
-  const response = await fetch(databaseUrl);
+  // Although it is possible to download and stream directly to an unzipped directory,
+  // we need to avoid this for two reasons. The central directory is located at the
+  // end of the zip file. It is the source of truth of the content locations. Individual
+  // file headers may be incorrect. Additionally, saving to file first will reduce memory
+  // pressure compared with unzipping while downloading the archive.
 
-  await checkForFailingResponse(response);
+  const archivePath = path.join(tmpDir.name, `archive-${Date.now()}.zip`);
 
-  const unzipStream = unzipper.Extract({
-    path: unzipPath,
-  });
-
-  progressCallback?.({
+  progress?.({
     maxStep: 3,
-    message: 'Unzipping database',
-    step: 2,
-  });
-  await new Promise((resolve, reject) => {
-    const handler = (err: Error) => {
-      if (err.message.startsWith('invalid signature')) {
-        reject(new Error('Not a valid archive.'));
-      } else {
-        reject(err);
-      }
-    };
-    response.body.on('error', handler);
-    unzipStream.on('error', handler);
-    unzipStream.on('close', resolve);
-    response.body.pipe(unzipStream);
+    message: 'Downloading database',
+    step: 1,
   });
+
+  const response = await checkForFailingResponse(await fetch(databaseUrl));
+  const archiveFileStream = fs.createWriteStream(archivePath);
+
+  const contentLength = response.headers.get('content-length');
+  const totalNumBytes = contentLength ? parseInt(contentLength, 10) : undefined;
+  reportStreamProgress(response.body, 'Downloading database', totalNumBytes, progress);
+
+  await new Promise((resolve, reject) =>
+    response.body.pipe(archiveFileStream)
+      .on('finish', resolve)
+      .on('error', reject)
+  );
+
+  await readAndUnzip(Uri.file(archivePath).toString(true), unzipPath, progress);
+
+  // remove archivePath eagerly since these archives can be large.
+  await fs.remove(archivePath);
 }
 
-async function checkForFailingResponse(response: Response): Promise<void | never> {
+async function checkForFailingResponse(response: Response): Promise<Response | never> {
   if (response.ok) {
-    return;
+    return response;
   }
 
   // An error downloading the database. Attempt to extract the resaon behind it.
@@ -356,13 +352,14 @@ export async function findDirWithFile(
 
 /**
  * The URL pattern is https://lgtm.com/projects/{provider}/{org}/{name}/{irrelevant-subpages}.
- * There are several possibilities for the provider: in addition to GitHub.com(g),
+ * There are several possibilities for the provider: in addition to GitHub.com (g),
  * LGTM currently hosts projects from Bitbucket (b), GitLab (gl) and plain git (git).
  *
- * After the {provider}/{org}/{name} path components, there may be the components
- * related to sub pages.
+ * This function accepts any url that matches the pattern above. It also accepts the
+ * raw project slug, e.g., `g/myorg/myproject`
  *
- * This function accepts any url that matches the patter above
+ * After the `{provider}/{org}/{name}` path components, there may be the components
+ * related to sub pages.
  *
  * @param lgtmUrl The URL to the lgtm project
  *
@@ -374,6 +371,10 @@ export function looksLikeLgtmUrl(lgtmUrl: string | undefined): lgtmUrl is string
     return false;
   }
 
+  if (convertRawLgtmSlug(lgtmUrl)) {
+    return true;
+  }
+
   try {
     const uri = Uri.parse(lgtmUrl, true);
     if (uri.scheme !== 'https') {
@@ -391,9 +392,23 @@ export function looksLikeLgtmUrl(lgtmUrl: string | undefined): lgtmUrl is string
   }
 }
 
+function convertRawLgtmSlug(maybeSlug: string): string | undefined {
+  if (!maybeSlug) {
+    return;
+  }
+  const segments = maybeSlug.split('/');
+  const providers = ['g', 'gl', 'b', 'git'];
+  if (segments.length === 3 && providers.includes(segments[0])) {
+    return `https://lgtm.com/projects/${maybeSlug}`;
+  }
+  return;
+}
+
 // exported for testing
 export async function convertToDatabaseUrl(lgtmUrl: string) {
   try {
+    lgtmUrl = convertRawLgtmSlug(lgtmUrl) || lgtmUrl;
+
     const uri = Uri.parse(lgtmUrl, true);
     const paths = ['api', 'v1.0'].concat(
       uri.path.split('/').filter((segment) => segment)

extensions/ql-vscode/src/databases-ui.ts

@@ -1,10 +1,8 @@
 import * as path from 'path';
-import { DisposableObject } from './vscode-utils/disposable-object';
+import { DisposableObject } from './pure/disposable-object';
 import {
-  commands,
   Event,
   EventEmitter,
-  ExtensionContext,
   ProviderResult,
   TreeDataProvider,
   TreeItem,
@@ -14,22 +12,32 @@ import {
 } from 'vscode';
 import * as fs from 'fs-extra';
 
-import * as cli from './cli';
 import {
+  DatabaseChangedEvent,
   DatabaseItem,
   DatabaseManager,
-  getUpgradesDirectories,
 } from './databases';
-import { getOnDiskWorkspaceFolders, showAndLogErrorMessage } from './helpers';
+import {
+  commandRunner,
+  commandRunnerWithProgress,
+  ProgressCallback,
+} from './commandRunner';
+import {
+  isLikelyDatabaseRoot,
+  isLikelyDbLanguageFolder,
+  showAndLogErrorMessage
+} from './helpers';
 import { logger } from './logging';
-import { clearCacheInDatabase, UserCancellationException } from './run-queries';
+import { clearCacheInDatabase } from './run-queries';
 import * as qsClient from './queryserver-client';
-import { upgradeDatabase } from './upgrades';
+import { upgradeDatabaseExplicit } from './upgrades';
 import {
   importArchiveDatabase,
   promptImportInternetDatabase,
   promptImportLgtmDatabase,
 } from './databaseFetcher';
+import { CancellationToken } from 'vscode';
+import { asyncFilter } from './pure/helpers-pure';
 
 type ThemableIconPath = { light: string; dark: string } | string;
 
@@ -72,14 +80,12 @@ class DatabaseTreeDataProvider extends DisposableObject
   implements TreeDataProvider<DatabaseItem> {
   private _sortOrder = SortOrder.NameAsc;
 
-  private readonly _onDidChangeTreeData = new EventEmitter<
-    DatabaseItem | undefined
-  >();
+  private readonly _onDidChangeTreeData = this.push(new EventEmitter<DatabaseItem | undefined>());
   private currentDatabaseItem: DatabaseItem | undefined;
 
   constructor(
-    private ctx: ExtensionContext,
-    private databaseManager: DatabaseManager
+    private databaseManager: DatabaseManager,
+    private readonly extensionPath: string
   ) {
     super();
 
@@ -101,19 +107,22 @@ class DatabaseTreeDataProvider extends DisposableObject
     return this._onDidChangeTreeData.event;
   }
 
-  private handleDidChangeDatabaseItem = (
-    databaseItem: DatabaseItem | undefined
-  ): void => {
-    this._onDidChangeTreeData.fire(databaseItem);
+  private handleDidChangeDatabaseItem = (event: DatabaseChangedEvent): void => {
+    // Note that events from the databse manager are instances of DatabaseChangedEvent
+    // and events fired by the UI are instances of DatabaseItem
+
+    // When event.item is undefined, then the entire tree is refreshed.
+    // When event.item is a db item, then only that item is refreshed.
+    this._onDidChangeTreeData.fire(event.item);
   };
 
   private handleDidChangeCurrentDatabaseItem = (
-    databaseItem: DatabaseItem | undefined
+    event: DatabaseChangedEvent
   ): void => {
     if (this.currentDatabaseItem) {
       this._onDidChangeTreeData.fire(this.currentDatabaseItem);
     }
-    this.currentDatabaseItem = databaseItem;
+    this.currentDatabaseItem = event.item;
     if (this.currentDatabaseItem) {
       this._onDidChangeTreeData.fire(this.currentDatabaseItem);
     }
@@ -123,16 +132,17 @@ class DatabaseTreeDataProvider extends DisposableObject
     const item = new TreeItem(element.name);
     if (element === this.currentDatabaseItem) {
       item.iconPath = joinThemableIconPath(
-        this.ctx.extensionPath,
+        this.extensionPath,
         SELECTED_DATABASE_ICON
       );
     } else if (element.error !== undefined) {
       item.iconPath = joinThemableIconPath(
-        this.ctx.extensionPath,
+        this.extensionPath,
         INVALID_DATABASE_ICON
       );
     }
     item.tooltip = element.databaseUri.fsPath;
+    item.description = element.language;
     return item;
   }
 
@@ -205,16 +215,15 @@ export class DatabaseUI extends DisposableObject {
   private treeDataProvider: DatabaseTreeDataProvider;
 
   public constructor(
-    ctx: ExtensionContext,
-    private cliserver: cli.CodeQLCliServer,
     private databaseManager: DatabaseManager,
     private readonly queryServer: qsClient.QueryServerClient | undefined,
-    private readonly storagePath: string
+    private readonly storagePath: string,
+    readonly extensionPath: string
   ) {
     super();
 
     this.treeDataProvider = this.push(
-      new DatabaseTreeDataProvider(ctx, databaseManager)
+      new DatabaseTreeDataProvider(databaseManager, extensionPath)
     );
     this.push(
       window.createTreeView('codeQLDatabases', {
@@ -222,90 +231,129 @@ export class DatabaseUI extends DisposableObject {
         canSelectMany: true,
       })
     );
+  }
 
+  init() {
     logger.log('Registering database panel commands.');
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQL.setCurrentDatabase',
-        this.handleSetCurrentDatabase
+        this.handleSetCurrentDatabase,
+        {
+          title: 'Importing database from archive',
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQL.upgradeCurrentDatabase',
-        this.handleUpgradeCurrentDatabase
+        this.handleUpgradeCurrentDatabase,
+        {
+          title: 'Upgrading current database',
+          cancellable: true,
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand('codeQL.clearCache', this.handleClearCache)
+    this.push(
+      commandRunnerWithProgress(
+        'codeQL.clearCache',
+        this.handleClearCache,
+        {
+          title: 'Clearing Cache',
+        })
     );
 
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.chooseDatabaseFolder',
-        this.handleChooseDatabaseFolder
+        this.handleChooseDatabaseFolder,
+        {
+          title: 'Adding database from folder',
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.chooseDatabaseArchive',
-        this.handleChooseDatabaseArchive
+        this.handleChooseDatabaseArchive,
+        {
+          title: 'Adding database from archive',
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.chooseDatabaseInternet',
-        this.handleChooseDatabaseInternet
+        this.handleChooseDatabaseInternet,
+        {
+          title: 'Adding database from URL',
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.chooseDatabaseLgtm',
-        this.handleChooseDatabaseLgtm
-      )
+        this.handleChooseDatabaseLgtm,
+        {
+          title: 'Adding database from LGTM',
+        })
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLDatabases.setCurrentDatabase',
         this.handleMakeCurrentDatabase
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLDatabases.sortByName',
         this.handleSortByName
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLDatabases.sortByDateAdded',
         this.handleSortByDateAdded
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.removeDatabase',
-        this.handleRemoveDatabase
+        this.handleRemoveDatabase,
+        {
+          title: 'Removing database',
+          cancellable: false
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunnerWithProgress(
         'codeQLDatabases.upgradeDatabase',
-        this.handleUpgradeDatabase
+        this.handleUpgradeDatabase,
+        {
+          title: 'Upgrading database',
+          cancellable: true,
+        }
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLDatabases.renameDatabase',
         this.handleRenameDatabase
       )
     );
-    ctx.subscriptions.push(
-      commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLDatabases.openDatabaseFolder',
         this.handleOpenFolder
       )
     );
+    this.push(
+      commandRunner(
+        'codeQLDatabases.removeOrphanedDatabases',
+        this.handleRemoveOrphanedDatabases
+      )
+    );
   }
 
   private handleMakeCurrentDatabase = async (
@@ -314,40 +362,120 @@ export class DatabaseUI extends DisposableObject {
     await this.databaseManager.setCurrentDatabaseItem(databaseItem);
   };
 
-  handleChooseDatabaseFolder = async (): Promise<DatabaseItem | undefined> => {
+  handleChooseDatabaseFolder = async (
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<DatabaseItem | undefined> => {
     try {
-      return await this.chooseAndSetDatabase(true);
+      return await this.chooseAndSetDatabase(true, progress, token);
     } catch (e) {
       showAndLogErrorMessage(e.message);
       return undefined;
     }
   };
 
-  handleChooseDatabaseArchive = async (): Promise<DatabaseItem | undefined> => {
+  handleRemoveOrphanedDatabases = async (): Promise<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.');
+      return;
+    }
+
+    dbDirs =
+      // read directory
+      (await fs.readdir(this.storagePath, { withFileTypes: true }))
+        // remove non-directories
+        .filter(dirent => dirent.isDirectory())
+        // get the full path
+        .map(dirent => path.join(this.storagePath, dirent.name))
+        // remove databases still in workspace
+        .filter(dbDir => {
+          const dbUri = Uri.file(dbDir);
+          return this.databaseManager.databaseItems.every(item => item.databaseUri.fsPath !== dbUri.fsPath);
+        });
+
+    // remove non-databases
+    dbDirs = await asyncFilter(dbDirs, isLikelyDatabaseRoot);
+
+    if (!dbDirs.length) {
+      logger.log('No orphaned databases found.');
+      return;
+    }
+
+    // delete
+    const failures = [] as string[];
+    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
+        } catch (e) {
+          failures.push(`${path.basename(dbDir)}`);
+        }
+      })
+    );
+
+    if (failures.length) {
+      const dirname = path.dirname(failures[0]);
+      showAndLogErrorMessage(
+        `Failed to delete unused databases (${
+        failures.join(', ')
+        }).\nTo delete unused databases, please remove them manually from the storage folder ${dirname}.`
+      );
+    }
+  };
+
+
+  handleChooseDatabaseArchive = async (
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<DatabaseItem | undefined> => {
     try {
-      return await this.chooseAndSetDatabase(false);
+      return await this.chooseAndSetDatabase(false, progress, token);
     } catch (e) {
       showAndLogErrorMessage(e.message);
       return undefined;
     }
   };
 
-  handleChooseDatabaseInternet = async (): Promise<
+  handleChooseDatabaseInternet = async (
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<
     DatabaseItem | undefined
   > => {
     return await promptImportInternetDatabase(
       this.databaseManager,
-      this.storagePath
+      this.storagePath,
+      progress,
+      token
     );
   };
 
-  handleChooseDatabaseLgtm = async (): Promise<DatabaseItem | undefined> => {
+  handleChooseDatabaseLgtm = async (
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<DatabaseItem | undefined> => {
     return await promptImportLgtmDatabase(
       this.databaseManager,
-      this.storagePath
+      this.storagePath,
+      progress,
+      token
     );
   };
 
+  async tryUpgradeCurrentDatabase(
+    progress: ProgressCallback,
+    token: CancellationToken
+  ) {
+    await this.handleUpgradeCurrentDatabase(progress, token);
+  }
+
   private handleSortByName = async () => {
     if (this.treeDataProvider.sortOrder === SortOrder.NameAsc) {
       this.treeDataProvider.sortOrder = SortOrder.NameDesc;
@@ -364,127 +492,116 @@ export class DatabaseUI extends DisposableObject {
     }
   };
 
-  private handleUpgradeCurrentDatabase = async (): Promise<void> => {
+  private handleUpgradeCurrentDatabase = async (
+    progress: ProgressCallback,
+    token: CancellationToken,
+  ): Promise<void> => {
     await this.handleUpgradeDatabase(
+      progress, token,
       this.databaseManager.currentDatabaseItem,
       []
     );
   };
 
   private handleUpgradeDatabase = async (
+    progress: ProgressCallback,
+    token: CancellationToken,
     databaseItem: DatabaseItem | undefined,
-    multiSelect: DatabaseItem[] | undefined
+    multiSelect: DatabaseItem[] | undefined,
   ): Promise<void> => {
-    try {
-      if (multiSelect?.length) {
-        await Promise.all(
-          multiSelect.map((dbItem) => this.handleUpgradeDatabase(dbItem, []))
-        );
-      }
-      if (this.queryServer === undefined) {
-        logger.log(
-          'Received request to upgrade database, but there is no running query server.'
-        );
-        return;
-      }
-      if (databaseItem === undefined) {
-        logger.log(
-          'Received request to upgrade database, but no database was provided.'
-        );
-        return;
-      }
-      if (databaseItem.contents === undefined) {
-        logger.log(
-          'Received request to upgrade database, but database contents could not be found.'
-        );
-        return;
-      }
-      if (databaseItem.contents.dbSchemeUri === undefined) {
-        logger.log(
-          'Received request to upgrade database, but database has no schema.'
-        );
-        return;
-      }
-
-      // Search for upgrade scripts in any workspace folders available
-      const searchPath: string[] = getOnDiskWorkspaceFolders();
-
-      const upgradeInfo = await this.cliserver.resolveUpgrades(
-        databaseItem.contents.dbSchemeUri.fsPath,
-        searchPath
+    if (multiSelect?.length) {
+      await Promise.all(
+        multiSelect.map((dbItem) => this.handleUpgradeDatabase(progress, token, dbItem, []))
       );
-
-      const { scripts, finalDbscheme } = upgradeInfo;
-
-      if (finalDbscheme === undefined) {
-        logger.log('Could not determine target dbscheme to upgrade to.');
-        return;
-      }
-      const targetDbSchemeUri = Uri.file(finalDbscheme);
-
-      await upgradeDatabase(
-        this.queryServer,
-        databaseItem,
-        targetDbSchemeUri,
-        getUpgradesDirectories(scripts)
-      );
-    } catch (e) {
-      if (e instanceof UserCancellationException) {
-        logger.log(e.message);
-      } else throw e;
     }
+    if (this.queryServer === undefined) {
+      throw new Error(
+        'Received request to upgrade database, but there is no running query server.'
+      );
+    }
+    if (databaseItem === undefined) {
+      throw new Error(
+        'Received request to upgrade database, but no database was provided.'
+      );
+    }
+    if (databaseItem.contents === undefined) {
+      throw new Error(
+        'Received request to upgrade database, but database contents could not be found.'
+      );
+    }
+    if (databaseItem.contents.dbSchemeUri === undefined) {
+      throw new Error(
+        'Received request to upgrade database, but database has no schema.'
+      );
+    }
+
+    // Search for upgrade scripts in any workspace folders available
+
+    await upgradeDatabaseExplicit(
+      this.queryServer,
+      databaseItem,
+      progress,
+      token
+    );
   };
 
-  private handleClearCache = async (): Promise<void> => {
+  private handleClearCache = async (
+    progress: ProgressCallback,
+    token: CancellationToken,
+  ): Promise<void> => {
     if (
       this.queryServer !== undefined &&
       this.databaseManager.currentDatabaseItem !== undefined
     ) {
       await clearCacheInDatabase(
         this.queryServer,
-        this.databaseManager.currentDatabaseItem
+        this.databaseManager.currentDatabaseItem,
+        progress,
+        token
       );
     }
   };
 
   private handleSetCurrentDatabase = async (
-    uri: Uri
-  ): Promise<DatabaseItem | undefined> => {
+    progress: ProgressCallback,
+    token: CancellationToken,
+    uri: Uri,
+  ): Promise<void> => {
     try {
       // Assume user has selected an archive if the file has a .zip extension
       if (uri.path.endsWith('.zip')) {
-        return await importArchiveDatabase(
+        await importArchiveDatabase(
           uri.toString(true),
           this.databaseManager,
-          this.storagePath
+          this.storagePath,
+          progress,
+          token
         );
+      } else {
+        await this.setCurrentDatabase(progress, token, uri);
       }
-
-      return await this.setCurrentDatabase(uri);
     } catch (e) {
-      showAndLogErrorMessage(
+      // 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
         }`
       );
-      return undefined;
     }
   };
 
-  private handleRemoveDatabase = (
+  private handleRemoveDatabase = async (
+    progress: ProgressCallback,
+    token: CancellationToken,
     databaseItem: DatabaseItem,
     multiSelect: DatabaseItem[] | undefined
-  ): void => {
-    try {
-      if (multiSelect?.length) {
-        multiSelect.forEach((dbItem) =>
-          this.databaseManager.removeDatabaseItem(dbItem)
-        );
-      } else {
-        this.databaseManager.removeDatabaseItem(databaseItem);
-      }
-    } catch (e) {
-      showAndLogErrorMessage(e.message);
+  ): Promise<void> => {
+    if (multiSelect?.length) {
+      await Promise.all(multiSelect.map((dbItem) =>
+        this.databaseManager.removeDatabaseItem(progress, token, dbItem)
+      ));
+    } else {
+      await this.databaseManager.removeDatabaseItem(progress, token, databaseItem);
     }
   };
 
@@ -492,19 +609,15 @@ export class DatabaseUI extends DisposableObject {
     databaseItem: DatabaseItem,
     multiSelect: DatabaseItem[] | undefined
   ): Promise<void> => {
-    try {
-      this.assertSingleDatabase(multiSelect);
+    this.assertSingleDatabase(multiSelect);
 
-      const newName = await window.showInputBox({
-        prompt: 'Choose new database name',
-        value: databaseItem.name,
-      });
+    const newName = await window.showInputBox({
+      prompt: 'Choose new database name',
+      value: databaseItem.name,
+    });
 
-      if (newName) {
-        this.databaseManager.renameDatabaseItem(databaseItem, newName);
-      }
-    } catch (e) {
-      showAndLogErrorMessage(e.message);
+    if (newName) {
+      this.databaseManager.renameDatabaseItem(databaseItem, newName);
     }
   };
 
@@ -512,16 +625,12 @@ export class DatabaseUI extends DisposableObject {
     databaseItem: DatabaseItem,
     multiSelect: DatabaseItem[] | undefined
   ): Promise<void> => {
-    try {
-      if (multiSelect?.length) {
-        await Promise.all(
-          multiSelect.map((dbItem) => env.openExternal(dbItem.databaseUri))
-        );
-      } else {
-        await env.openExternal(databaseItem.databaseUri);
-      }
-    } catch (e) {
-      showAndLogErrorMessage(e.message);
+    if (multiSelect?.length) {
+      await Promise.all(
+        multiSelect.map((dbItem) => env.openExternal(dbItem.databaseUri))
+      );
+    } else {
+      await env.openExternal(databaseItem.databaseUri);
     }
   };
 
@@ -530,20 +639,25 @@ export class DatabaseUI extends DisposableObject {
    * current database, ask the user for one, and return that, or
    * undefined if they cancel.
    */
-  public async getDatabaseItem(): Promise<DatabaseItem | undefined> {
+  public async getDatabaseItem(
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<DatabaseItem | undefined> {
     if (this.databaseManager.currentDatabaseItem === undefined) {
-      await this.chooseAndSetDatabase(false);
+      await this.chooseAndSetDatabase(false, progress, token);
     }
 
     return this.databaseManager.currentDatabaseItem;
   }
 
   private async setCurrentDatabase(
+    progress: ProgressCallback,
+    token: CancellationToken,
     uri: Uri
   ): Promise<DatabaseItem | undefined> {
     let databaseItem = this.databaseManager.findDatabaseItem(uri);
     if (databaseItem === undefined) {
-      databaseItem = await this.databaseManager.openDatabase(uri);
+      databaseItem = await this.databaseManager.openDatabase(progress, token, uri);
     }
     await this.databaseManager.setCurrentDatabaseItem(databaseItem);
 
@@ -555,7 +669,9 @@ export class DatabaseUI extends DisposableObject {
    * operation was canceled.
    */
   private async chooseAndSetDatabase(
-    byFolder: boolean
+    byFolder: boolean,
+    progress: ProgressCallback,
+    token: CancellationToken,
   ): Promise<DatabaseItem | undefined> {
     const uri = await chooseDatabaseDir(byFolder);
 
@@ -566,14 +682,16 @@ export class DatabaseUI extends DisposableObject {
     if (byFolder) {
       const fixedUri = await this.fixDbUri(uri);
       // we are selecting a database folder
-      return await this.setCurrentDatabase(fixedUri);
+      return await this.setCurrentDatabase(progress, token, fixedUri);
     } else {
       // we are selecting a database archive. Must unzip into a workspace-controlled area
       // before importing.
       return await importArchiveDatabase(
         uri.toString(true),
         this.databaseManager,
-        this.storagePath
+        this.storagePath,
+        progress,
+        token
       );
     }
   }
@@ -595,7 +713,7 @@ export class DatabaseUI extends DisposableObject {
       dbPath = path.dirname(dbPath);
     }
 
-    if (isLikelyDbFolder(dbPath)) {
+    if (isLikelyDbLanguageFolder(dbPath)) {
       dbPath = path.dirname(dbPath);
     }
     return Uri.file(dbPath);
@@ -610,8 +728,3 @@ export class DatabaseUI extends DisposableObject {
     }
   }
 }
-
-const dbRegeEx = /^db-(javascript|go|cpp|java|python)$/;
-function isLikelyDbFolder(dbPath: string) {
-  return path.basename(dbPath).match(dbRegeEx);
-}

extensions/ql-vscode/src/databases.ts

@@ -4,11 +4,21 @@ import * as path from 'path';
 import * as vscode from 'vscode';
 import * as cli from './cli';
 import { ExtensionContext } from 'vscode';
-import { showAndLogErrorMessage, showAndLogWarningMessage, showAndLogInformationMessage } from './helpers';
-import { zipArchiveScheme, encodeSourceArchiveUri, decodeSourceArchiveUri } from './archive-filesystem-provider';
-import { DisposableObject } from './vscode-utils/disposable-object';
-import { QueryServerConfig } from './config';
+import {
+  showAndLogErrorMessage,
+  showAndLogWarningMessage,
+  showAndLogInformationMessage,
+  isLikelyDatabaseRoot
+} from './helpers';
+import {
+  ProgressCallback,
+  withProgress
+} from './commandRunner';
+import { zipArchiveScheme, encodeArchiveBasePath, decodeSourceArchiveUri, encodeSourceArchiveUri } from './archive-filesystem-provider';
+import { DisposableObject } from './pure/disposable-object';
 import { Logger, logger } from './logging';
+import { registerDatabases, Dataset, deregisterDatabases } from './pure/messages';
+import { QueryServerClient } from './queryserver-client';
 
 /**
  * databases.ts
@@ -36,11 +46,13 @@ export interface DatabaseOptions {
   displayName?: string;
   ignoreSourceArchive?: boolean;
   dateAdded?: number | undefined;
+  language?: string;
 }
 
-interface FullDatabaseOptions extends DatabaseOptions {
+export interface FullDatabaseOptions extends DatabaseOptions {
   ignoreSourceArchive: boolean;
   dateAdded: number | undefined;
+  language: string | undefined;
 }
 
 interface PersistedDatabaseItem {
@@ -121,13 +133,15 @@ async function findSourceArchive(
 
     if (await fs.pathExists(basePath)) {
       return vscode.Uri.file(basePath);
-    }
-    else if (await fs.pathExists(zipPath)) {
-      return vscode.Uri.file(zipPath).with({ scheme: zipArchiveScheme });
+    } else if (await fs.pathExists(zipPath)) {
+      return encodeArchiveBasePath(zipPath);
     }
   }
-  if (!silent)
-    showAndLogInformationMessage(`Could not find source archive for database '${databasePath}'. Assuming paths are absolute.`);
+  if (!silent) {
+    showAndLogInformationMessage(
+      `Could not find source archive for database '${databasePath}'. Assuming paths are absolute.`
+    );
+  }
   return undefined;
 }
 
@@ -191,6 +205,9 @@ export interface DatabaseItem {
   readonly databaseUri: vscode.Uri;
   /** The name of the database to be displayed in the UI */
   name: string;
+
+  /** The primary language of the database or empty string if unknown */
+  readonly language: string;
   /** The URI of the database's source archive, or `undefined` if no source archive is to be used. */
   readonly sourceArchive: vscode.Uri | undefined;
   /**
@@ -247,18 +264,44 @@ export interface DatabaseItem {
    * Holds if `uri` belongs to this database's source archive.
    */
   belongsToSourceArchiveExplorerUri(uri: vscode.Uri): boolean;
+
+  /**
+   * Gets the state of this database, to be persisted in the workspace state.
+   */
+  getPersistedState(): PersistedDatabaseItem;
 }
 
-class DatabaseItemImpl implements DatabaseItem {
+export enum DatabaseEventKind {
+  Add = 'Add',
+  Remove = 'Remove',
+
+  // Fired when databases are refreshed from persisted state
+  Refresh = 'Refresh',
+
+  // Fired when the current database changes
+  Change = 'Change',
+
+  Rename = 'Rename'
+}
+
+export interface DatabaseChangedEvent {
+  kind: DatabaseEventKind;
+  item: DatabaseItem | undefined;
+}
+
+// Exported for testing
+export class DatabaseItemImpl implements DatabaseItem {
   private _error: Error | undefined = undefined;
   private _contents: DatabaseContents | undefined;
   /** A cache of database info */
   private _dbinfo: cli.DbInfo | undefined;
 
-  public constructor(public readonly databaseUri: vscode.Uri,
-    contents: DatabaseContents | undefined, private options: FullDatabaseOptions,
-    private readonly onChanged: (item: DatabaseItemImpl) => void) {
-
+  public constructor(
+    public readonly databaseUri: vscode.Uri,
+    contents: DatabaseContents | undefined,
+    private options: FullDatabaseOptions,
+    private readonly onChanged: (event: DatabaseChangedEvent) => void
+  ) {
     this._contents = contents;
   }
 
@@ -281,8 +324,7 @@ class DatabaseItemImpl implements DatabaseItem {
   public get sourceArchive(): vscode.Uri | undefined {
     if (this.options.ignoreSourceArchive || (this._contents === undefined)) {
       return undefined;
-    }
-    else {
+    } else {
       return this._contents.sourceArchiveUri;
     }
   }
@@ -312,46 +354,52 @@ class DatabaseItemImpl implements DatabaseItem {
       }
     }
     finally {
-      this.onChanged(this);
+      this.onChanged({
+        kind: DatabaseEventKind.Refresh,
+        item: this
+      });
     }
   }
 
-  public resolveSourceFile(file: string | undefined): vscode.Uri {
+  public resolveSourceFile(uriStr: string | undefined): vscode.Uri {
     const sourceArchive = this.sourceArchive;
-    if (sourceArchive === undefined) {
-      if (file !== undefined) {
-        // Treat it as an absolute path.
-        return vscode.Uri.file(file);
-      }
-      else {
+    const uri = uriStr ? vscode.Uri.parse(uriStr, true) : undefined;
+    if (uri && uri.scheme !== 'file') {
+      throw new Error(`Invalid uri scheme in ${uriStr}. Only 'file' is allowed.`);
+    }
+    if (!sourceArchive) {
+      if (uri) {
+        return uri;
+      } else {
         return this.databaseUri;
       }
     }
-    else {
-      if (file !== undefined) {
-        const absoluteFilePath = file.replace(':', '_');
-        // Strip any leading slashes from the file path, and replace `:` with `_`.
-        const relativeFilePath = absoluteFilePath.replace(/^\/*/, '').replace(':', '_');
-        if (sourceArchive.scheme == zipArchiveScheme) {
-          return encodeSourceArchiveUri({
-            pathWithinSourceArchive: absoluteFilePath,
-            sourceArchiveZipPath: sourceArchive.fsPath,
-          });
-        }
-        else {
-          let newPath = sourceArchive.path;
-          if (!newPath.endsWith('/')) {
-            // Ensure a trailing slash.
-            newPath += '/';
-          }
-          newPath += relativeFilePath;
 
-          return sourceArchive.with({ path: newPath });
+    if (uri) {
+      const relativeFilePath = decodeURI(uri.path).replace(':', '_').replace(/^\/*/, '');
+      if (sourceArchive.scheme === zipArchiveScheme) {
+        const zipRef = decodeSourceArchiveUri(sourceArchive);
+        const pathWithinSourceArchive = zipRef.pathWithinSourceArchive === '/'
+          ? relativeFilePath
+          : zipRef.pathWithinSourceArchive + '/' + relativeFilePath;
+        return encodeSourceArchiveUri({
+          pathWithinSourceArchive,
+          sourceArchiveZipPath: zipRef.sourceArchiveZipPath,
+        });
+
+      } else {
+        let newPath = sourceArchive.path;
+        if (!newPath.endsWith('/')) {
+          // Ensure a trailing slash.
+          newPath += '/';
         }
+        newPath += relativeFilePath;
+
+        return sourceArchive.with({ path: newPath });
       }
-      else {
-        return sourceArchive;
-      }
+
+    } else {
+      return sourceArchive;
     }
   }
 
@@ -369,10 +417,7 @@ class DatabaseItemImpl implements DatabaseItem {
    * Holds if the database item refers to an exported snapshot
    */
   public async hasMetadataFile(): Promise<boolean> {
-    return (await Promise.all([
-      fs.pathExists(path.join(this.databaseUri.fsPath, '.dbinfo')),
-      fs.pathExists(path.join(this.databaseUri.fsPath, 'codeql-database.yml'))
-    ])).some(x => x);
+    return await isLikelyDatabaseRoot(this.databaseUri.fsPath);
   }
 
   /**
@@ -402,6 +447,10 @@ class DatabaseItemImpl implements DatabaseItem {
     return dbInfo.datasetFolder;
   }
 
+  public get language() {
+    return this.options.language || '';
+  }
+
   /**
    * Returns the root uri of the virtual filesystem for this database's source archive.
    */
@@ -409,10 +458,7 @@ class DatabaseItemImpl implements DatabaseItem {
     const sourceArchive = this.sourceArchive;
     if (sourceArchive === undefined || !sourceArchive.fsPath.endsWith('.zip'))
       return undefined;
-    return encodeSourceArchiveUri({
-      pathWithinSourceArchive: '/',
-      sourceArchiveZipPath: sourceArchive.fsPath,
-    });
+    return encodeArchiveBasePath(sourceArchive.fsPath);
   }
 
   /**
@@ -450,47 +496,71 @@ function eventFired<T>(event: vscode.Event<T>, timeoutMs = 1000): Promise<T | un
 }
 
 export class DatabaseManager extends DisposableObject {
-  private readonly _onDidChangeDatabaseItem = this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
+  private readonly _onDidChangeDatabaseItem = this.push(new vscode.EventEmitter<DatabaseChangedEvent>());
 
   readonly onDidChangeDatabaseItem = this._onDidChangeDatabaseItem.event;
 
-  private readonly _onDidChangeCurrentDatabaseItem = this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
+  private readonly _onDidChangeCurrentDatabaseItem = this.push(new vscode.EventEmitter<DatabaseChangedEvent>());
   readonly onDidChangeCurrentDatabaseItem = this._onDidChangeCurrentDatabaseItem.event;
 
-  private readonly _databaseItems: DatabaseItemImpl[] = [];
+  private readonly _databaseItems: DatabaseItem[] = [];
   private _currentDatabaseItem: DatabaseItem | undefined = undefined;
 
-  constructor(private ctx: ExtensionContext,
-    public config: QueryServerConfig,
-    public logger: Logger) {
+  constructor(
+    private readonly ctx: ExtensionContext,
+    private readonly qs: QueryServerClient,
+    private readonly cli: cli.CodeQLCliServer,
+    public logger: Logger
+  ) {
     super();
 
-    this.loadPersistedState();  // Let this run async.
+    qs.onDidStartQueryServer(this.reregisterDatabases.bind(this));
+
+    // Let this run async.
+    this.loadPersistedState();
   }
 
   public async openDatabase(
-    uri: vscode.Uri, options?: DatabaseOptions
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
+    uri: vscode.Uri,
   ): Promise<DatabaseItem> {
-
     const contents = await resolveDatabaseContents(uri);
-    const realOptions = options || {};
     // Ignore the source archive for QLTest databases by default.
     const isQLTestDatabase = path.extname(uri.fsPath) === '.testproj';
     const fullOptions: FullDatabaseOptions = {
-      ignoreSourceArchive: (realOptions.ignoreSourceArchive !== undefined) ?
-        realOptions.ignoreSourceArchive : isQLTestDatabase,
-      displayName: realOptions.displayName,
-      dateAdded: realOptions.dateAdded || Date.now()
+      ignoreSourceArchive: isQLTestDatabase,
+      // displayName is only set if a user explicitly renames a database
+      displayName: undefined,
+      dateAdded: Date.now(),
+      language: await this.getPrimaryLanguage(uri.fsPath)
     };
-    const databaseItem = new DatabaseItemImpl(uri, contents, fullOptions, (item) => {
-      this._onDidChangeDatabaseItem.fire(item);
+    const databaseItem = new DatabaseItemImpl(uri, contents, fullOptions, (event) => {
+      this._onDidChangeDatabaseItem.fire(event);
     });
-    await this.addDatabaseItem(databaseItem);
+
+    await this.addDatabaseItem(progress, token, databaseItem);
     await this.addDatabaseSourceArchiveFolder(databaseItem);
 
     return databaseItem;
   }
 
+  private async reregisterDatabases(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken
+  ) {
+    let completed = 0;
+    await Promise.all(this._databaseItems.map(async (databaseItem) => {
+      await this.registerDatabase(progress, token, databaseItem);
+      completed++;
+      progress({
+        maxStep: this._databaseItems.length,
+        step: completed,
+        message: 'Re-registering databases'
+      });
+    }));
+  }
+
   private async addDatabaseSourceArchiveFolder(item: DatabaseItem) {
     // The folder may already be in workspace state from a previous
     // session. If not, add it.
@@ -531,12 +601,15 @@ export class DatabaseManager extends DisposableObject {
   }
 
   private async createDatabaseItemFromPersistedState(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
     state: PersistedDatabaseItem
   ): Promise<DatabaseItem> {
 
     let displayName: string | undefined = undefined;
     let ignoreSourceArchive = false;
     let dateAdded = undefined;
+    let language = undefined;
     if (state.options) {
       if (typeof state.options.displayName === 'string') {
         displayName = state.options.displayName;
@@ -547,43 +620,69 @@ export class DatabaseManager extends DisposableObject {
       if (typeof state.options.dateAdded === 'number') {
         dateAdded = state.options.dateAdded;
       }
+      language = state.options.language;
     }
+
+    const dbBaseUri = vscode.Uri.parse(state.uri, true);
+    if (language === undefined) {
+      // we haven't been successful yet at getting the language. try again
+      language = await this.getPrimaryLanguage(dbBaseUri.fsPath);
+    }
+
     const fullOptions: FullDatabaseOptions = {
       ignoreSourceArchive,
       displayName,
-      dateAdded
+      dateAdded,
+      language
     };
-    const item = new DatabaseItemImpl(vscode.Uri.parse(state.uri), undefined, fullOptions,
-      (item) => {
-        this._onDidChangeDatabaseItem.fire(item);
+    const item = new DatabaseItemImpl(dbBaseUri, undefined, fullOptions,
+      (event) => {
+        this._onDidChangeDatabaseItem.fire(event);
       });
-    await this.addDatabaseItem(item);
 
+    await this.addDatabaseItem(progress, token, item);
     return item;
   }
 
   private async loadPersistedState(): Promise<void> {
-    const currentDatabaseUri = this.ctx.workspaceState.get<string>(CURRENT_DB);
-    const databases = this.ctx.workspaceState.get<PersistedDatabaseItem[]>(DB_LIST, []);
-
-    try {
-      for (const database of databases) {
-        const databaseItem = await this.createDatabaseItemFromPersistedState(database);
+    return withProgress({
+      location: vscode.ProgressLocation.Notification
+    },
+      async (progress, token) => {
+        const currentDatabaseUri = this.ctx.workspaceState.get<string>(CURRENT_DB);
+        const databases = this.ctx.workspaceState.get<PersistedDatabaseItem[]>(DB_LIST, []);
+        let step = 0;
+        progress({
+          maxStep: databases.length,
+          message: 'Loading persisted databases',
+          step
+        });
         try {
-          await databaseItem.refresh();
-          if (currentDatabaseUri === database.uri) {
-            this.setCurrentDatabaseItem(databaseItem, true);
+          for (const database of databases) {
+            progress({
+              maxStep: databases.length,
+              message: `Loading ${database.options?.displayName || 'databases'}`,
+              step: ++step
+            });
+
+            const databaseItem = await this.createDatabaseItemFromPersistedState(progress, token, database);
+            try {
+              await databaseItem.refresh();
+              await this.registerDatabase(progress, token, databaseItem);
+              if (currentDatabaseUri === database.uri) {
+                this.setCurrentDatabaseItem(databaseItem, true);
+              }
+            }
+            catch (e) {
+              // When loading from persisted state, leave invalid databases in the list. They will be
+              // marked as invalid, and cannot be set as the current database.
+            }
           }
+        } catch (e) {
+          // database list had an unexpected type - nothing to be done?
+          showAndLogErrorMessage(`Database list loading failed: ${e.message}`);
         }
-        catch (e) {
-          // When loading from persisted state, leave invalid databases in the list. They will be
-          // marked as invalid, and cannot be set as the current database.
-        }
-      }
-    } catch (e) {
-      // database list had an unexpected type - nothing to be done?
-      showAndLogErrorMessage(`Database list loading failed: ${e.message}`);
-    }
+      });
   }
 
   public get databaseItems(): readonly DatabaseItem[] {
@@ -594,8 +693,10 @@ export class DatabaseManager extends DisposableObject {
     return this._currentDatabaseItem;
   }
 
-  public async setCurrentDatabaseItem(item: DatabaseItem | undefined,
-    skipRefresh = false): Promise<void> {
+  public async setCurrentDatabaseItem(
+    item: DatabaseItem | undefined,
+    skipRefresh = false
+  ): Promise<void> {
 
     if (!skipRefresh && (item !== undefined)) {
       await item.refresh();  // Will throw on invalid database.
@@ -603,7 +704,11 @@ export class DatabaseManager extends DisposableObject {
     if (this._currentDatabaseItem !== item) {
       this._currentDatabaseItem = item;
       this.updatePersistedCurrentDatabaseItem();
-      this._onDidChangeCurrentDatabaseItem.fire(item);
+
+      this._onDidChangeCurrentDatabaseItem.fire({
+        item,
+        kind: DatabaseEventKind.Change
+      });
     }
   }
 
@@ -626,21 +731,45 @@ export class DatabaseManager extends DisposableObject {
     return this._databaseItems.find(item => item.sourceArchive && item.sourceArchive.toString(true) === uriString);
   }
 
-  private async addDatabaseItem(item: DatabaseItemImpl) {
+  private async addDatabaseItem(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
+    item: DatabaseItem
+  ) {
     this._databaseItems.push(item);
     this.updatePersistedDatabaseList();
-    this._onDidChangeDatabaseItem.fire(undefined);
+
+    // Add this database item to the allow-list
+    // Database items reconstituted from persisted state
+    // will not have their contents yet.
+    if (item.contents?.datasetUri) {
+      await this.registerDatabase(progress, token, item);
+    }
+    // note that we use undefined as the item in order to reset the entire tree
+    this._onDidChangeDatabaseItem.fire({
+      item: undefined,
+      kind: DatabaseEventKind.Add
+    });
   }
 
   public async renameDatabaseItem(item: DatabaseItem, newName: string) {
     item.name = newName;
     this.updatePersistedDatabaseList();
-    this._onDidChangeDatabaseItem.fire(item);
+    this._onDidChangeDatabaseItem.fire({
+      // pass undefined so that the entire tree is rebuilt in order to re-sort
+      item: undefined,
+      kind: DatabaseEventKind.Rename
+    });
   }
 
-  public removeDatabaseItem(item: DatabaseItem) {
-    if (this._currentDatabaseItem == item)
+  public async removeDatabaseItem(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
+    item: DatabaseItem
+  ) {
+    if (this._currentDatabaseItem == item) {
       this._currentDatabaseItem = undefined;
+    }
     const index = this.databaseItems.findIndex(searchItem => searchItem === item);
     if (index >= 0) {
       this._databaseItems.splice(index, 1);
@@ -648,8 +777,10 @@ export class DatabaseManager extends DisposableObject {
     this.updatePersistedDatabaseList();
 
     // Delete folder from workspace, if it is still there
-    const folderIndex = (vscode.workspace.workspaceFolders || []).findIndex(folder => item.belongsToSourceArchiveExplorerUri(folder.uri));
-    if (index >= 0) {
+    const folderIndex = (vscode.workspace.workspaceFolders || []).findIndex(
+      folder => item.belongsToSourceArchiveExplorerUri(folder.uri)
+    );
+    if (folderIndex >= 0) {
       logger.log(`Removing workspace folder at index ${folderIndex}`);
       vscode.workspace.updateWorkspaceFolders(folderIndex, 1);
     }
@@ -657,12 +788,47 @@ export class DatabaseManager extends DisposableObject {
     // Delete folder from file system only if it is controlled by the extension
     if (this.isExtensionControlledLocation(item.databaseUri)) {
       logger.log('Deleting database from filesystem.');
-      fs.remove(item.databaseUri.path).then(
-        () => logger.log(`Deleted '${item.databaseUri.path}'`),
-        e => logger.log(`Failed to delete '${item.databaseUri.path}'. Reason: ${e.message}`));
+      fs.remove(item.databaseUri.fsPath).then(
+        () => logger.log(`Deleted '${item.databaseUri.fsPath}'`),
+        e => logger.log(`Failed to delete '${item.databaseUri.fsPath}'. Reason: ${e.message}`));
     }
 
-    this._onDidChangeDatabaseItem.fire(undefined);
+    // Remove this database item from the allow-list
+    await this.deregisterDatabase(progress, token, item);
+
+    // note that we use undefined as the item in order to reset the entire tree
+    this._onDidChangeDatabaseItem.fire({
+      item: undefined,
+      kind: DatabaseEventKind.Remove
+    });
+  }
+
+  private async deregisterDatabase(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
+    dbItem: DatabaseItem,
+  ) {
+    if (dbItem.contents && (await this.cli.cliConstraints.supportsDatabaseRegistration())) {
+      const databases: Dataset[] = [{
+        dbDir: dbItem.contents.datasetUri.fsPath,
+        workingSet: 'default'
+      }];
+      await this.qs.sendRequest(deregisterDatabases, { databases }, token, progress);
+    }
+  }
+
+  private async registerDatabase(
+    progress: ProgressCallback,
+    token: vscode.CancellationToken,
+    dbItem: DatabaseItem,
+  ) {
+    if (dbItem.contents && (await this.cli.cliConstraints.supportsDatabaseRegistration())) {
+      const databases: Dataset[] = [{
+        dbDir: dbItem.contents.datasetUri.fsPath,
+        workingSet: 'default'
+      }];
+      await this.qs.sendRequest(registerDatabases, { databases }, token, progress);
+    }
   }
 
   private updatePersistedCurrentDatabaseItem(): void {
@@ -676,7 +842,24 @@ export class DatabaseManager extends DisposableObject {
 
   private isExtensionControlledLocation(uri: vscode.Uri) {
     const storagePath = this.ctx.storagePath || this.ctx.globalStoragePath;
-    return uri.path.startsWith(storagePath);
+    // the uri.fsPath function on windows returns a lowercase drive letter,
+    // but storagePath will have an uppercase drive letter. Be sure to compare
+    // URIs to URIs only
+    if (storagePath) {
+      return uri.fsPath.startsWith(vscode.Uri.file(storagePath).fsPath);
+    }
+    return false;
+  }
+
+  private async getPrimaryLanguage(dbPath: string) {
+    if (!(await this.cli.cliConstraints.supportsLanguageName())) {
+      // return undefined so that we recalculate on restart until the cli is at a version that
+      // supports this feature. This recalculation is cheap since we avoid calling into the cli
+      // unless we know it can return the langauges property.
+      return undefined;
+    }
+    const dbInfo = await this.cli.resolveDatabase(dbPath);
+    return dbInfo.languages?.[0] || '';
   }
 }
 

extensions/ql-vscode/src/discovery.ts

@@ -1,5 +1,5 @@
-import { DisposableObject } from './vscode-utils/disposable-object';
-import { showAndLogErrorMessage } from './helpers';
+import { DisposableObject } from './pure/disposable-object';
+import { logger } from './logging';
 
 /**
  * Base class for "discovery" operations, which scan the file system to find specific kinds of
@@ -62,7 +62,7 @@ export abstract class Discovery<T> extends DisposableObject {
     });
 
     discoveryPromise.catch(err => {
-      showAndLogErrorMessage(`${this.name} failed. Reason: ${err.message}`);
+      logger.log(`${this.name} failed. Reason: ${err.message}`);
     });
 
     discoveryPromise.finally(() => {

extensions/ql-vscode/src/distribution.ts

@@ -7,10 +7,15 @@ import * as unzipper from 'unzipper';
 import * as url from 'url';
 import { ExtensionContext, Event } from 'vscode';
 import { DistributionConfig } from './config';
-import { InvocationRateLimiter, InvocationRateLimiterResultKind, showAndLogErrorMessage } from './helpers';
+import {
+  InvocationRateLimiter,
+  InvocationRateLimiterResultKind,
+  showAndLogErrorMessage,
+  showAndLogWarningMessage
+} from './helpers';
 import { logger } from './logging';
-import * as helpers from './helpers';
 import { getCodeQlCliVersion } from './cli-version';
+import { ProgressCallback, reportStreamProgress } from './commandRunner';
 
 /**
  * distribution.ts
@@ -45,19 +50,40 @@ export const DEFAULT_DISTRIBUTION_VERSION_RANGE: semver.Range = new semver.Range
 export interface DistributionProvider {
   getCodeQlPathWithoutVersionCheck(): Promise<string | undefined>;
   onDidChangeDistribution?: Event<void>;
+  getDistribution(): Promise<FindDistributionResult>;
 }
 
 export class DistributionManager implements DistributionProvider {
-  constructor(extensionContext: ExtensionContext, config: DistributionConfig, versionRange: semver.Range) {
-    this._config = config;
-    this._extensionSpecificDistributionManager = new ExtensionSpecificDistributionManager(extensionContext, config, versionRange);
-    this._onDidChangeDistribution = config.onDidChangeDistributionConfiguration;
-    this._updateCheckRateLimiter = new InvocationRateLimiter(
+
+  /**
+   * Get the name of the codeql cli installation we prefer to install, based on our current platform.
+   */
+  public static getRequiredAssetName(): string {
+    switch (os.platform()) {
+      case 'linux':
+        return 'codeql-linux64.zip';
+      case 'darwin':
+        return 'codeql-osx64.zip';
+      case 'win32':
+        return 'codeql-win64.zip';
+      default:
+        return 'codeql.zip';
+    }
+  }
+
+  constructor(
+    public readonly config: DistributionConfig,
+    private readonly versionRange: semver.Range,
+    extensionContext: ExtensionContext
+  ) {
+    this._onDidChangeDistribution = config.onDidChangeConfiguration;
+    this.extensionSpecificDistributionManager =
+      new ExtensionSpecificDistributionManager(config, versionRange, extensionContext);
+    this.updateCheckRateLimiter = new InvocationRateLimiter(
       extensionContext,
       'extensionSpecificDistributionUpdateCheck',
-      () => this._extensionSpecificDistributionManager.checkForUpdatesToDistribution()
+      () => this.extensionSpecificDistributionManager.checkForUpdatesToDistribution()
     );
-    this._versionRange = versionRange;
   }
 
   /**
@@ -94,9 +120,9 @@ export class DistributionManager implements DistributionProvider {
      * - If the user is using an extension-managed CLI, then prereleases are only accepted when the
      * includePrerelease config option is set.
      */
-    const includePrerelease = distribution.kind !== DistributionKind.ExtensionManaged || this._config.includePrerelease;
+    const includePrerelease = distribution.kind !== DistributionKind.ExtensionManaged || this.config.includePrerelease;
 
-    if (!semver.satisfies(version, this._versionRange, { includePrerelease })) {
+    if (!semver.satisfies(version, this.versionRange, { includePrerelease })) {
       return {
         distribution,
         kind: FindDistributionResultKind.IncompatibleDistribution,
@@ -125,9 +151,9 @@ export class DistributionManager implements DistributionProvider {
    */
   async getDistributionWithoutVersionCheck(): Promise<Distribution | undefined> {
     // 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}" ` +
+    if (this.config.customCodeQlPath) {
+      if (!await fs.pathExists(this.config.customCodeQlPath)) {
+        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;
@@ -136,18 +162,18 @@ export class DistributionManager implements DistributionProvider {
       // emit a warning if using a deprecated launcher and a non-deprecated launcher exists
       if (
         deprecatedCodeQlLauncherName() &&
-        this._config.customCodeQlPath.endsWith(deprecatedCodeQlLauncherName()!) &&
+        this.config.customCodeQlPath.endsWith(deprecatedCodeQlLauncherName()!) &&
         await this.hasNewLauncherName()
       ) {
         warnDeprecatedLauncher();
       }
       return {
-        codeQlPath: this._config.customCodeQlPath,
+        codeQlPath: this.config.customCodeQlPath,
         kind: DistributionKind.CustomPathConfig
       };
     }
 
-    const extensionSpecificCodeQlPath = await this._extensionSpecificDistributionManager.getCodeQlPathWithoutVersionCheck();
+    const extensionSpecificCodeQlPath = await this.extensionSpecificDistributionManager.getCodeQlPathWithoutVersionCheck();
     if (extensionSpecificCodeQlPath !== undefined) {
       return {
         codeQlPath: extensionSpecificCodeQlPath,
@@ -180,12 +206,12 @@ export class DistributionManager implements DistributionProvider {
   public async checkForUpdatesToExtensionManagedDistribution(
     minSecondsSinceLastUpdateCheck: number): Promise<DistributionUpdateCheckResult> {
     const distribution = await this.getDistributionWithoutVersionCheck();
-    const extensionManagedCodeQlPath = await this._extensionSpecificDistributionManager.getCodeQlPathWithoutVersionCheck();
+    const extensionManagedCodeQlPath = await this.extensionSpecificDistributionManager.getCodeQlPathWithoutVersionCheck();
     if (distribution?.codeQlPath !== extensionManagedCodeQlPath) {
       // A distribution is present but it isn't managed by the extension.
       return createInvalidLocationResult();
     }
-    const updateCheckResult = await this._updateCheckRateLimiter.invokeFunctionIfIntervalElapsed(minSecondsSinceLastUpdateCheck);
+    const updateCheckResult = await this.updateCheckRateLimiter.invokeFunctionIfIntervalElapsed(minSecondsSinceLastUpdateCheck);
     switch (updateCheckResult.kind) {
       case InvocationRateLimiterResultKind.Invoked:
         return updateCheckResult.result;
@@ -199,9 +225,11 @@ export class DistributionManager implements DistributionProvider {
    *
    * Returns a failed promise if an unexpected error occurs during installation.
    */
-  public installExtensionManagedDistributionRelease(release: Release,
-    progressCallback?: helpers.ProgressCallback): Promise<void> {
-    return this._extensionSpecificDistributionManager.installDistributionRelease(release, progressCallback);
+  public installExtensionManagedDistributionRelease(
+    release: Release,
+    progressCallback?: ProgressCallback
+  ): Promise<void> {
+    return this.extensionSpecificDistributionManager.installDistributionRelease(release, progressCallback);
   }
 
   public get onDidChangeDistribution(): Event<void> | undefined {
@@ -214,27 +242,27 @@ export class DistributionManager implements DistributionProvider {
    * installation. False otherwise.
    */
   private async hasNewLauncherName(): Promise<boolean> {
-    if (!this._config.customCodeQlPath) {
+    if (!this.config.customCodeQlPath) {
       // not managed externally
       return false;
     }
-    const dir = path.dirname(this._config.customCodeQlPath);
+    const dir = path.dirname(this.config.customCodeQlPath);
     const newLaunderPath = path.join(dir, codeQlLauncherName());
     return await fs.pathExists(newLaunderPath);
   }
 
-  private readonly _config: DistributionConfig;
-  private readonly _extensionSpecificDistributionManager: ExtensionSpecificDistributionManager;
-  private readonly _updateCheckRateLimiter: InvocationRateLimiter<DistributionUpdateCheckResult>;
+  private readonly extensionSpecificDistributionManager: ExtensionSpecificDistributionManager;
+  private readonly updateCheckRateLimiter: InvocationRateLimiter<DistributionUpdateCheckResult>;
   private readonly _onDidChangeDistribution: Event<void> | undefined;
-  private readonly _versionRange: semver.Range;
 }
 
 class ExtensionSpecificDistributionManager {
-  constructor(extensionContext: ExtensionContext, config: DistributionConfig, versionRange: semver.Range) {
-    this._extensionContext = extensionContext;
-    this._config = config;
-    this._versionRange = versionRange;
+  constructor(
+    private readonly config: DistributionConfig,
+    private readonly versionRange: semver.Range,
+    private readonly extensionContext: ExtensionContext
+  ) {
+    /**/
   }
 
   public async getCodeQlPathWithoutVersionCheck(): Promise<string | undefined> {
@@ -282,14 +310,14 @@ class ExtensionSpecificDistributionManager {
    * Returns a failed promise if an unexpected error occurs during installation.
    */
   public async installDistributionRelease(release: Release,
-    progressCallback?: helpers.ProgressCallback): Promise<void> {
+    progressCallback?: ProgressCallback): Promise<void> {
     await this.downloadDistribution(release, progressCallback);
     // Store the installed release within the global extension state.
     this.storeInstalledRelease(release);
   }
 
   private async downloadDistribution(release: Release,
-    progressCallback?: helpers.ProgressCallback): Promise<void> {
+    progressCallback?: ProgressCallback): Promise<void> {
     try {
       await this.removeDistribution();
     } catch (e) {
@@ -298,7 +326,7 @@ class ExtensionSpecificDistributionManager {
     }
 
     // Filter assets to the unique one that we require.
-    const requiredAssetName = this.getRequiredAssetName();
+    const requiredAssetName = DistributionManager.getRequiredAssetName();
     const assets = release.assets.filter(asset => asset.name === requiredAssetName);
     if (assets.length === 0) {
       throw new Error(`Invariant violation: chose a release to install that didn't have ${requiredAssetName}`);
@@ -316,27 +344,8 @@ class ExtensionSpecificDistributionManager {
       const archiveFile = fs.createWriteStream(archivePath);
 
       const contentLength = assetStream.headers.get('content-length');
-      let numBytesDownloaded = 0;
-
-      if (progressCallback && contentLength !== null) {
-        const totalNumBytes = parseInt(contentLength, 10);
-        const bytesToDisplayMB = (numBytes: number): string => `${(numBytes / (1024 * 1024)).toFixed(1)} MB`;
-        const updateProgress = (): void => {
-          progressCallback({
-            step: numBytesDownloaded,
-            maxStep: totalNumBytes,
-            message: `Downloading CodeQL CLI… [${bytesToDisplayMB(numBytesDownloaded)} of ${bytesToDisplayMB(totalNumBytes)}]`,
-          });
-        };
-
-        // Display the progress straight away rather than waiting for the first chunk.
-        updateProgress();
-
-        assetStream.body.on('data', data => {
-          numBytesDownloaded += data.length;
-          updateProgress();
-        });
-      }
+      const totalNumBytes = contentLength ? parseInt(contentLength, 10) : undefined;
+      reportStreamProgress(assetStream.body, 'Downloading CodeQL CLI…', totalNumBytes, progressCallback);
 
       await new Promise((resolve, reject) =>
         assetStream.body.pipe(archiveFile)
@@ -365,22 +374,12 @@ class ExtensionSpecificDistributionManager {
     }
   }
 
-  /**
-   * Get the name of the codeql cli installation we prefer to install, based on our current platform.
-   */
-  private getRequiredAssetName(): string {
-    if (os.platform() === 'linux') return 'codeql-linux64.zip';
-    if (os.platform() === 'darwin') return 'codeql-osx64.zip';
-    if (os.platform() === 'win32') return 'codeql-win64.zip';
-    return 'codeql.zip';
-  }
-
   private async getLatestRelease(): Promise<Release> {
-    const requiredAssetName = this.getRequiredAssetName();
+    const requiredAssetName = DistributionManager.getRequiredAssetName();
     logger.log(`Searching for latest release including ${requiredAssetName}.`);
     return this.createReleasesApiConsumer().getLatestRelease(
-      this._versionRange,
-      this._config.includePrerelease,
+      this.versionRange,
+      this.config.includePrerelease,
       release => {
         const matchingAssets = release.assets.filter(asset => asset.name === requiredAssetName);
         if (matchingAssets.length === 0) {
@@ -398,23 +397,23 @@ class ExtensionSpecificDistributionManager {
   }
 
   private createReleasesApiConsumer(): ReleasesApiConsumer {
-    const ownerName = this._config.ownerName ? this._config.ownerName : DEFAULT_DISTRIBUTION_OWNER_NAME;
-    const repositoryName = this._config.repositoryName ? this._config.repositoryName : DEFAULT_DISTRIBUTION_REPOSITORY_NAME;
-    return new ReleasesApiConsumer(ownerName, repositoryName, this._config.personalAccessToken);
+    const ownerName = this.config.ownerName ? this.config.ownerName : DEFAULT_DISTRIBUTION_OWNER_NAME;
+    const repositoryName = this.config.repositoryName ? this.config.repositoryName : DEFAULT_DISTRIBUTION_REPOSITORY_NAME;
+    return new ReleasesApiConsumer(ownerName, repositoryName, this.config.personalAccessToken);
   }
 
   private async bumpDistributionFolderIndex(): Promise<void> {
-    const index = this._extensionContext.globalState.get(
+    const index = this.extensionContext.globalState.get(
       ExtensionSpecificDistributionManager._currentDistributionFolderIndexStateKey, 0);
-    await this._extensionContext.globalState.update(
+    await this.extensionContext.globalState.update(
       ExtensionSpecificDistributionManager._currentDistributionFolderIndexStateKey, index + 1);
   }
 
   private getDistributionStoragePath(): string {
     // Use an empty string for the initial distribution for backwards compatibility.
-    const distributionFolderIndex = this._extensionContext.globalState.get(
+    const distributionFolderIndex = this.extensionContext.globalState.get(
       ExtensionSpecificDistributionManager._currentDistributionFolderIndexStateKey, 0) || '';
-    return path.join(this._extensionContext.globalStoragePath,
+    return path.join(this.extensionContext.globalStoragePath,
       ExtensionSpecificDistributionManager._currentDistributionFolderBaseName + distributionFolderIndex);
   }
 
@@ -424,17 +423,13 @@ class ExtensionSpecificDistributionManager {
   }
 
   private getInstalledRelease(): Release | undefined {
-    return this._extensionContext.globalState.get(ExtensionSpecificDistributionManager._installedReleaseStateKey);
+    return this.extensionContext.globalState.get(ExtensionSpecificDistributionManager._installedReleaseStateKey);
   }
 
   private async storeInstalledRelease(release: Release | undefined): Promise<void> {
-    await this._extensionContext.globalState.update(ExtensionSpecificDistributionManager._installedReleaseStateKey, release);
+    await this.extensionContext.globalState.update(ExtensionSpecificDistributionManager._installedReleaseStateKey, release);
   }
 
-  private readonly _config: DistributionConfig;
-  private readonly _extensionContext: ExtensionContext;
-  private readonly _versionRange: semver.Range;
-
   private static readonly _currentDistributionFolderBaseName = 'distribution';
   private static readonly _currentDistributionFolderIndexStateKey = 'distributionFolderIndex';
   private static readonly _installedReleaseStateKey = 'distributionRelease';
@@ -575,7 +570,7 @@ export async function extractZipArchive(archivePath: string, outPath: string): P
   }));
 }
 
-function codeQlLauncherName(): string {
+export function codeQlLauncherName(): string {
   return (os.platform() === 'win32') ? 'codeql.exe' : 'codeql';
 }
 
@@ -719,7 +714,9 @@ export async function getExecutableFromDirectory(directory: string, warnWhenNotF
 }
 
 function warnDeprecatedLauncher() {
-  helpers.showAndLogWarningMessage(
+
+  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.`
   );

extensions/ql-vscode/src/extension.ts

@@ -1,4 +1,5 @@
 import {
+  CancellationToken,
   commands,
   Disposable,
   ExtensionContext,
@@ -17,8 +18,14 @@ import { testExplorerExtensionId, TestHub } from 'vscode-test-adapter-api';
 
 import { AstViewer } from './astViewer';
 import * as archiveFilesystemProvider from './archive-filesystem-provider';
-import { CodeQLCliServer } from './cli';
-import { DistributionConfigListener, QueryHistoryConfigListener, QueryServerConfigListener } from './config';
+import { CodeQLCliServer, CliVersionConstraint } from './cli';
+import {
+  CliConfigListener,
+  DistributionConfigListener,
+  MAX_QUERIES,
+  QueryHistoryConfigListener,
+  QueryServerConfigListener
+} from './config';
 import * as languageSupport from './languageSupport';
 import { DatabaseManager } from './databases';
 import { DatabaseUI } from './databases-ui';
@@ -38,7 +45,7 @@ import {
   GithubRateLimitedError
 } from './distribution';
 import * as helpers from './helpers';
-import { assertNever } from './helpers-pure';
+import { assertNever } from './pure/helpers-pure';
 import { spawnIdeServer } from './ide-server';
 import { InterfaceManager } from './interface';
 import { WebviewReveal } from './interface-utils';
@@ -47,11 +54,20 @@ import { QueryHistoryManager } from './query-history';
 import { CompletedQuery } from './query-results';
 import * as qsClient from './queryserver-client';
 import { displayQuickQuery } from './quick-query';
-import { compileAndRunQueryAgainstDatabase, tmpDirDisposal, UserCancellationException } from './run-queries';
+import { compileAndRunQueryAgainstDatabase, tmpDirDisposal } from './run-queries';
 import { QLTestAdapterFactory } from './test-adapter';
 import { TestUIService } from './test-ui';
 import { CompareInterfaceManager } from './compare/compare-interface';
-import { gatherQlFiles } from './files';
+import { gatherQlFiles } from './pure/files';
+import { initializeTelemetry } from './telemetry';
+import {
+  commandRunner,
+  commandRunnerWithProgress,
+  ProgressCallback,
+  withProgress,
+  ProgressUpdate
+} from './commandRunner';
+import { CodeQlStatusBarHandler } from './status-bar';
 
 /**
  * extension.ts
@@ -80,18 +96,19 @@ const errorStubs: Disposable[] = [];
  */
 let isInstallingOrUpdatingDistribution = false;
 
+const extensionId = 'GitHub.vscode-codeql';
+const extension = extensions.getExtension(extensionId);
+
 /**
  * If the user tries to execute vscode commands after extension activation is failed, give
  * a sensible error message.
  *
  * @param excludedCommands List of commands for which we should not register error stubs.
  */
-function registerErrorStubs(excludedCommands: string[], stubGenerator: (command: string) => () => void): void {
+function registerErrorStubs(excludedCommands: string[], stubGenerator: (command: string) => () => Promise<void>): void {
   // Remove existing stubs
   errorStubs.forEach(stub => stub.dispose());
 
-  const extensionId = 'GitHub.vscode-codeql'; // TODO: Is there a better way of obtaining this?
-  const extension = extensions.getExtension(extensionId);
   if (extension === undefined) {
     throw new Error(`Can't find extension ${extensionId}`);
   }
@@ -101,27 +118,55 @@ function registerErrorStubs(excludedCommands: string[], stubGenerator: (command:
 
   stubbedCommands.forEach(command => {
     if (excludedCommands.indexOf(command) === -1) {
-      errorStubs.push(commands.registerCommand(command, stubGenerator(command)));
+      errorStubs.push(commandRunner(command, stubGenerator(command)));
     }
   });
 }
 
-export async function activate(ctx: ExtensionContext): Promise<void> {
-  logger.log('Starting CodeQL extension');
+/**
+ * The publicly available interface for this extension. This is to
+ * be used in our tests.
+ */
+export interface CodeQLExtensionInterface {
+  readonly ctx: ExtensionContext;
+  readonly cliServer: CodeQLCliServer;
+  readonly qs: qsClient.QueryServerClient;
+  readonly distributionManager: DistributionManager;
+  readonly databaseManager: DatabaseManager;
+  readonly databaseUI: DatabaseUI;
+  readonly dispose: () => void;
+}
 
-  initializeLogging(ctx);
-  languageSupport.install();
+/**
+ * Returns the CodeQLExtensionInterface, or an empty object if the interface is not
+ * available afer activation is complete. This will happen if there is no cli
+ * installed when the extension starts. Downloading and installing the cli
+ * will happen at a later time.
+ *
+ * @param ctx The extension context
+ *
+ * @returns CodeQLExtensionInterface
+ */
+export async function activate(ctx: ExtensionContext): Promise<CodeQLExtensionInterface | {}> {
+  logger.log(`Starting ${extensionId} extension`);
+  if (extension === undefined) {
+    throw new Error(`Can't find extension ${extensionId}`);
+  }
 
   const distributionConfigListener = new DistributionConfigListener();
+  initializeLogging(ctx);
+  await initializeTelemetry(extension, ctx);
+  languageSupport.install();
+
   ctx.subscriptions.push(distributionConfigListener);
   const codeQlVersionRange = DEFAULT_DISTRIBUTION_VERSION_RANGE;
-  const distributionManager = new DistributionManager(ctx, distributionConfigListener, codeQlVersionRange);
+  const distributionManager = new DistributionManager(distributionConfigListener, codeQlVersionRange, ctx);
 
   const shouldUpdateOnNextActivationKey = 'shouldUpdateOnNextActivation';
 
-  registerErrorStubs([checkForUpdatesCommand], command => () => {
+  registerErrorStubs([checkForUpdatesCommand], command => (async () => {
     helpers.showAndLogErrorMessage(`Can't execute ${command}: waiting to finish loading CodeQL CLI.`);
-  });
+  }));
 
   interface DistributionUpdateConfig {
     isUserInitiated: boolean;
@@ -159,11 +204,11 @@ export async function activate(ctx: ExtensionContext): Promise<void> {
           }
         } else {
           const progressOptions: ProgressOptions = {
-            location: ProgressLocation.Notification,
             title: progressTitle,
-            cancellable: false,
+            location: ProgressLocation.Notification,
           };
-          await helpers.withProgress(progressOptions, progress =>
+
+          await withProgress(progressOptions, progress =>
             distributionManager.installExtensionManagedDistributionRelease(result.updatedRelease, progress));
 
           await ctx.globalState.update(shouldUpdateOnNextActivationKey, false);
@@ -246,14 +291,22 @@ export async function activate(ctx: ExtensionContext): Promise<void> {
     return result;
   }
 
-  async function installOrUpdateThenTryActivate(config: DistributionUpdateConfig): Promise<void> {
+  async function installOrUpdateThenTryActivate(
+    config: DistributionUpdateConfig
+  ): Promise<CodeQLExtensionInterface | {}> {
+
     await installOrUpdateDistribution(config);
 
     // Display the warnings even if the extension has already activated.
     const distributionResult = await getDistributionDisplayingDistributionWarnings();
-
+    let extensionInterface: CodeQLExtensionInterface | {} = {};
     if (!beganMainExtensionActivation && distributionResult.kind !== FindDistributionResultKind.NoDistribution) {
-      await activateWithInstalledDistribution(ctx, distributionManager);
+      extensionInterface = await activateWithInstalledDistribution(
+        ctx,
+        distributionManager,
+        distributionConfigListener
+      );
+
     } else if (distributionResult.kind === FindDistributionResultKind.NoDistribution) {
       registerErrorStubs([checkForUpdatesCommand], command => async () => {
         const installActionName = 'Install CodeQL CLI';
@@ -261,7 +314,7 @@ export async function activate(ctx: ExtensionContext): Promise<void> {
           items: [installActionName]
         });
         if (chosenAction === installActionName) {
-          installOrUpdateThenTryActivate({
+          await installOrUpdateThenTryActivate({
             isUserInitiated: true,
             shouldDisplayMessageWhenNoUpdates: false,
             allowAutoUpdating: true
@@ -269,20 +322,21 @@ export async function activate(ctx: ExtensionContext): Promise<void> {
         }
       });
     }
+    return extensionInterface;
   }
 
-  ctx.subscriptions.push(distributionConfigListener.onDidChangeDistributionConfiguration(() => installOrUpdateThenTryActivate({
+  ctx.subscriptions.push(distributionConfigListener.onDidChangeConfiguration(() => installOrUpdateThenTryActivate({
     isUserInitiated: true,
     shouldDisplayMessageWhenNoUpdates: false,
     allowAutoUpdating: true
   })));
-  ctx.subscriptions.push(commands.registerCommand(checkForUpdatesCommand, () => installOrUpdateThenTryActivate({
+  ctx.subscriptions.push(commandRunner(checkForUpdatesCommand, () => installOrUpdateThenTryActivate({
     isUserInitiated: true,
     shouldDisplayMessageWhenNoUpdates: true,
     allowAutoUpdating: true
   })));
 
-  await installOrUpdateThenTryActivate({
+  return await installOrUpdateThenTryActivate({
     isUserInitiated: !!ctx.globalState.get(shouldUpdateOnNextActivationKey),
     shouldDisplayMessageWhenNoUpdates: false,
 
@@ -294,8 +348,9 @@ export async function activate(ctx: ExtensionContext): Promise<void> {
 
 async function activateWithInstalledDistribution(
   ctx: ExtensionContext,
-  distributionManager: DistributionManager
-): Promise<void> {
+  distributionManager: DistributionManager,
+  distributionConfigListener: DistributionConfigListener
+): Promise<CodeQLExtensionInterface> {
   beganMainExtensionActivation = true;
   // Remove any error stubs command handlers left over from first part
   // of activation.
@@ -308,9 +363,16 @@ async function activateWithInstalledDistribution(
   ctx.subscriptions.push(qlConfigurationListener);
 
   logger.log('Initializing CodeQL cli server...');
-  const cliServer = new CodeQLCliServer(distributionManager, logger);
+  const cliServer = new CodeQLCliServer(
+    distributionManager,
+    new CliConfigListener(),
+    logger
+  );
   ctx.subscriptions.push(cliServer);
 
+  const statusBar = new CodeQlStatusBarHandler(cliServer, distributionConfigListener);
+  ctx.subscriptions.push(statusBar);
+
   logger.log('Initializing query server client.');
   const qs = new qsClient.QueryServerClient(
     qlConfigurationListener,
@@ -328,30 +390,33 @@ async function activateWithInstalledDistribution(
   await qs.startQueryServer();
 
   logger.log('Initializing database manager.');
-  const dbm = new DatabaseManager(ctx, qlConfigurationListener, logger);
+  const dbm = new DatabaseManager(ctx, qs, cliServer, logger);
   ctx.subscriptions.push(dbm);
   logger.log('Initializing database panel.');
   const databaseUI = new DatabaseUI(
-    ctx,
-    cliServer,
     dbm,
     qs,
-    getContextStoragePath(ctx)
+    getContextStoragePath(ctx),
+    ctx.extensionPath
   );
+  databaseUI.init();
   ctx.subscriptions.push(databaseUI);
 
   logger.log('Initializing query history manager.');
   const queryHistoryConfigurationListener = new QueryHistoryConfigListener();
+  ctx.subscriptions.push(queryHistoryConfigurationListener);
   const showResults = async (item: CompletedQuery) =>
     showResultsForCompletedQuery(item, WebviewReveal.Forced);
 
   const qhm = new QueryHistoryManager(
-    ctx,
+    qs,
+    ctx.extensionPath,
     queryHistoryConfigurationListener,
     showResults,
     async (from: CompletedQuery, to: CompletedQuery) =>
       showResultsForComparison(from, to),
   );
+  ctx.subscriptions.push(qhm);
   logger.log('Initializing results panel interface.');
   const intm = new InterfaceManager(ctx, dbm, cliServer, queryServerLogger);
   ctx.subscriptions.push(intm);
@@ -389,31 +454,47 @@ async function activateWithInstalledDistribution(
 
   async function compileAndRunQuery(
     quickEval: boolean,
-    selectedQuery: Uri | undefined
+    selectedQuery: Uri | undefined,
+    progress: ProgressCallback,
+    token: CancellationToken,
   ): Promise<void> {
     if (qs !== undefined) {
-      try {
-        const dbItem = await databaseUI.getDatabaseItem();
-        if (dbItem === undefined) {
-          throw new Error('Can\'t run query without a selected database');
-        }
-        const info = await compileAndRunQueryAgainstDatabase(
-          cliServer,
-          qs,
-          dbItem,
-          quickEval,
-          selectedQuery
-        );
-        const item = qhm.addQuery(info);
-        await showResultsForCompletedQuery(item, WebviewReveal.NotForced);
-      } catch (e) {
-        if (e instanceof UserCancellationException) {
-          helpers.showAndLogWarningMessage(e.message);
-        } else if (e instanceof Error) {
-          helpers.showAndLogErrorMessage(e.message);
-        } else {
-          throw e;
-        }
+      const dbItem = await databaseUI.getDatabaseItem(progress, token);
+      if (dbItem === undefined) {
+        throw new Error('Can\'t run query without a selected database');
+      }
+      const info = await compileAndRunQueryAgainstDatabase(
+        cliServer,
+        qs,
+        dbItem,
+        quickEval,
+        selectedQuery,
+        progress,
+        token
+      );
+      const item = qhm.buildCompletedQuery(info);
+      await showResultsForCompletedQuery(item, WebviewReveal.NotForced);
+      // Note we must update the query history view after showing results as the
+      // display and sorting might depend on the number of results
+      await qhm.addCompletedQuery(item);
+    }
+  }
+
+  async function openReferencedFile(
+    selectedQuery: Uri
+  ): Promise<void> {
+    if (qs !== undefined) {
+      if (await cliServer.cliConstraints.supportsResolveQlref()) {
+        const resolved = await cliServer.resolveQlref(selectedQuery.path);
+        const uri = Uri.file(resolved.resolvedPath);
+        await window.showTextDocument(uri, { preview: false });
+      } else {
+        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
+          } or later to use this feature.`);
       }
     }
   }
@@ -453,79 +534,171 @@ async function activateWithInstalledDistribution(
 
   logger.log('Registering top-level command palette commands.');
   ctx.subscriptions.push(
-    commands.registerCommand(
+    commandRunnerWithProgress(
       'codeQL.runQuery',
-      async (uri: Uri | undefined) => await compileAndRunQuery(false, uri)
-    )
-  );
-  ctx.subscriptions.push(
-    commands.registerCommand(
-      'codeQL.runQueries',
-      async (_: Uri | undefined, multi: Uri[]) => {
-        const maxQueryCount = 20;
-        try {
-          const [files, dirFound] = await gatherQlFiles(multi.map(uri => uri.fsPath));
-          if (files.length > maxQueryCount) {
-            throw new Error(`You tried to run ${files.length} queries, but the maximum is ${maxQueryCount}. Try selecting fewer queries.`);
-          }
-          // warn user and display selected files when a directory is selected because some ql
-          // files may be hidden from the user.
-          if (dirFound) {
-            const fileString = files.map(file => path.basename(file)).join(', ');
-            const res = await helpers.showBinaryChoiceDialog(
-              `You are about to run ${files.length} queries: ${fileString} Do you want to continue?`
-            );
-            if (!res) {
-              return;
-            }
-          }
-          const queryUris = files.map(path => Uri.parse(`file:${path}`, true));
-          await Promise.all(queryUris.map(uri => compileAndRunQuery(false, uri)));
-        } catch (e) {
-          helpers.showAndLogErrorMessage(e.message);
-        }
+      async (
+        progress: ProgressCallback,
+        token: CancellationToken,
+        uri: Uri | undefined
+      ) => await compileAndRunQuery(false, uri, progress, token),
+      {
+        title: 'Running query',
+        cancellable: true
       }
     )
   );
   ctx.subscriptions.push(
-    commands.registerCommand(
+    commandRunnerWithProgress(
+      'codeQL.runQueries',
+      async (
+        progress: ProgressCallback,
+        token: CancellationToken,
+        _: Uri | undefined,
+        multi: Uri[]
+      ) => {
+        const maxQueryCount = MAX_QUERIES.getValue() as number;
+        const [files, dirFound] = await gatherQlFiles(multi.map(uri => uri.fsPath));
+        if (files.length > maxQueryCount) {
+          throw new Error(`You tried to run ${files.length} queries, but the maximum is ${maxQueryCount}. Try selecting fewer queries or changing the 'codeQL.runningQueries.maxQueries' setting.`);
+        }
+        // warn user and display selected files when a directory is selected because some ql
+        // files may be hidden from the user.
+        if (dirFound) {
+          const fileString = files.map(file => path.basename(file)).join(', ');
+          const res = await helpers.showBinaryChoiceDialog(
+            `You are about to run ${files.length} queries: ${fileString} Do you want to continue?`
+          );
+          if (!res) {
+            return;
+          }
+        }
+        const queryUris = files.map(path => Uri.parse(`file:${path}`, true));
+
+        // Use a wrapped progress so that messages appear with the queries remaining in it.
+        let queriesRemaining = queryUris.length;
+        function wrappedProgress(update: ProgressUpdate) {
+          const message = queriesRemaining > 1
+            ? `${queriesRemaining} remaining. ${update.message}`
+            : update.message;
+          progress({
+            ...update,
+            message
+          });
+        }
+
+        if (queryUris.length > 1) {
+          // Try to upgrade the current database before running any queries
+          // so that the user isn't confronted with multiple upgrade
+          // requests for each query to run.
+          // Only do it if running multiple queries since this check is
+          // performed on each query run anyway.
+          await databaseUI.tryUpgradeCurrentDatabase(progress, token);
+        }
+
+        wrappedProgress({
+          maxStep: queryUris.length,
+          step: queryUris.length - queriesRemaining,
+          message: ''
+        });
+
+        await Promise.all(queryUris.map(async uri =>
+          compileAndRunQuery(false, uri, wrappedProgress, token)
+            .then(() => queriesRemaining--)
+        ));
+      },
+      {
+        title: 'Running queries',
+        cancellable: true
+      })
+  );
+  ctx.subscriptions.push(
+    commandRunnerWithProgress(
       'codeQL.quickEval',
-      async (uri: Uri | undefined) => await compileAndRunQuery(true, uri)
+      async (
+        progress: ProgressCallback,
+        token: CancellationToken,
+        uri: Uri | undefined
+      ) => await compileAndRunQuery(true, uri, progress, token),
+      {
+        title: 'Running query',
+        cancellable: true
+      })
+  );
+  ctx.subscriptions.push(
+    commandRunnerWithProgress('codeQL.quickQuery', async (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) =>
+      displayQuickQuery(ctx, cliServer, databaseUI, progress, token),
+      {
+        title: 'Run Quick Query'
+      }
     )
   );
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.quickQuery', async () =>
-      displayQuickQuery(ctx, cliServer, databaseUI)
+    commandRunner(
+      'codeQL.openReferencedFile',
+      openReferencedFile
     )
   );
+
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.restartQueryServer', async () => {
-      await qs.restartQueryServer();
+    commandRunnerWithProgress('codeQL.restartQueryServer', async (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) => {
+      await qs.restartQueryServer(progress, token);
       helpers.showAndLogInformationMessage('CodeQL Query Server restarted.', {
         outputLogger: queryServerLogger,
       });
+    }, {
+      title: 'Restarting Query Server'
+    })
+  );
+
+  ctx.subscriptions.push(
+    commandRunnerWithProgress('codeQL.chooseDatabaseFolder', (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) =>
+      databaseUI.handleChooseDatabaseFolder(progress, token), {
+      title: 'Choose a Database from a Folder'
     })
   );
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.chooseDatabaseFolder', () =>
-      databaseUI.handleChooseDatabaseFolder()
-    )
+    commandRunnerWithProgress('codeQL.chooseDatabaseArchive', (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) =>
+      databaseUI.handleChooseDatabaseArchive(progress, token), {
+      title: 'Choose a Database from an Archive'
+    })
   );
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.chooseDatabaseArchive', () =>
-      databaseUI.handleChooseDatabaseArchive()
-    )
+    commandRunnerWithProgress('codeQL.chooseDatabaseLgtm', (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) =>
+      databaseUI.handleChooseDatabaseLgtm(progress, token),
+      {
+        title: 'Adding database from LGTM',
+      })
   );
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.chooseDatabaseLgtm', () =>
-      databaseUI.handleChooseDatabaseLgtm()
-    )
+    commandRunnerWithProgress('codeQL.chooseDatabaseInternet', (
+      progress: ProgressCallback,
+      token: CancellationToken
+    ) =>
+      databaseUI.handleChooseDatabaseInternet(progress, token),
+
+      {
+        title: 'Adding database from URL',
+      })
   );
+
   ctx.subscriptions.push(
-    commands.registerCommand('codeQL.chooseDatabaseInternet', () =>
-      databaseUI.handleChooseDatabaseInternet()
-    )
-  );
+    commandRunner('codeQL.openDocumentation', async () =>
+      env.openExternal(Uri.parse('https://codeql.github.com/docs/'))));
 
   logger.log('Starting language server.');
   ctx.subscriptions.push(client.start());
@@ -536,21 +709,48 @@ async function activateWithInstalledDistribution(
     { scheme: archiveFilesystemProvider.zipArchiveScheme },
     new TemplateQueryDefinitionProvider(cliServer, qs, dbm)
   );
+
   languages.registerReferenceProvider(
     { scheme: archiveFilesystemProvider.zipArchiveScheme },
     new TemplateQueryReferenceProvider(cliServer, qs, dbm)
   );
 
   const astViewer = new AstViewer();
-  ctx.subscriptions.push(commands.registerCommand('codeQL.viewAst', async () => {
-    const ast = await new TemplatePrintAstProvider(cliServer, qs, dbm)
-      .provideAst(window.activeTextEditor?.document);
+  const templateProvider = new TemplatePrintAstProvider(cliServer, qs, dbm);
+
+  ctx.subscriptions.push(astViewer);
+  ctx.subscriptions.push(commandRunnerWithProgress('codeQL.viewAst', async (
+    progress: ProgressCallback,
+    token: CancellationToken
+  ) => {
+    const ast = await templateProvider.provideAst(
+      progress,
+      token,
+      window.activeTextEditor?.document,
+    );
     if (ast) {
       astViewer.updateRoots(await ast.getRoots(), ast.db, ast.fileName);
     }
+  }, {
+    cancellable: true,
+    title: 'Calculate AST'
   }));
 
+  commands.executeCommand('codeQLDatabases.removeOrphanedDatabases');
+
   logger.log('Successfully finished extension initialization.');
+
+  return {
+    ctx,
+    cliServer,
+    qs,
+    distributionManager,
+    databaseManager: dbm,
+    databaseUI,
+    dispose: () => {
+      ctx.subscriptions.forEach(d => d.dispose());
+    }
+  };
 }
 
 function getContextStoragePath(ctx: ExtensionContext) {

extensions/ql-vscode/src/helpers.ts

@@ -2,52 +2,15 @@ import * as fs from 'fs-extra';
 import * as glob from 'glob-promise';
 import * as yaml from 'js-yaml';
 import * as path from 'path';
-import { CancellationToken, ExtensionContext, ProgressOptions, window as Window, workspace } from 'vscode';
+import {
+  ExtensionContext,
+  Uri,
+  window as Window,
+  workspace,
+  env
+} from 'vscode';
 import { CodeQLCliServer } from './cli';
 import { logger } from './logging';
-import { QueryInfo } from './run-queries';
-
-export interface ProgressUpdate {
-  /**
-   * The current step
-   */
-  step: number;
-  /**
-   * The maximum step. This *should* be constant for a single job.
-   */
-  maxStep: number;
-  /**
-   * The current progress message
-   */
-  message: string;
-}
-
-export type ProgressCallback = (p: ProgressUpdate) => void;
-
-/**
- * This mediates between the kind of progress callbacks we want to
- * write (where we *set* current progress position and give
- * `maxSteps`) and the kind vscode progress api expects us to write
- * (which increment progress by a certain amount out of 100%)
- */
-export function withProgress<R>(
-  options: ProgressOptions,
-  task: (
-    progress: (p: ProgressUpdate) => void,
-    token: CancellationToken
-  ) => Thenable<R>
-): Thenable<R> {
-  let progressAchieved = 0;
-  return Window.withProgress(options,
-    (progress, token) => {
-      return task(p => {
-        const { message, step, maxStep } = p;
-        const increment = 100 * (step - progressAchieved) / maxStep;
-        progressAchieved = step;
-        progress.report({ message, increment });
-      }, token);
-    });
-}
 
 /**
  * Show an error message and log it to the console
@@ -55,15 +18,24 @@ export function withProgress<R>(
  * @param message The message to show.
  * @param options.outputLogger The output logger that will receive the message
  * @param options.items A set of items that will be rendered as actions in the message.
+ * @param options.fullMessage An alternate message that is added to the log, but not displayed
+ *                           in the popup. This is useful for adding extra detail to the logs
+ *                           that would be too noisy for the popup.
  *
  * @return A promise that resolves to the selected item or undefined when being dismissed.
  */
 export async function showAndLogErrorMessage(message: string, {
   outputLogger = logger,
-  items = [] as string[]
+  items = [] as string[],
+  fullMessage = undefined as (string | undefined)
 } = {}): Promise<string | undefined> {
-  return internalShowAndLog(message, items, outputLogger, Window.showErrorMessage);
+  return internalShowAndLog(dropLinesExceptInitial(message), items, outputLogger, Window.showErrorMessage, fullMessage);
 }
+
+function dropLinesExceptInitial(message: string, n = 2) {
+  return message.toString().split(/\r?\n/).slice(0, n).join('\n');
+}
+
 /**
  * Show a warning message and log it to the console
  *
@@ -97,10 +69,15 @@ export async function showAndLogInformationMessage(message: string, {
 
 type ShowMessageFn = (message: string, ...items: string[]) => Thenable<string | undefined>;
 
-async function internalShowAndLog(message: string, items: string[], outputLogger = logger,
-  fn: ShowMessageFn): Promise<string | undefined> {
+async function internalShowAndLog(
+  message: string,
+  items: string[],
+  outputLogger = logger,
+  fn: ShowMessageFn,
+  fullMessage?: string
+): Promise<string | undefined> {
   const label = 'Show Log';
-  outputLogger.log(message);
+  outputLogger.log(fullMessage || message);
   const result = await fn(message, label, ...items);
   if (result === label) {
     outputLogger.show();
@@ -110,17 +87,61 @@ async function internalShowAndLog(message: string, items: string[], outputLogger
 
 /**
  * Opens a modal dialog for the user to make a yes/no choice.
- * @param message The message to show.
  *
- * @return `true` if the user clicks 'Yes', `false` if the user clicks 'No' or cancels the dialog.
+ * @param message The message to show.
+ * @param modal If true (the default), show a modal dialog box, otherwise dialog is non-modal and can
+ *        be closed even if the user does not make a choice.
+ *
+ * @return
+ *  `true` if the user clicks 'Yes',
+ *  `false` if the user clicks 'No' or cancels the dialog,
+ *  `undefined` if the dialog is closed without the user making a choice.
  */
-export async function showBinaryChoiceDialog(message: string): Promise<boolean> {
+export async function showBinaryChoiceDialog(message: string, modal = true): Promise<boolean | undefined> {
   const yesItem = { title: 'Yes', isCloseAffordance: false };
   const noItem = { title: 'No', isCloseAffordance: true };
-  const chosenItem = await Window.showInformationMessage(message, { modal: true }, yesItem, noItem);
+  const chosenItem = await Window.showInformationMessage(message, { modal }, yesItem, noItem);
+  if (!chosenItem) {
+    return undefined;
+  }
   return chosenItem?.title === yesItem.title;
 }
 
+/**
+ * Opens a modal dialog for the user to make a yes/no choice.
+ *
+ * @param message The message to show.
+ * @param modal If true (the default), show a modal dialog box, otherwise dialog is non-modal and can
+ *        be closed even if the user does not make a choice.
+ *
+ * @return
+ *  `true` if the user clicks 'Yes',
+ *  `false` if the user clicks 'No' or cancels the dialog,
+ *  `undefined` if the dialog is closed without the user making a choice.
+ */
+export async function showBinaryChoiceWithUrlDialog(message: string, url: string): Promise<boolean | undefined> {
+  const urlItem = { title: 'More Information', isCloseAffordance: false };
+  const yesItem = { title: 'Yes', isCloseAffordance: false };
+  const noItem = { title: 'No', isCloseAffordance: true };
+  let chosenItem;
+
+  // Keep the dialog open as long as the user is clicking the 'more information' option.
+  // To prevent an infinite loop, if the user clicks 'more information' 5 times, close the dialog and return cancelled
+  let count = 0;
+  do {
+    chosenItem = await Window.showInformationMessage(message, { modal: true }, urlItem, yesItem, noItem);
+    if (chosenItem === urlItem) {
+      await env.openExternal(Uri.parse(url, true));
+    }
+    count++;
+  } while (chosenItem === urlItem && count < 5);
+
+  if (!chosenItem || chosenItem.title === urlItem.title) {
+    return undefined;
+  }
+  return chosenItem.title === yesItem.title;
+}
+
 /**
  * Show an information message with a customisable action.
  * @param message The message to show.
@@ -145,24 +166,6 @@ export function getOnDiskWorkspaceFolders() {
   return diskWorkspaceFolders;
 }
 
-/**
- * Gets a human-readable name for an evaluated query.
- * Uses metadata if it exists, and defaults to the query file name.
- */
-export function getQueryName(query: QueryInfo) {
-  // Queries run through quick evaluation are not usually the entire query file.
-  // Label them differently and include the line numbers.
-  if (query.quickEvalPosition !== undefined) {
-    const { line, endLine, fileName } = query.quickEvalPosition;
-    const lineInfo = line === endLine ? `${line}` : `${line}-${endLine}`;
-    return `Quick evaluation of ${path.basename(fileName)}:${lineInfo}`;
-  } else if (query.metadata && query.metadata.name) {
-    return query.metadata.name;
-  } else {
-    return path.basename(query.program.queryPath);
-  }
-}
-
 /**
  * Provides a utility method to invoke a function only if a minimum time interval has elapsed since
  * the last invocation of that function.
@@ -251,12 +254,6 @@ function createRateLimitedResult(): RateLimitedResult {
   };
 }
 
-
-export type DatasetFolderInfo = {
-  dbscheme: string;
-  qlpack: string;
-}
-
 export async function getQlPackForDbscheme(cliServer: CodeQLCliServer, dbschemePath: string): Promise<string> {
   const qlpacks = await cliServer.resolveQlpacks(getOnDiskWorkspaceFolders());
   const packs: { packDir: string | undefined; packName: string }[] =
@@ -275,7 +272,7 @@ export async function getQlPackForDbscheme(cliServer: CodeQLCliServer, dbschemeP
     });
   for (const { packDir, packName } of packs) {
     if (packDir !== undefined) {
-      const qlpack = yaml.safeLoad(await fs.readFile(path.join(packDir, 'qlpack.yml'), 'utf8'));
+      const qlpack = yaml.safeLoad(await fs.readFile(path.join(packDir, 'qlpack.yml'), 'utf8')) as { dbscheme: string };
       if (qlpack.dbscheme !== undefined && path.basename(qlpack.dbscheme) === path.basename(dbschemePath)) {
         return packName;
       }
@@ -284,7 +281,7 @@ export async function getQlPackForDbscheme(cliServer: CodeQLCliServer, dbschemeP
   throw new Error(`Could not find qlpack file for dbscheme ${dbschemePath}`);
 }
 
-export async function resolveDatasetFolder(cliServer: CodeQLCliServer, datasetFolder: string): Promise<DatasetFolderInfo> {
+export async function getPrimaryDbscheme(datasetFolder: string): Promise<string> {
   const dbschemes = await glob(path.join(datasetFolder, '*.dbscheme'));
 
   if (dbschemes.length < 1) {
@@ -293,31 +290,30 @@ export async function resolveDatasetFolder(cliServer: CodeQLCliServer, datasetFo
 
   dbschemes.sort();
   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.`);
   }
-
-  const qlpack = await getQlPackForDbscheme(cliServer, dbscheme);
-  return { dbscheme, qlpack };
+  return dbscheme;
 }
 
 /**
  * A cached mapping from strings to value of type U.
  */
 export class CachedOperation<U> {
-  private readonly operation: (t: string) => Promise<U>;
+  private readonly operation: (t: string, ...args: any[]) => Promise<U>;
   private readonly cached: Map<string, U>;
   private readonly lru: string[];
   private readonly inProgressCallbacks: Map<string, [(u: U) => void, (reason?: any) => void][]>;
 
-  constructor(operation: (t: string) => Promise<U>, private cacheSize = 100) {
+  constructor(operation: (t: string, ...args: any[]) => Promise<U>, private cacheSize = 100) {
     this.operation = operation;
     this.lru = [];
     this.inProgressCallbacks = new Map<string, [(u: U) => void, (reason?: any) => void][]>();
     this.cached = new Map<string, U>();
   }
 
-  async get(t: string): Promise<U> {
+  async get(t: string, ...args: any[]): Promise<U> {
     // Try and retrieve from the cache
     const fromCache = this.cached.get(t);
     if (fromCache !== undefined) {
@@ -338,7 +334,7 @@ export class CachedOperation<U> {
     const callbacks: [(u: U) => void, (reason?: any) => void][] = [];
     this.inProgressCallbacks.set(t, callbacks);
     try {
-      const result = await this.operation(t);
+      const result = await this.operation(t, ...args);
       callbacks.forEach(f => f[0](result));
       this.inProgressCallbacks.delete(t);
       if (this.lru.length > this.cacheSize) {
@@ -357,3 +353,74 @@ export class CachedOperation<U> {
     }
   }
 }
+
+
+
+/**
+ * The following functions al heuristically determine metadata about databases.
+ */
+
+/**
+ * Note that this heuristic is only being used for backwards compatibility with
+ * CLI versions before the langauge name was introduced to dbInfo. Features
+ * that do not require backwards compatibility should call
+ * `cli.CodeQLCliServer.resolveDatabase` and use the first entry in the
+ * `languages` property.
+ *
+ * @see cli.CliVersionConstraint.supportsLanguageName
+ * @see cli.CodeQLCliServer.resolveDatabase
+ */
+const dbSchemeToLanguage = {
+  'semmlecode.javascript.dbscheme': 'javascript',
+  'semmlecode.cpp.dbscheme': 'cpp',
+  'semmlecode.dbscheme': 'java',
+  'semmlecode.python.dbscheme': 'python',
+  'semmlecode.csharp.dbscheme': 'csharp',
+  'go.dbscheme': 'go'
+};
+
+/**
+ * Returns the initial contents for an empty query, based on the language of the selected
+ * databse.
+ *
+ * First try to use the given language name. If that doesn't exist, try to infer it based on
+ * dbscheme. Otherwise return no import statement.
+ *
+ * @param language the database language or empty string if unknown
+ * @param dbscheme path to the dbscheme file
+ *
+ * @returns an import and empty select statement appropriate for the selected language
+ */
+export function getInitialQueryContents(language: string, dbscheme: string) {
+  if (!language) {
+    const dbschemeBase = path.basename(dbscheme) as keyof typeof dbSchemeToLanguage;
+    language = dbSchemeToLanguage[dbschemeBase];
+  }
+
+  return language
+    ? `import ${language}\n\nselect ""`
+    : 'select ""';
+}
+
+/**
+ * Heuristically determines if the directory passed in corresponds
+ * to a database root.
+ *
+ * @param maybeRoot
+ */
+export async function isLikelyDatabaseRoot(maybeRoot: string) {
+  const [a, b, c] = (await Promise.all([
+    // databases can have either .dbinfo or codeql-database.yml.
+    fs.pathExists(path.join(maybeRoot, '.dbinfo')),
+    fs.pathExists(path.join(maybeRoot, 'codeql-database.yml')),
+
+    // they *must* have a db-{language} folder
+    glob('db-*/', { cwd: maybeRoot })
+  ]));
+
+  return !!((a || b) && c);
+}
+
+export function isLikelyDbLanguageFolder(dbPath: string) {
+  return !!path.basename(dbPath).startsWith('db-');
+}

extensions/ql-vscode/src/ide-server.ts

@@ -12,7 +12,7 @@ import { ideServerLogger } from './logging';
 export async function spawnIdeServer(config: QueryServerConfig): Promise<StreamInfo> {
   return window.withProgress({ title: 'CodeQL language server', location: ProgressLocation.Window }, async (progressReporter, _) => {
     const args = ['--check-errors', 'ON_CHANGE'];
-    if (shouldDebug()) {
+    if (cli.shouldDebugIdeServer()) {
       args.push('-J=-agentlib:jdwp=transport=dt_socket,address=localhost:9009,server=y,suspend=n,quiet=y');
     }
     const child = cli.spawnServer(
@@ -28,9 +28,3 @@ export async function spawnIdeServer(config: QueryServerConfig): Promise<StreamI
     return { writer: child.stdin!, reader: child.stdout! };
   });
 }
-
-function shouldDebug() {
-  return 'DEBUG_LANGUAGE_SERVER' in process.env
-    && process.env.DEBUG_LANGUAGE_SERVER !== '0'
-    && process.env.DEBUG_LANGUAGE_SERVER?.toLocaleLowerCase() !== 'false';
-}

extensions/ql-vscode/src/interface-utils.ts

@@ -12,19 +12,19 @@ import {
   TextEditorRevealType,
   ThemeColor,
 } from 'vscode';
-import {
-  FivePartLocation,
-  LocationStyle,
-  LocationValue,
-  WholeFileLocation,
-  ResolvableLocationValue,
-} from './bqrs-types';
 import {
   tryGetResolvableLocation,
-} from './bqrs-utils';
+  isLineColumnLoc
+} from './pure/bqrs-utils';
 import { DatabaseItem, DatabaseManager } from './databases';
-import { ViewSourceFileMsg } from './interface-types';
+import { ViewSourceFileMsg } from './pure/interface-types';
 import { Logger } from './logging';
+import {
+  LineColumnLocation,
+  WholeFileLocation,
+  UrlValue,
+  ResolvableLocationValue
+} from './pure/bqrs-cli-types';
 
 /**
  * This module contains functions and types that are sharedd between
@@ -61,19 +61,19 @@ export function fileUriToWebviewUri(
  * @param databaseItem Database in which to resolve the file location.
  */
 function resolveFivePartLocation(
-  loc: FivePartLocation,
+  loc: LineColumnLocation,
   databaseItem: DatabaseItem
 ): Location {
   // `Range` is a half-open interval, and is zero-based. CodeQL locations are closed intervals, and
   // are one-based. Adjust accordingly.
   const range = new Range(
-    Math.max(0, loc.lineStart - 1),
-    Math.max(0, loc.colStart - 1),
-    Math.max(0, loc.lineEnd - 1),
-    Math.max(0, loc.colEnd)
+    Math.max(0, loc.startLine - 1),
+    Math.max(0, loc.startColumn - 1),
+    Math.max(0, loc.endLine - 1),
+    Math.max(0, loc.endColumn)
   );
 
-  return new Location(databaseItem.resolveSourceFile(loc.file), range);
+  return new Location(databaseItem.resolveSourceFile(loc.uri), range);
 }
 
 /**
@@ -87,7 +87,7 @@ function resolveWholeFileLocation(
 ): Location {
   // A location corresponding to the start of the file.
   const range = new Range(0, 0, 0, 0);
-  return new Location(databaseItem.resolveSourceFile(loc.file), range);
+  return new Location(databaseItem.resolveSourceFile(loc.uri), range);
 }
 
 /**
@@ -97,20 +97,16 @@ function resolveWholeFileLocation(
  * @param databaseItem Database in which to resolve the file location.
  */
 export function tryResolveLocation(
-  loc: LocationValue | undefined,
+  loc: UrlValue | undefined,
   databaseItem: DatabaseItem
 ): Location | undefined {
   const resolvableLoc = tryGetResolvableLocation(loc);
-  if (resolvableLoc === undefined) {
-    return undefined;
-  }
-  switch (resolvableLoc.t) {
-    case LocationStyle.FivePart:
-      return resolveFivePartLocation(resolvableLoc, databaseItem);
-    case LocationStyle.WholeFile:
-      return resolveWholeFileLocation(resolvableLoc, databaseItem);
-    default:
-      return undefined;
+  if (!resolvableLoc || typeof resolvableLoc === 'string') {
+    return;
+  } else if (isLineColumnLoc(resolvableLoc)) {
+    return resolveFivePartLocation(resolvableLoc, databaseItem);
+  } else {
+    return resolveWholeFileLocation(resolvableLoc, databaseItem);
   }
 }
 
@@ -160,33 +156,41 @@ export async function showResolvableLocation(
 }
 
 export async function showLocation(location?: Location) {
-  if (location) {
-    const doc = await workspace.openTextDocument(location.uri);
-    const editorsWithDoc = Window.visibleTextEditors.filter(
-      (e) => e.document === doc
-    );
-    const editor =
-      editorsWithDoc.length > 0
-        ? editorsWithDoc[0]
-        : await Window.showTextDocument(doc, ViewColumn.One);
-    const range = location.range;
-    // When highlighting the range, vscode's occurrence-match and bracket-match highlighting will
-    // trigger based on where we place the cursor/selection, and will compete for the user's attention.
-    // For reference:
-    // - Occurences are highlighted when the cursor is next to or inside a word or a whole word is selected.
-    // - Brackets are highlighted when the cursor is next to a bracket and there is an empty selection.
-    // - Multi-line selections explicitly highlight line-break characters, but multi-line decorators do not.
-    //
-    // For single-line ranges, select the whole range, mainly to disable bracket highlighting.
-    // For multi-line ranges, place the cursor at the beginning to avoid visual artifacts from selected line-breaks.
-    // Multi-line ranges are usually large enough to overshadow the noise from bracket highlighting.
-    const selectionEnd =
-      range.start.line === range.end.line ? range.end : range.start;
-    editor.selection = new Selection(range.start, selectionEnd);
-    editor.revealRange(range, TextEditorRevealType.InCenter);
-    editor.setDecorations(shownLocationDecoration, [range]);
-    editor.setDecorations(shownLocationLineDecoration, [range]);
+  if (!location) {
+    return;
   }
+
+  const doc = await workspace.openTextDocument(location.uri);
+  const editorsWithDoc = Window.visibleTextEditors.filter(
+    (e) => e.document === doc
+  );
+  const editor =
+    editorsWithDoc.length > 0
+      ? editorsWithDoc[0]
+      : await Window.showTextDocument(
+        doc, {
+        // avoid preview mode so editor is sticky and will be added to navigation and search histories.
+        preview: false,
+        viewColumn: ViewColumn.One,
+      });
+
+  const range = location.range;
+  // When highlighting the range, vscode's occurrence-match and bracket-match highlighting will
+  // trigger based on where we place the cursor/selection, and will compete for the user's attention.
+  // For reference:
+  // - Occurences are highlighted when the cursor is next to or inside a word or a whole word is selected.
+  // - Brackets are highlighted when the cursor is next to a bracket and there is an empty selection.
+  // - Multi-line selections explicitly highlight line-break characters, but multi-line decorators do not.
+  //
+  // For single-line ranges, select the whole range, mainly to disable bracket highlighting.
+  // For multi-line ranges, place the cursor at the beginning to avoid visual artifacts from selected line-breaks.
+  // Multi-line ranges are usually large enough to overshadow the noise from bracket highlighting.
+  const selectionEnd =
+    range.start.line === range.end.line ? range.end : range.start;
+  editor.selection = new Selection(range.start, selectionEnd);
+  editor.revealRange(range, TextEditorRevealType.InCenter);
+  editor.setDecorations(shownLocationDecoration, [range]);
+  editor.setDecorations(shownLocationLineDecoration, [range]);
 }
 
 const findMatchBackground = new ThemeColor('editor.findMatchBackground');

extensions/ql-vscode/src/interface.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as Sarif from 'sarif';
-import { DisposableObject } from './vscode-utils/disposable-object';
+import { DisposableObject } from './pure/disposable-object';
 import * as vscode from 'vscode';
 import {
   Diagnostic,
@@ -13,9 +13,9 @@ import {
 } from 'vscode';
 import * as cli from './cli';
 import { CodeQLCliServer } from './cli';
-import { DatabaseItem, DatabaseManager } from './databases';
+import { DatabaseEventKind, DatabaseItem, DatabaseManager } from './databases';
 import { showAndLogErrorMessage } from './helpers';
-import { assertNever } from './helpers-pure';
+import { assertNever } from './pure/helpers-pure';
 import {
   FromResultsViewMsg,
   Interpretation,
@@ -26,22 +26,15 @@ import {
   SortedResultsMap,
   InterpretedResultsSortState,
   SortDirection,
-  RAW_RESULTS_PAGE_SIZE,
-  INTERPRETED_RESULTS_PAGE_SIZE,
   ALERTS_TABLE_NAME,
   RawResultsSortState,
-} from './interface-types';
+} from './pure/interface-types';
 import { Logger } from './logging';
-import * as messages from './messages';
+import * as messages from './pure/messages';
+import { commandRunner } from './commandRunner';
 import { CompletedQuery, interpretResults } from './query-results';
 import { QueryInfo, tmpDir } from './run-queries';
-import { parseSarifLocation, parseSarifPlainTextMessage } from './sarif-utils';
-import {
-  adaptSchema,
-  adaptBqrs,
-  ParsedResultSets,
-  RawResultSet,
-} from './adapt';
+import { parseSarifLocation, parseSarifPlainTextMessage } from './pure/sarif-utils';
 import {
   WebviewReveal,
   fileUriToWebviewUri,
@@ -51,8 +44,9 @@ import {
   shownLocationLineDecoration,
   jumpToLocation,
 } from './interface-utils';
-import { getDefaultResultSetName } from './interface-types';
-import { ResultSetSchema } from './bqrs-cli-types';
+import { getDefaultResultSetName, ParsedResultSets } from './pure/interface-types';
+import { RawResultSet, transformBqrsResultSet, ResultSetSchema } from './pure/bqrs-cli-types';
+import { PAGE_SIZE } from './config';
 
 /**
  * interface.ts
@@ -94,11 +88,11 @@ function sortInterpretedResults(
 }
 
 function numPagesOfResultSet(resultSet: RawResultSet): number {
-  return Math.ceil(resultSet.schema.tupleCount / RAW_RESULTS_PAGE_SIZE);
+  return Math.ceil(resultSet.schema.rows / PAGE_SIZE.getValue<number>());
 }
 
 function numInterpretedPages(interpretation: Interpretation | undefined): number {
-  return Math.ceil((interpretation?.sarif.runs[0].results?.length || 0) / INTERPRETED_RESULTS_PAGE_SIZE);
+  return Math.ceil((interpretation?.sarif.runs[0].results?.length || 0) / PAGE_SIZE.getValue<number>());
 }
 
 export class InterfaceManager extends DisposableObject {
@@ -127,23 +121,40 @@ export class InterfaceManager extends DisposableObject {
     );
     logger.log('Registering path-step navigation commands.');
     this.push(
-      vscode.commands.registerCommand(
+      commandRunner(
         'codeQLQueryResults.nextPathStep',
         this.navigatePathStep.bind(this, 1)
       )
     );
     this.push(
-      vscode.commands.registerCommand(
+      commandRunner(
         'codeQLQueryResults.previousPathStep',
         this.navigatePathStep.bind(this, -1)
       )
     );
+
+    this.push(
+      this.databaseManager.onDidChangeDatabaseItem(({ kind }) => {
+        if (kind === DatabaseEventKind.Remove) {
+          this._diagnosticCollection.clear();
+          if (this.isShowingPanel()) {
+            this.postMessage({
+              t: 'untoggleShowProblems'
+            });
+          }
+        }
+      })
+    );
   }
 
-  navigatePathStep(direction: number): void {
+  async navigatePathStep(direction: number): Promise<void> {
     this.postMessage({ t: 'navigatePath', direction });
   }
 
+  private isShowingPanel() {
+    return !!this._panel;
+  }
+
   // Returns the webview panel, creating it if it doesn't already
   // exist.
   getPanel(): vscode.WebviewPanel {
@@ -163,6 +174,7 @@ export class InterfaceManager extends DisposableObject {
           ]
         }
       ));
+
       this._panel.onDidDispose(
         () => {
           this._panel = undefined;
@@ -231,50 +243,67 @@ export class InterfaceManager extends DisposableObject {
   }
 
   private async handleMsgFromView(msg: FromResultsViewMsg): Promise<void> {
-    switch (msg.t) {
-      case 'viewSourceFile': {
-        await jumpToLocation(msg, this.databaseManager, this.logger);
-        break;
-      }
-      case 'toggleDiagnostics': {
-        if (msg.visible) {
-          const databaseItem = this.databaseManager.findDatabaseItem(
-            Uri.parse(msg.databaseUri)
-          );
-          if (databaseItem !== undefined) {
-            await this.showResultsAsDiagnostics(
-              msg.origResultsPaths,
-              msg.metadata,
-              databaseItem
+    try {
+      switch (msg.t) {
+        case 'viewSourceFile': {
+          await jumpToLocation(msg, this.databaseManager, this.logger);
+          break;
+        }
+        case 'toggleDiagnostics': {
+          if (msg.visible) {
+            const databaseItem = this.databaseManager.findDatabaseItem(
+              Uri.parse(msg.databaseUri)
+            );
+            if (databaseItem !== undefined) {
+              await this.showResultsAsDiagnostics(
+                msg.origResultsPaths,
+                msg.metadata,
+                databaseItem
+              );
+            }
+          } else {
+            // TODO: Only clear diagnostics on the same database.
+            this._diagnosticCollection.clear();
+          }
+          break;
+        }
+        case 'resultViewLoaded':
+          this._panelLoaded = true;
+          this._panelLoadedCallBacks.forEach((cb) => cb());
+          this._panelLoadedCallBacks = [];
+          break;
+        case 'changeSort':
+          await this.changeRawSortState(msg.resultSetName, msg.sortState);
+          break;
+        case 'changeInterpretedSort':
+          await this.changeInterpretedSortState(msg.sortState);
+          break;
+        case 'changePage':
+          if (msg.selectedTable === ALERTS_TABLE_NAME) {
+            await this.showPageOfInterpretedResults(msg.pageNumber);
+          }
+          else {
+            await this.showPageOfRawResults(
+              msg.selectedTable,
+              msg.pageNumber,
+              // When we are in an unsorted state, we guarantee that
+              // sortedResultsInfo doesn't have an entry for the current
+              // result set. Use this to determine whether or not we use
+              // the sorted bqrs file.
+              this._displayedQuery?.sortedResultsInfo.has(msg.selectedTable) || false
             );
           }
-        } else {
-          // TODO: Only clear diagnostics on the same database.
-          this._diagnosticCollection.clear();
-        }
-        break;
+          break;
+        case 'openFile':
+          await this.openFile(msg.filePath);
+          break;
+        default:
+          assertNever(msg);
       }
-      case 'resultViewLoaded':
-        this._panelLoaded = true;
-        this._panelLoadedCallBacks.forEach((cb) => cb());
-        this._panelLoadedCallBacks = [];
-        break;
-      case 'changeSort':
-        await this.changeRawSortState(msg.resultSetName, msg.sortState);
-        break;
-      case 'changeInterpretedSort':
-        await this.changeInterpretedSortState(msg.sortState);
-        break;
-      case 'changePage':
-        if (msg.selectedTable === ALERTS_TABLE_NAME) {
-          await this.showPageOfInterpretedResults(msg.pageNumber);
-        }
-        else {
-          await this.showPageOfRawResults(msg.selectedTable, msg.pageNumber);
-        }
-        break;
-      default:
-        assertNever(msg);
+    } catch (e) {
+      showAndLogErrorMessage(e.message, {
+        fullMessage: e.stack
+      });
     }
   }
 
@@ -350,36 +379,43 @@ export class InterfaceManager extends DisposableObject {
       });
     }
 
-    const getParsedResultSets = async (): Promise<ParsedResultSets> => {
+    // Note that the resultSetSchemas will return offsets for the default (unsorted) page,
+    // which may not be correct. However, in this case, it doesn't matter since we only
+    // need the first offset, which will be the same no matter which sorting we use.
+    const resultSetSchemas = await this.getResultSetSchemas(results);
+    const resultSetNames = resultSetSchemas.map(schema => schema.name);
 
-      const resultSetSchemas = await this.getResultSetSchemas(results);
-      const resultSetNames = resultSetSchemas.map(schema => schema.name);
+    const selectedTable = getDefaultResultSetName(resultSetNames);
+    const schema = resultSetSchemas.find(
+      (resultSet) => resultSet.name == selectedTable
+    )!;
 
-      // This may not wind up being the page we actually show, if there are interpreted results,
-      // but speculatively send it anyway.
-      const selectedTable = getDefaultResultSetName(resultSetNames);
-      const schema = resultSetSchemas.find(
-        (resultSet) => resultSet.name == selectedTable
-      )!;
-
-      const chunk = await this.cliServer.bqrsDecode(
-        results.query.resultsPaths.resultsPath,
-        schema.name,
-        {
-          offset: schema.pagination?.offsets[0],
-          pageSize: RAW_RESULTS_PAGE_SIZE
-        }
-      );
-      const adaptedSchema = adaptSchema(schema);
-      const resultSet = adaptBqrs(adaptedSchema, chunk);
-      return {
-        pageNumber: 0,
-        numPages: numPagesOfResultSet(resultSet),
-        numInterpretedPages: numInterpretedPages(this._interpretation),
-        resultSet: { t: 'RawResultSet', ...resultSet },
-        selectedTable: undefined,
-        resultSetNames,
-      };
+    // Use sorted results path if it exists. This may happen if we are
+    // reloading the results view after it has been sorted in the past.
+    const resultsPath = results.getResultsPath(selectedTable);
+    const pageSize = PAGE_SIZE.getValue<number>();
+    const chunk = await this.cliServer.bqrsDecode(
+      resultsPath,
+      schema.name,
+      {
+        // Always send the first page.
+        // It may not wind up being the page we actually show,
+        // if there are interpreted results, but speculatively
+        // send anyway.
+        offset: schema.pagination?.offsets[0],
+        pageSize
+      }
+    );
+    const resultSet = transformBqrsResultSet(schema, chunk);
+    results.setResultCount(interpretationPage?.numTotalResults || resultSet.schema.rows);
+    const parsedResultSets: ParsedResultSets = {
+      pageNumber: 0,
+      pageSize,
+      numPages: numPagesOfResultSet(resultSet),
+      numInterpretedPages: numInterpretedPages(this._interpretation),
+      resultSet: { ...resultSet, t: 'RawResultSet' },
+      selectedTable: undefined,
+      resultSetNames,
     };
 
     await this.postMessage({
@@ -389,11 +425,13 @@ export class InterfaceManager extends DisposableObject {
       resultsPath: this.convertPathToWebviewUri(
         results.query.resultsPaths.resultsPath
       ),
-      parsedResultSets: await getParsedResultSets(),
+      parsedResultSets,
       sortedResultsMap,
       database: results.database,
       shouldKeepOldResultsWhileRendering,
       metadata: results.query.metadata,
+      queryName: results.toString(),
+      queryPath: results.query.program.queryPath
     });
   }
 
@@ -423,18 +461,27 @@ export class InterfaceManager extends DisposableObject {
       metadata: this._displayedQuery.query.metadata,
       pageNumber,
       resultSetNames,
+      pageSize: PAGE_SIZE.getValue(),
       numPages: numInterpretedPages(this._interpretation),
+      queryName: this._displayedQuery.toString(),
+      queryPath: this._displayedQuery.query.program.queryPath
     });
   }
 
-  private async getResultSetSchemas(results: CompletedQuery): Promise<ResultSetSchema[]> {
+  private async getResultSetSchemas(results: CompletedQuery, selectedTable = ''): Promise<ResultSetSchema[]> {
+    const resultsPath = results.getResultsPath(selectedTable);
     const schemas = await this.cliServer.bqrsInfo(
-      results.query.resultsPaths.resultsPath,
-      RAW_RESULTS_PAGE_SIZE
+      resultsPath,
+      PAGE_SIZE.getValue()
     );
     return schemas['result-sets'];
   }
 
+  public async openFile(filePath: string) {
+    const textDocument = await vscode.workspace.openTextDocument(filePath);
+    await vscode.window.showTextDocument(textDocument, vscode.ViewColumn.One);
+  }
+
   /**
    * Show a page of raw results from the chosen table.
    */
@@ -454,7 +501,7 @@ export class InterfaceManager extends DisposableObject {
         (sortedResultsMap[k] = this.convertPathPropertiesToWebviewUris(v))
     );
 
-    const resultSetSchemas = await this.getResultSetSchemas(results);
+    const resultSetSchemas = await this.getResultSetSchemas(results, sorted ? selectedTable : '');
     const resultSetNames = resultSetSchemas.map(schema => schema.name);
 
     const schema = resultSetSchemas.find(
@@ -463,32 +510,20 @@ export class InterfaceManager extends DisposableObject {
     if (schema === undefined)
       throw new Error(`Query result set '${selectedTable}' not found.`);
 
-    const getResultsPath = () => {
-      if (sorted) {
-        const resultsPath = results.sortedResultsInfo.get(selectedTable)?.resultsPath;
-        if (resultsPath === undefined) {
-          throw new Error(`Can't find sorted results for table ${selectedTable}`);
-        }
-        return resultsPath;
-      }
-      else {
-        return results.query.resultsPaths.resultsPath;
-      }
-    };
-
+    const pageSize = PAGE_SIZE.getValue<number>();
     const chunk = await this.cliServer.bqrsDecode(
-      getResultsPath(),
+      results.getResultsPath(selectedTable, sorted),
       schema.name,
       {
         offset: schema.pagination?.offsets[pageNumber],
-        pageSize: RAW_RESULTS_PAGE_SIZE
+        pageSize
       }
     );
-    const adaptedSchema = adaptSchema(schema);
-    const resultSet = adaptBqrs(adaptedSchema, chunk);
+    const resultSet = transformBqrsResultSet(schema, chunk);
 
     const parsedResultSets: ParsedResultSets = {
       pageNumber,
+      pageSize,
       resultSet: { t: 'RawResultSet', ...resultSet },
       numPages: numPagesOfResultSet(resultSet),
       numInterpretedPages: numInterpretedPages(this._interpretation),
@@ -508,6 +543,8 @@ export class InterfaceManager extends DisposableObject {
       database: results.database,
       shouldKeepOldResultsWhileRendering: false,
       metadata: results.query.metadata,
+      queryName: results.toString(),
+      queryPath: results.query.program.queryPath
     });
   }
 
@@ -517,23 +554,26 @@ export class InterfaceManager extends DisposableObject {
     sourceInfo: cli.SourceInfo | undefined,
     sourceLocationPrefix: string,
     sortState: InterpretedResultsSortState | undefined
-  ): Promise<Interpretation> {
+  ): Promise<Interpretation | undefined> {
+    if (!resultsPaths) {
+      this.logger.log('No results path. Cannot display interpreted results.');
+      return undefined;
+    }
+
     const sarif = await interpretResults(
       this.cliServer,
       metadata,
       resultsPaths,
       sourceInfo
     );
+
     sarif.runs.forEach(run => {
-      if (run.results !== undefined)
+      if (run.results !== undefined) {
         sortInterpretedResults(run.results, sortState);
+      }
     });
 
-    const numTotalResults = (() => {
-      if (sarif.runs.length === 0) return 0;
-      if (sarif.runs[0].results === undefined) return 0;
-      return sarif.runs[0].results.length;
-    })();
+    const numTotalResults = sarif.runs[0]?.results?.length || 0;
 
     const interpretation: Interpretation = {
       sarif,
@@ -553,8 +593,8 @@ export class InterfaceManager extends DisposableObject {
     function getPageOfRun(run: Sarif.Run): Sarif.Run {
       return {
         ...run, results: run.results?.slice(
-          INTERPRETED_RESULTS_PAGE_SIZE * pageNumber,
-          INTERPRETED_RESULTS_PAGE_SIZE * (pageNumber + 1)
+          PAGE_SIZE.getValue<number>() * pageNumber,
+          PAGE_SIZE.getValue<number>() * (pageNumber + 1)
         )
       };
     }
@@ -602,8 +642,8 @@ export class InterfaceManager extends DisposableObject {
       } catch (e) {
         // If interpretation fails, accept the error and continue
         // trying to render uninterpreted results anyway.
-        this.logger.log(
-          `Exception during results interpretation: ${e.message}. Will show raw results instead.`
+        showAndLogErrorMessage(
+          `Showing raw results instead of interpreted ones due to an error. ${e.message}`
         );
       }
     }
@@ -635,6 +675,10 @@ export class InterfaceManager extends DisposableObject {
       undefined
     );
 
+    if (!interpretation) {
+      return;
+    }
+
     try {
       await this.showProblemResultsAsDiagnostics(interpretation, database);
     } catch (e) {
@@ -676,7 +720,7 @@ export class InterfaceManager extends DisposableObject {
         result.locations[0],
         sourceLocationPrefix
       );
-      if (sarifLoc.t == 'NoLocation') {
+      if ('hint' in sarifLoc) {
         continue;
       }
       const resultLocation = tryResolveLocation(sarifLoc, databaseItem);
@@ -701,7 +745,7 @@ export class InterfaceManager extends DisposableObject {
             relatedLocationsById[section.dest],
             sourceLocationPrefix
           );
-          if (sarifChunkLoc.t == 'NoLocation') {
+          if ('hint' in sarifChunkLoc) {
             continue;
           }
           const referenceLocation = tryResolveLocation(

extensions/ql-vscode/src/logging.ts

@@ -1,5 +1,5 @@
 import { window as Window, OutputChannel, Progress, Disposable } from 'vscode';
-import { DisposableObject } from './vscode-utils/disposable-object';
+import { DisposableObject } from './pure/disposable-object';
 import * as fs from 'fs-extra';
 import * as path from 'path';
 

extensions/ql-vscode/src/pure/bqrs-cli-types.ts

@@ -67,18 +67,6 @@ export interface LineColumnLocation {
   startColumn: number;
   endLine: number;
   endColumn: number;
-  charOffset: never;
-  charLength: never;
-}
-
-export interface OffsetLengthLocation {
-  uri: string;
-  startLine: never;
-  startColumn: never;
-  endLine: never;
-  endColumn: never;
-  charOffset: number;
-  charLength: number;
 }
 
 export interface WholeFileLocation {
@@ -87,15 +75,34 @@ export interface WholeFileLocation {
   startColumn: never;
   endLine: never;
   endColumn: never;
-  charOffset: never;
-  charLength: never;
 }
 
-export type UrlValue = LineColumnLocation | OffsetLengthLocation | WholeFileLocation | string;
+export type ResolvableLocationValue = WholeFileLocation | LineColumnLocation;
 
+export type UrlValue = ResolvableLocationValue  | string;
 
 export type ColumnValue = EntityValue | number | string | boolean;
 
+export type ResultRow = ColumnValue[];
+
+export interface RawResultSet {
+  readonly schema: ResultSetSchema;
+  readonly rows: readonly ResultRow[];
+}
+
+// TODO: This function is not necessary. It generates a tuple that is slightly easier
+// to handle than the ResultSetSchema and DecodedBqrsChunk. But perhaps it is unnecessary
+// boilerplate.
+export function transformBqrsResultSet(
+  schema: ResultSetSchema,
+  page: DecodedBqrsChunk
+): RawResultSet {
+  return {
+    schema,
+    rows: Array.from(page.tuples),
+  };
+}
+
 export interface DecodedBqrsChunk {
   tuples: ColumnValue[][];
   next?: number;

extensions/ql-vscode/src/pure/bqrs-utils.ts

@@ -0,0 +1,96 @@
+import {
+  UrlValue,
+  ResolvableLocationValue,
+  LineColumnLocation,
+  WholeFileLocation
+} from './bqrs-cli-types';
+
+/**
+ * The CodeQL filesystem libraries use this pattern in `getURL()` predicates
+ * to describe the location of an entire filesystem resource.
+ * Such locations appear as `StringLocation`s instead of `FivePartLocation`s.
+ *
+ * Folder resources also get similar URLs, but with the `folder` scheme.
+ * They are deliberately ignored here, since there is no suitable location to show the user.
+ */
+const FILE_LOCATION_REGEX = /file:\/\/(.+):([0-9]+):([0-9]+):([0-9]+):([0-9]+)/;
+/**
+ * Gets a resolvable source file location for the specified `LocationValue`, if possible.
+ * @param loc The location to test.
+ */
+export function tryGetResolvableLocation(
+  loc: UrlValue | undefined
+): ResolvableLocationValue | undefined {
+  let resolvedLoc;
+  if (loc === undefined) {
+    resolvedLoc = undefined;
+  } else if (isWholeFileLoc(loc) || isLineColumnLoc(loc)) {
+    resolvedLoc = loc as ResolvableLocationValue;
+  } else if (isStringLoc(loc)) {
+    resolvedLoc = tryGetLocationFromString(loc);
+  } else {
+    resolvedLoc = undefined;
+  }
+
+  return resolvedLoc;
+}
+
+export function tryGetLocationFromString(
+  loc: string
+): ResolvableLocationValue | undefined {
+  const matches = FILE_LOCATION_REGEX.exec(loc);
+  if (matches && matches.length > 1 && matches[1]) {
+    if (isWholeFileMatch(matches)) {
+      return {
+        uri: matches[1],
+      } as WholeFileLocation;
+    } else {
+      return {
+        uri: matches[1],
+        startLine: Number(matches[2]),
+        startColumn: Number(matches[3]),
+        endLine: Number(matches[4]),
+        endColumn: Number(matches[5]),
+      };
+    }
+  } else {
+    return undefined;
+  }
+}
+
+function isWholeFileMatch(matches: RegExpExecArray): boolean {
+  return (
+    matches[2] === '0' &&
+    matches[3] === '0' &&
+    matches[4] === '0' &&
+    matches[5] === '0'
+  );
+}
+
+/**
+ * Checks whether the file path is empty. If so, we do not want to render this location
+ * as a link.
+ *
+ * @param uri A file uri
+ */
+export function isEmptyPath(uriStr: string) {
+  return !uriStr || uriStr === 'file:/';
+}
+
+export function isLineColumnLoc(loc: UrlValue): loc is LineColumnLocation {
+  return typeof loc !== 'string'
+    && !isEmptyPath(loc.uri)
+    && 'startLine' in loc
+    && 'startColumn' in loc
+    && 'endLine' in loc
+    && 'endColumn' in loc
+    && loc.endColumn > 0;
+}
+
+export function isWholeFileLoc(loc: UrlValue): loc is WholeFileLocation {
+  return typeof loc !== 'string' && !isEmptyPath(loc.uri) && !isLineColumnLoc(loc);
+}
+
+export function isStringLoc(loc: UrlValue): loc is string {
+  return typeof loc === 'string';
+}

extensions/ql-vscode/src/pure/disposable-object.ts

@@ -1,4 +1,11 @@
-import { Disposable } from 'vscode';
+
+// Avoid explicitly referencing Disposable type in vscode.
+// This file cannot have dependencies on the vscode API.
+interface Disposable {
+  dispose(): any;
+}
+
+export type DisposeHandler = (disposable: Disposable) => void;
 
 /**
  * Base class to make it easier to implement a `Disposable` that owns other disposable object.
@@ -40,21 +47,39 @@ export abstract class DisposableObject implements Disposable {
    * @param obj The object to stop tracking.
    */
   protected disposeAndStopTracking(obj: Disposable): void {
-    if (obj !== undefined) {
-      this.tracked!.delete(obj);
+    if (obj && this.tracked) {
+      this.tracked.delete(obj);
       obj.dispose();
     }
   }
 
-  public dispose() {
+  /**
+   * Dispose this object and all contained objects
+   *
+   * @param disposeHandler An optional dispose handler that gets
+   *      passed each element to dispose. The dispose handler
+   *      can choose how (and if) to dispose the object. The
+   *      primary usage is for tests that should not dispose
+   *      all items of a disposable.
+   */
+  public dispose(disposeHandler?: DisposeHandler) {
     if (this.tracked !== undefined) {
       for (const trackedObject of this.tracked.values()) {
-        trackedObject.dispose();
+        if (disposeHandler) {
+          disposeHandler(trackedObject);
+        } else {
+          trackedObject.dispose();
+        }
       }
       this.tracked = undefined;
     }
     while (this.disposables.length > 0) {
-      this.disposables.pop()!.dispose();
+      const disposable = this.disposables.pop()!;
+      if (disposeHandler) {
+        disposeHandler(disposable);
+      } else {
+        disposable.dispose();
+      }
     }
   }
 }

extensions/ql-vscode/src/pure/helpers-pure.ts

@@ -2,7 +2,7 @@
  * helpers-pure.ts
  * ------------
  *
- * Helper functions that don't depend on vscode and therefore can be used by the front-end and pure unit tests.
+ * Helper functions that don't depend on vscode or the CLI and therefore can be used by the front-end and pure unit tests.
  */
 
 /**
@@ -21,3 +21,11 @@ class ExhaustivityCheckingError extends Error {
 export function assertNever(value: never): never {
   throw new ExhaustivityCheckingError(value);
 }
+
+/**
+ * Use to perform array filters where the predicate is asynchronous.
+ */
+export const asyncFilter = async function <T>(arr: T[], predicate: (arg0: T) => Promise<boolean>) {
+  const results = await Promise.all(arr.map(predicate));
+  return arr.filter((_, index) => results[index]);
+};

extensions/ql-vscode/src/pure/interface-types.ts

@@ -1,10 +1,5 @@
 import * as sarif from 'sarif';
-import {
-  ResolvableLocationValue,
-  ColumnSchema,
-  ResultSetSchema,
-} from './bqrs-types';
-import { ResultRow, ParsedResultSets, RawResultSet } from './adapt';
+import { RawResultSet, ResultRow, ResultSetSchema, Column, ResolvableLocationValue } from './bqrs-cli-types';
 
 /**
  * This module contains types and code that are shared between
@@ -28,16 +23,6 @@ export type ResultSet = RawTableResultSet | PathTableResultSet;
  */
 export const RAW_RESULTS_LIMIT = 10000;
 
-/**
- * Show this many rows in a raw result table at a time.
- */
-export const RAW_RESULTS_PAGE_SIZE = 100;
-
-/**
- * Show this many rows in an interpreted results table at a time.
- */
-export const INTERPRETED_RESULTS_PAGE_SIZE = 100;
-
 export interface DatabaseInfo {
   name: string;
   databaseUri: string;
@@ -49,6 +34,7 @@ export interface QueryMetadata {
   description?: string;
   id?: string;
   kind?: string;
+  scored?: string;
 }
 
 export interface PreviousExecution {
@@ -91,6 +77,10 @@ export interface ResultsUpdatingMsg {
   t: 'resultsUpdating';
 }
 
+/**
+ * Message to set the initial state of the results view with a new
+ * query.
+ */
 export interface SetStateMsg {
   t: 'setState';
   resultsPath: string;
@@ -99,6 +89,8 @@ export interface SetStateMsg {
   interpretation: undefined | Interpretation;
   database: DatabaseInfo;
   metadata?: QueryMetadata;
+  queryName: string;
+  queryPath: string;
   /**
    * Whether to keep displaying the old results while rendering the new results.
    *
@@ -114,6 +106,10 @@ export interface SetStateMsg {
   parsedResultSets: ParsedResultSets;
 }
 
+/**
+ * Message indicating that the results view should display interpreted
+ * results.
+ */
 export interface ShowInterpretedPageMsg {
   t: 'showInterpretedPage';
   interpretation: Interpretation;
@@ -121,7 +117,10 @@ export interface ShowInterpretedPageMsg {
   metadata?: QueryMetadata;
   pageNumber: number;
   numPages: number;
+  pageSize: number;
   resultSetNames: string[];
+  queryName: string;
+  queryPath: string;
 }
 
 /** Advance to the next or previous path no in the path viewer */
@@ -132,26 +131,59 @@ export interface NavigatePathMsg {
   direction: number;
 }
 
+/**
+ * A message indicating that the results view should untoggle the
+ * "Show results in Problems view" checkbox.
+ */
+export interface UntoggleShowProblemsMsg {
+  t: 'untoggleShowProblems';
+}
+
+/**
+ * A message sent into the results view.
+ */
 export type IntoResultsViewMsg =
   | ResultsUpdatingMsg
   | SetStateMsg
   | ShowInterpretedPageMsg
-  | NavigatePathMsg;
+  | NavigatePathMsg
+  | UntoggleShowProblemsMsg;
 
+/**
+ * A message sent from the results view.
+ */
 export type FromResultsViewMsg =
   | ViewSourceFileMsg
   | ToggleDiagnostics
   | ChangeRawResultsSortMsg
   | ChangeInterpretedResultsSortMsg
   | ResultViewLoaded
-  | ChangePage;
+  | ChangePage
+  | OpenFileMsg;
 
+/**
+ * Message from the results view to open a database source
+ * file at the provided location.
+ */
 export interface ViewSourceFileMsg {
   t: 'viewSourceFile';
   loc: ResolvableLocationValue;
   databaseUri: string;
 }
 
+/**
+ * Message from the results view to open a file in an editor.
+ */
+export interface OpenFileMsg {
+  t: 'openFile';
+  /* Full path to the file to open. */
+  filePath: string;
+}
+
+/**
+ * Message from the results view to toggle the display of
+ * query diagnostics.
+ */
 interface ToggleDiagnostics {
   t: 'toggleDiagnostics';
   databaseUri: string;
@@ -161,10 +193,18 @@ interface ToggleDiagnostics {
   kind?: string;
 }
 
+/**
+ * Message from the results view to signal that loading the results
+ * is complete.
+ */
 interface ResultViewLoaded {
   t: 'resultViewLoaded';
 }
 
+/**
+ * Message from the results view to signal a request to change the
+ * page.
+ */
 interface ChangePage {
   t: 'changePage';
   pageNumber: number; // 0-indexed, displayed to the user as 1-indexed
@@ -188,6 +228,9 @@ export interface InterpretedResultsSortState {
   sortDirection: SortDirection;
 }
 
+/**
+ * Message from the results view to request a sorting change.
+ */
 interface ChangeRawResultsSortMsg {
   t: 'changeSort';
   resultSetName: string;
@@ -198,6 +241,9 @@ interface ChangeRawResultsSortMsg {
   sortState?: RawResultsSortState;
 }
 
+/**
+ * Message from the results view to request a sorting change in interpreted results.
+ */
 interface ChangeInterpretedResultsSortMsg {
   t: 'changeInterpretedSort';
   /**
@@ -207,21 +253,33 @@ interface ChangeInterpretedResultsSortMsg {
   sortState?: InterpretedResultsSortState;
 }
 
+/**
+ * Message from the compare view to the extension.
+ */
 export type FromCompareViewMessage =
   | CompareViewLoadedMessage
   | ChangeCompareMessage
   | ViewSourceFileMsg
   | OpenQueryMessage;
 
+/**
+ * Message from the compare view to signal the completion of loading results.
+ */
 interface CompareViewLoadedMessage {
   t: 'compareViewLoaded';
 }
 
+/**
+ * Message from the compare view to request opening a query.
+ */
 export interface OpenQueryMessage {
   readonly t: 'openQuery';
   readonly kind: 'from' | 'to';
 }
 
+/**
+ * Message from the compare view to request changing the result set to compare.
+ */
 interface ChangeCompareMessage {
   t: 'changeCompare';
   newResultSetName: string;
@@ -229,6 +287,9 @@ interface ChangeCompareMessage {
 
 export type ToCompareViewMessage = SetComparisonsMessage;
 
+/**
+ * Message to the compare view that specifies the query results to compare.
+ */
 export interface SetComparisonsMessage {
   readonly t: 'setComparisons';
   readonly stats: {
@@ -243,7 +304,7 @@ export interface SetComparisonsMessage {
       time: string;
     };
   };
-  readonly columns: readonly ColumnSchema[];
+  readonly columns: readonly Column[];
   readonly commonResultSetNames: string[];
   readonly currentResultSetName: string;
   readonly rows: QueryCompareResult | undefined;
@@ -293,3 +354,13 @@ export function getDefaultResultSetName(
     resultSetNames[0],
   ].filter((resultSetName) => resultSetNames.includes(resultSetName))[0];
 }
+
+export interface ParsedResultSets {
+  pageNumber: number;
+  pageSize: number;
+  numPages: number;
+  numInterpretedPages: number;
+  selectedTable?: string; // when undefined, means 'show default table'
+  resultSetNames: string[];
+  resultSet: ResultSet;
+}

extensions/ql-vscode/src/pure/messages.ts

@@ -150,6 +150,11 @@ export interface CompilationOptions {
    * Whether to disable toString values in the results.
    */
   noComputeToString: boolean;
+  /**
+   * Whether to ensure that elements that do not have a displayString
+   * get reported anyway. Useful for universal compilation options.
+   */
+  computeDefaultStrings: boolean;
 }
 
 /**
@@ -380,8 +385,8 @@ export namespace ResultColumnKind {
    */
   export const BOOLEAN = 3;
   /**
- * A column of type `date`
- */
+   * A column of type `date`
+   */
   export const DATE = 4;
   /**
    * A column of a non-primitive type
@@ -401,6 +406,25 @@ export interface CompileUpgradeParams {
    * A directory to store parts of the compiled upgrade
    */
   upgradeTempDir: string;
+  /**
+   * Enable single file upgrades, set to true to allow
+   * using single file upgrades.
+   */
+  singleFileUpgrades: true;
+}
+
+/**
+ * Parameters for compiling an upgrade.
+ */
+export interface CompileUpgradeSequenceParams {
+  /**
+   * The sequence of upgrades to compile
+   */
+  upgradePaths: string[];
+  /**
+   * A directory to store parts of the compiled upgrade
+   */
+  upgradeTempDir: string;
 }
 
 /**
@@ -450,6 +474,19 @@ export interface CompileUpgradeResult {
    */
   error?: string;
 }
+
+export interface CompileUpgradeSequenceResult {
+  /**
+   * The compiled upgrades as a single file.
+   */
+  compiledUpgrade?: string;
+  /**
+   * Any errors that occurred when checking the scripts.
+   */
+  error?: string;
+}
+
+
 /**
  * A description of a upgrade process
  */
@@ -487,10 +524,13 @@ export interface UpgradeDescription {
   newSha: string;
 }
 
+
+export type CompiledUpgrades = MultiFileCompiledUpgrades | SingleFileCompiledUpgrades
+
 /**
- * A compiled upgrade.
+ * The parts shared by all compiled upgrades
  */
-export interface CompiledUpgrades {
+interface CompiledUpgradesBase {
   /**
   * The initial sha of the dbscheme to upgrade from
   */
@@ -499,14 +539,46 @@ export interface CompiledUpgrades {
    * The path to the new dataset statistics
    */
   newStatsPath: string;
+  /**
+   * The sha of the target dataset.
+   */
+  targetSha: string;
+}
+
+
+/**
+ * A compiled upgrade.
+ * The upgrade is spread among multiple files.
+ */
+interface MultiFileCompiledUpgrades extends CompiledUpgradesBase {
+  /**
+   * The path to the new dataset dbscheme
+   */
+  newDbscheme: string;
   /**
    * The steps in the upgrade path
    */
   scripts: CompiledUpgradeScript[];
   /**
-   * The sha of the target dataset.
+   * Will never exist in an old result
    */
-  targetSha: string;
+  compiledUpgradeFile?: never;
+}
+
+
+/**
+ * A compiled upgrade.
+ * The upgrade is in a single file.
+ */
+export interface SingleFileCompiledUpgrades extends CompiledUpgradesBase {
+  /**
+   * The steps in the upgrade path
+   */
+  descriptions: UpgradeDescription[];
+  /**
+   * A path to a file containing the upgrade
+   */
+  compiledUpgradeFile: string;
 }
 
 /**
@@ -651,6 +723,10 @@ export interface QueryToRun {
    * A uri pointing to the qlo to run.
    */
   qlo: string;
+  /**
+   * A uri pointing to the compiled upgrade file.
+   */
+  compiledUpgrade?: string;
   /**
    * The path where we should save this queries results
    */
@@ -837,7 +913,6 @@ export interface RunUpgradeParams {
   toRun: CompiledUpgrades;
 }
 
-
 /**
  * The result of running an upgrade
  */
@@ -857,6 +932,21 @@ export interface RunUpgradeResult {
   finalSha: string;
 }
 
+export interface RegisterDatabasesParams {
+  databases: Dataset[];
+}
+
+export interface DeregisterDatabasesParams {
+  databases: Dataset[];
+}
+
+export type RegisterDatabasesResult = {
+  registeredDatabases: Dataset[];
+};
+
+export type DeregisterDatabasesResult = {
+  registeredDatabases: Dataset[];
+};
 
 /**
  * Type for any action that could have progress messages.
@@ -913,7 +1003,10 @@ export const checkUpgrade = new rpc.RequestType<WithProgressId<UpgradeParams>, C
  * Compile an upgrade script to upgrade a dataset.
  */
 export const compileUpgrade = new rpc.RequestType<WithProgressId<CompileUpgradeParams>, CompileUpgradeResult, void, void>('compilation/compileUpgrade');
-
+/**
+ * Compile an upgrade script to upgrade a dataset.
+ */
+export const compileUpgradeSequence = new rpc.RequestType<WithProgressId<CompileUpgradeSequenceParams>, CompileUpgradeSequenceResult, void, void>('compilation/compileUpgradeSequence');
 
 /**
  * Clear the cache of a dataset
@@ -934,6 +1027,20 @@ export const runQueries = new rpc.RequestType<WithProgressId<EvaluateQueriesPara
  */
 export const runUpgrade = new rpc.RequestType<WithProgressId<RunUpgradeParams>, RunUpgradeResult, void, void>('evaluation/runUpgrade');
 
+export const registerDatabases = new rpc.RequestType<
+  WithProgressId<RegisterDatabasesParams>,
+  RegisterDatabasesResult,
+  void,
+  void
+>('evaluation/registerDatabases');
+
+export const deregisterDatabases = new rpc.RequestType<
+  WithProgressId<DeregisterDatabasesParams>,
+  DeregisterDatabasesResult,
+  void,
+  void
+>('evaluation/deregisterDatabases');
+
 /**
  * Request returned to the client to notify completion of a query.
  * The full runQueries job is completed when all queries are acknowledged.

extensions/ql-vscode/src/pure/sarif-utils.ts

@@ -1,21 +1,28 @@
 import * as Sarif from 'sarif';
-import * as path from 'path';
-import { LocationStyle, ResolvableLocationValue } from './bqrs-types';
+import { ResolvableLocationValue } from './bqrs-cli-types';
 
 export interface SarifLink {
   dest: number;
   text: string;
 }
 
+// The type of a result that has no associated location.
+// hint is a string intended for display to the user
+// that explains why there is no location.
+interface NoLocation {
+  hint: string;
+}
 
 type ParsedSarifLocation =
-  | ResolvableLocationValue
-  // Resolvable locations have a `file` field, but it will sometimes include
+  | (ResolvableLocationValue & {
+
+    userVisibleFile: string;
+  })
+  // Resolvable locations have a `uri` field, but it will sometimes include
   // a source location prefix, which contains build-specific information the user
   // doesn't really need to see. We ensure that `userVisibleFile` will not contain
   // that, and is appropriate for display in the UI.
-  & { userVisibleFile: string }
-  | { t: 'NoLocation'; hint: string };
+  | NoLocation;
 
 export type SarifMessageComponent = string | SarifLink
 
@@ -23,7 +30,10 @@ export type SarifMessageComponent = string | SarifLink
  * Unescape "[", "]" and "\\" like in sarif plain text messages
  */
 export function unescapeSarifText(message: string): string {
-  return message.replace(/\\\[/g, '[').replace(/\\\]/g, ']').replace(/\\\\/, '\\');
+  return message
+    .replace(/\\\[/g, '[')
+    .replace(/\\\]/g, ']')
+    .replace(/\\\\/g, '\\');
 }
 
 export function parseSarifPlainTextMessage(message: string): SarifMessageComponent[] {
@@ -54,71 +64,98 @@ export function parseSarifPlainTextMessage(message: string): SarifMessageCompone
  * @param sourceLocationPrefix The source location prefix of a database. May be
  * unix style `/foo/bar/baz` or windows-style `C:\foo\bar\baz`.
  * @param sarifRelativeUri A uri relative to sourceLocationPrefix.
- * @returns A string that is valid for the `.file` field of a `FivePartLocation`:
+ *
+ * @returns A URI string that is valid for the `.file` field of a `FivePartLocation`:
  * directory separators are normalized, but drive letters `C:` may appear.
  */
-export function getPathRelativeToSourceLocationPrefix(sourceLocationPrefix: string, sarifRelativeUui: string) {
-  const normalizedSourceLocationPrefix = sourceLocationPrefix.replace(/\\/g, '/');
-  return path.join(normalizedSourceLocationPrefix, decodeURIComponent(sarifRelativeUui));
+export function getPathRelativeToSourceLocationPrefix(
+  sourceLocationPrefix: string,
+  sarifRelativeUri: string
+) {
+  // convert a platform specific path into encoded path uri segments
+  // need to be careful about drive letters and ensure that there
+  // is a starting '/'
+  let prefix = '';
+  if (sourceLocationPrefix[1] === ':') {
+    // assume this is a windows drive separator
+    prefix = sourceLocationPrefix.substring(0, 2);
+    sourceLocationPrefix = sourceLocationPrefix.substring(2);
+  }
+  const normalizedSourceLocationPrefix = prefix + sourceLocationPrefix.replace(/\\/g, '/')
+    .split('/')
+    .map(encodeURIComponent)
+    .join('/');
+  const slashPrefix = normalizedSourceLocationPrefix.startsWith('/') ? '' : '/';
+  return `file:${slashPrefix + normalizedSourceLocationPrefix}/${sarifRelativeUri}`;
 }
 
-export function parseSarifLocation(loc: Sarif.Location, sourceLocationPrefix: string): ParsedSarifLocation {
+/**
+ *
+ * @param loc specifies the database-relative location of the source location
+ * @param sourceLocationPrefix a file path (usually a full path) to the database containing the source location.
+ */
+export function parseSarifLocation(
+  loc: Sarif.Location,
+  sourceLocationPrefix: string
+): ParsedSarifLocation {
   const physicalLocation = loc.physicalLocation;
   if (physicalLocation === undefined)
-    return { t: 'NoLocation', hint: 'no physical location' };
+    return { hint: 'no physical location' };
   if (physicalLocation.artifactLocation === undefined)
-    return { t: 'NoLocation', hint: 'no artifact location' };
+    return { hint: 'no artifact location' };
   if (physicalLocation.artifactLocation.uri === undefined)
-    return { t: 'NoLocation', hint: 'artifact location has no uri' };
+    return { hint: 'artifact location has no uri' };
 
   // This is not necessarily really an absolute uri; it could either be a
   // file uri or a relative uri.
   const uri = physicalLocation.artifactLocation.uri;
 
   const fileUriRegex = /^file:/;
-  const effectiveLocation = uri.match(fileUriRegex) ?
-    decodeURIComponent(uri.replace(fileUriRegex, '')) :
-    getPathRelativeToSourceLocationPrefix(sourceLocationPrefix, uri);
-  const userVisibleFile = uri.match(fileUriRegex) ?
-    decodeURIComponent(uri.replace(fileUriRegex, '')) :
-    uri;
+  const hasFilePrefix = uri.match(fileUriRegex);
+  const effectiveLocation = hasFilePrefix
+    ? uri
+    : getPathRelativeToSourceLocationPrefix(sourceLocationPrefix, uri);
+  const userVisibleFile = decodeURIComponent(hasFilePrefix
+    ? uri.replace(fileUriRegex, '')
+    : uri);
 
   if (physicalLocation.region === undefined) {
     // If the region property is absent, the physicalLocation object refers to the entire file.
     // Source: https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Toc16012638.
-    // TODO: Do we get here if we provide a non-filesystem URL?
     return {
-      t: LocationStyle.WholeFile,
-      file: effectiveLocation,
-      userVisibleFile,
-    };
+      uri: effectiveLocation,
+      userVisibleFile
+    } as ParsedSarifLocation;
   } else {
     const region = physicalLocation.region;
     // We assume that the SARIF we're given always has startLine
     // This is not mandated by the SARIF spec, but should be true of
     // SARIF output by our own tools.
-    const lineStart = region.startLine!;
+    const startLine = region.startLine!;
 
     // These defaults are from SARIF 2.1.0 spec, section 3.30.2, "Text Regions"
     // https://docs.oasis-open.org/sarif/sarif/v2.1.0/cs01/sarif-v2.1.0-cs01.html#_Ref493492556
-    const lineEnd = region.endLine === undefined ? lineStart : region.endLine;
-    const colStart = region.startColumn === undefined ? 1 : region.startColumn;
+    const endLine = region.endLine === undefined ? startLine : region.endLine;
+    const startColumn = region.startColumn === undefined ? 1 : region.startColumn;
 
     // We also assume that our tools will always supply `endColumn` field, which is
     // fortunate, since the SARIF spec says that it defaults to the end of the line, whose
     // length we don't know at this point in the code.
     //
     // It is off by one with respect to the way vscode counts columns in selections.
-    const colEnd = region.endColumn! - 1;
+    const endColumn = region.endColumn! - 1;
 
     return {
-      t: LocationStyle.FivePart,
-      file: effectiveLocation,
+      uri: effectiveLocation,
       userVisibleFile,
-      lineStart,
-      colStart,
-      lineEnd,
-      colEnd,
+      startLine,
+      startColumn,
+      endLine,
+      endColumn,
     };
   }
 }
+
+export function isNoLocation(loc: ParsedSarifLocation): loc is NoLocation {
+  return 'hint' in loc;
+}

extensions/ql-vscode/src/qlpack-discovery.ts

@@ -1,58 +0,0 @@
-import { EventEmitter, Event, Uri, WorkspaceFolder, RelativePattern } from 'vscode';
-import { MultiFileSystemWatcher } from './vscode-utils/multi-file-system-watcher';
-import { CodeQLCliServer, QlpacksInfo } from './cli';
-import { Discovery } from './discovery';
-
-export interface QLPack {
-  name: string;
-  uri: Uri;
-}
-
-/**
- * Service to discover all available QL packs in a workspace folder.
- */
-export class QLPackDiscovery extends Discovery<QlpacksInfo> {
-  private readonly _onDidChangeQLPacks = this.push(new EventEmitter<void>());
-  private readonly watcher = this.push(new MultiFileSystemWatcher());
-  private _qlPacks: readonly QLPack[] = [];
-
-  constructor(
-    private readonly workspaceFolder: WorkspaceFolder,
-    private readonly cliServer: CodeQLCliServer
-  ) {
-    super('QL Pack Discovery');
-
-    // Watch for any changes to `qlpack.yml` files in this workspace folder.
-    // TODO: The CLI server should tell us what paths to watch for.
-    this.watcher.addWatch(new RelativePattern(this.workspaceFolder, '**/qlpack.yml'));
-    this.watcher.addWatch(new RelativePattern(this.workspaceFolder, '**/.codeqlmanifest.json'));
-    this.push(this.watcher.onDidChange(this.handleQLPackFileChanged, this));
-  }
-
-  public get onDidChangeQLPacks(): Event<void> { return this._onDidChangeQLPacks.event; }
-
-  public get qlPacks(): readonly QLPack[] { return this._qlPacks; }
-
-  private handleQLPackFileChanged(_uri: Uri): void {
-    this.refresh();
-  }
-
-  protected discover(): Promise<QlpacksInfo> {
-    // Only look for QL packs in this workspace folder.
-    return this.cliServer.resolveQlpacks([this.workspaceFolder.uri.fsPath], []);
-  }
-
-  protected update(results: QlpacksInfo): void {
-    const qlPacks: QLPack[] = [];
-    for (const id in results) {
-      qlPacks.push(...results[id].map(fsPath => {
-        return {
-          name: id,
-          uri: Uri.file(fsPath)
-        };
-      }));
-    }
-    this._qlPacks = qlPacks;
-    this._onDidChangeQLPacks.fire();
-  }
-}

extensions/ql-vscode/src/qltest-discovery.ts

@@ -1,9 +1,9 @@
 import * as path from 'path';
-import { QLPackDiscovery, QLPack } from './qlpack-discovery';
 import { Discovery } from './discovery';
-import { EventEmitter, Event, Uri, RelativePattern, WorkspaceFolder, env, workspace } from 'vscode';
+import { EventEmitter, Event, Uri, RelativePattern, WorkspaceFolder, env } from 'vscode';
 import { MultiFileSystemWatcher } from './vscode-utils/multi-file-system-watcher';
 import { CodeQLCliServer } from './cli';
+import * as fs from 'fs-extra';
 
 /**
  * A node in the tree of tests. This will be either a `QLTestDirectory` or a `QLTestFile`.
@@ -29,9 +29,8 @@ export abstract class QLTestNode {
  * A directory containing one or more QL tests or other test directories.
  */
 export class QLTestDirectory extends QLTestNode {
-  private _children: QLTestNode[] = [];
 
-  constructor(_path: string, _name: string) {
+  constructor(_path: string, _name: string, private _children: QLTestNode[] = []) {
     super(_path, _name);
   }
 
@@ -55,10 +54,23 @@ export class QLTestDirectory extends QLTestNode {
   }
 
   public finish(): void {
+    // remove empty directories
+    this._children.filter(child =>
+      child instanceof QLTestFile || child.children.length > 0
+    );
     this._children.sort((a, b) => a.name.localeCompare(b.name, env.language));
-    for (const child of this._children) {
+    this._children.forEach((child, i) => {
       child.finish();
-    }
+      if (child.children?.length === 1 && child.children[0] instanceof QLTestDirectory) {
+        // collapse children
+        const replacement = new QLTestDirectory(
+          child.children[0].path,
+          child.name + ' / ' + child.children[0].name,
+          Array.from(child.children[0].children)
+        );
+        this._children[i] = replacement;
+      }
+    });
   }
 
   private createChildDirectory(name: string): QLTestDirectory {
@@ -96,14 +108,15 @@ export class QLTestFile extends QLTestNode {
  */
 interface QLTestDiscoveryResults {
   /**
-   * The root test directory for each QL pack that contains tests.
+   * A directory that contains one or more QL Tests, or other QLTestDirectories.
    */
-  testDirectories: QLTestDirectory[];
+  testDirectory: QLTestDirectory | undefined;
+
   /**
-   * The list of file system paths to watch. If any of these paths changes, the discovery results
-   * may be out of date.
+   * The file system path to a directory to watch. If any ql or qlref file changes in
+   * this directory, then this signifies a change in tests.
    */
-  watchPaths: string[];
+  watchPath: string;
 }
 
 /**
@@ -112,31 +125,30 @@ interface QLTestDiscoveryResults {
 export class QLTestDiscovery extends Discovery<QLTestDiscoveryResults> {
   private readonly _onDidChangeTests = this.push(new EventEmitter<void>());
   private readonly watcher: MultiFileSystemWatcher = this.push(new MultiFileSystemWatcher());
-  private _testDirectories: QLTestDirectory[] = [];
+  private _testDirectory: QLTestDirectory | undefined;
 
   constructor(
-    private readonly qlPackDiscovery: QLPackDiscovery,
     private readonly workspaceFolder: WorkspaceFolder,
     private readonly cliServer: CodeQLCliServer
   ) {
     super('QL Test Discovery');
 
-    this.push(this.qlPackDiscovery.onDidChangeQLPacks(this.handleDidChangeQLPacks, this));
     this.push(this.watcher.onDidChange(this.handleDidChange, this));
   }
 
   /**
    * Event to be fired when the set of discovered tests may have changed.
    */
-  public get onDidChangeTests(): Event<void> { return this._onDidChangeTests.event; }
+  public get onDidChangeTests(): Event<void> {
+    return this._onDidChangeTests.event;
+  }
 
   /**
-   * The root test directory for each QL pack that contains tests.
+   * The root directory. There is at least one test in this directory, or
+   * in a subdirectory of this.
    */
-  public get testDirectories(): QLTestDirectory[] { return this._testDirectories; }
-
-  private handleDidChangeQLPacks(): void {
-    this.refresh();
+  public get testDirectory(): QLTestDirectory | undefined {
+    return this._testDirectory;
   }
 
   private handleDidChange(uri: Uri): void {
@@ -144,61 +156,37 @@ export class QLTestDiscovery extends Discovery<QLTestDiscoveryResults> {
       this.refresh();
     }
   }
-
   protected async discover(): Promise<QLTestDiscoveryResults> {
-    const testDirectories: QLTestDirectory[] = [];
-    const watchPaths: string[] = [];
-    const qlPacks = this.qlPackDiscovery.qlPacks;
-    for (const qlPack of qlPacks) {
-      //HACK: Assume that only QL packs whose name ends with '-tests' contain tests.
-      if (this.isRelevantQlPack(qlPack)) {
-        watchPaths.push(qlPack.uri.fsPath);
-        const testPackage = await this.discoverTests(qlPack.uri.fsPath, qlPack.name);
-        if (testPackage !== undefined) {
-          testDirectories.push(testPackage);
-        }
-      }
-    }
-
-    return { testDirectories, watchPaths };
+    const testDirectory = await this.discoverTests();
+    return {
+      testDirectory,
+      watchPath: this.workspaceFolder.uri.fsPath
+    };
   }
 
   protected update(results: QLTestDiscoveryResults): void {
-    this._testDirectories = results.testDirectories;
+    this._testDirectory = results.testDirectory;
 
     // Watch for changes to any `.ql` or `.qlref` file in any of the QL packs that contain tests.
     this.watcher.clear();
-    results.watchPaths.forEach(watchPath => {
-      this.watcher.addWatch(new RelativePattern(watchPath, '**/*.{ql,qlref}'));
-    });
+    this.watcher.addWatch(new RelativePattern(results.watchPath, '**/*.{ql,qlref}'));
     this._onDidChangeTests.fire();
   }
 
-  /**
-   * Only include qlpacks suffixed with '-tests' that are contained
-   * within the provided workspace folder.
-   */
-  private isRelevantQlPack(qlPack: QLPack): boolean {
-    return qlPack.name.endsWith('-tests')
-      && workspace.getWorkspaceFolder(qlPack.uri)?.index === this.workspaceFolder.index;
-  }
-
   /**
    * Discover all QL tests in the specified directory and its subdirectories.
-   * @param fullPath The full path of the test directory.
-   * @param name The display name to use for the returned `TestDirectory` object.
    * @returns A `QLTestDirectory` object describing the contents of the directory, or `undefined` if
    *   no tests were found.
    */
-  private async discoverTests(fullPath: string, name: string): Promise<QLTestDirectory | undefined> {
-    const resolvedTests = (await this.cliServer.resolveTests(fullPath))
-      .filter((testPath) => !QLTestDiscovery.ignoreTestPath(testPath));
+  private async discoverTests(): Promise<QLTestDirectory> {
+    const fullPath = this.workspaceFolder.uri.fsPath;
+    const name = this.workspaceFolder.name;
+    const rootDirectory = new QLTestDirectory(fullPath, name);
 
-    if (resolvedTests.length === 0) {
-      return undefined;
-    }
-    else {
-      const rootDirectory = new QLTestDirectory(fullPath, name);
+    // Don't try discovery on workspace folders that don't exist on the filesystem
+    if ((await fs.pathExists(fullPath))) {
+      const resolvedTests = (await this.cliServer.resolveTests(fullPath))
+        .filter((testPath) => !QLTestDiscovery.ignoreTestPath(testPath));
       for (const testPath of resolvedTests) {
         const relativePath = path.normalize(path.relative(fullPath, testPath));
         const dirName = path.dirname(relativePath);
@@ -207,9 +195,8 @@ export class QLTestDiscovery extends Discovery<QLTestDiscoveryResults> {
       }
 
       rootDirectory.finish();
-
-      return rootDirectory;
     }
+    return rootDirectory;
   }
 
   /**

extensions/ql-vscode/src/query-history.ts

@@ -1,12 +1,21 @@
 import * as path from 'path';
 import * as vscode from 'vscode';
-import { ExtensionContext, window as Window } from 'vscode';
+import { window as Window, env } from 'vscode';
 import { CompletedQuery } from './query-results';
 import { QueryHistoryConfig } from './config';
 import { QueryWithResults } from './run-queries';
-import * as helpers from './helpers';
+import {
+  showAndLogErrorMessage,
+  showAndLogInformationMessage,
+  showAndLogWarningMessage,
+  showBinaryChoiceDialog
+} from './helpers';
 import { logger } from './logging';
 import { URLSearchParams } from 'url';
+import { QueryServerClient } from './queryserver-client';
+import { DisposableObject } from './pure/disposable-object';
+import { commandRunner } from './commandRunner';
+import { assertNever } from './pure/helpers-pure';
 
 /**
  * query-history.ts
@@ -50,36 +59,47 @@ const SHOW_QUERY_TEXT_QUICK_EVAL_MSG = `\
  */
 const FAILED_QUERY_HISTORY_ITEM_ICON = 'media/red-x.svg';
 
+enum SortOrder {
+  NameAsc = 'NameAsc',
+  NameDesc = 'NameDesc',
+  DateAsc = 'DateAsc',
+  DateDesc = 'DateDesc',
+  CountAsc = 'CountAsc',
+  CountDesc = 'CountDesc',
+}
+
 /**
  * Tree data provider for the query history view.
  */
-class HistoryTreeDataProvider
-  implements vscode.TreeDataProvider<CompletedQuery> {
-  /**
-   * XXX: This idiom for how to get a `.fire()`-able event emitter was
-   * cargo culted from another vscode extension. It seems rather
-   * involved and I hope there's something better that can be done
-   * instead.
-   */
-  private _onDidChangeTreeData: vscode.EventEmitter<
-    CompletedQuery | undefined
-  > = new vscode.EventEmitter<CompletedQuery | undefined>();
+export class HistoryTreeDataProvider extends DisposableObject {
+  private _sortOrder = SortOrder.DateAsc;
+
+  private _onDidChangeTreeData = super.push(new vscode.EventEmitter<CompletedQuery | undefined>());
+
   readonly onDidChangeTreeData: vscode.Event<CompletedQuery | undefined> = this
     ._onDidChangeTreeData.event;
 
   private history: CompletedQuery[] = [];
 
+  private failedIconPath: string;
+
   /**
    * When not undefined, must be reference-equal to an item in `this.databases`.
    */
   private current: CompletedQuery | undefined;
 
-  constructor(private ctx: ExtensionContext) { }
+  constructor(extensionPath: string) {
+    super();
+    this.failedIconPath = path.join(
+      extensionPath,
+      FAILED_QUERY_HISTORY_ITEM_ICON
+    );
+  }
 
   async getTreeItem(element: CompletedQuery): Promise<vscode.TreeItem> {
-    const it = new vscode.TreeItem(element.toString());
+    const treeItem = new vscode.TreeItem(element.toString());
 
-    it.command = {
+    treeItem.command = {
       title: 'Query History Item',
       command: 'codeQLQueryHistory.itemClicked',
       arguments: [element],
@@ -88,24 +108,39 @@ class HistoryTreeDataProvider
     // Mark this query history item according to whether it has a
     // SARIF file so that we can make context menu items conditionally
     // available.
-    it.contextValue = (await element.query.hasInterpretedResults())
+    const hasResults = await element.query.hasInterpretedResults();
+    treeItem.contextValue = hasResults
       ? 'interpretedResultsItem'
       : 'rawResultsItem';
 
     if (!element.didRunSuccessfully) {
-      it.iconPath = path.join(
-        this.ctx.extensionPath,
-        FAILED_QUERY_HISTORY_ITEM_ICON
-      );
+      treeItem.iconPath = this.failedIconPath;
     }
 
-    return it;
+    return treeItem;
   }
 
   getChildren(
     element?: CompletedQuery
   ): vscode.ProviderResult<CompletedQuery[]> {
-    return element ? [] : this.history;
+    return element ? [] : this.history.sort((q1, q2) => {
+      switch (this.sortOrder) {
+        case SortOrder.NameAsc:
+          return q1.toString().localeCompare(q2.toString(), env.language);
+        case SortOrder.NameDesc:
+          return q2.toString().localeCompare(q1.toString(), env.language);
+        case SortOrder.DateAsc:
+          return q1.date.getTime() - q2.date.getTime();
+        case SortOrder.DateDesc:
+          return q2.date.getTime() - q1.date.getTime();
+        case SortOrder.CountAsc:
+          return q1.resultCount - q2.resultCount;
+        case SortOrder.CountDesc:
+          return q2.resultCount - q1.resultCount;
+        default:
+          assertNever(this.sortOrder);
+      }
+    });
   }
 
   getParent(_element: CompletedQuery): vscode.ProviderResult<CompletedQuery> {
@@ -116,7 +151,7 @@ class HistoryTreeDataProvider
     return this.current;
   }
 
-  push(item: CompletedQuery): void {
+  pushQuery(item: CompletedQuery): void {
     this.current = item;
     this.history.push(item);
     this.refresh();
@@ -144,13 +179,22 @@ class HistoryTreeDataProvider
     return this.history;
   }
 
-  refresh() {
-    this._onDidChangeTreeData.fire(undefined);
+  refresh(completedQuery?: CompletedQuery) {
+    this._onDidChangeTreeData.fire(completedQuery);
   }
 
   find(queryId: number): CompletedQuery | undefined {
     return this.allHistory.find((query) => query.query.queryID === queryId);
   }
+
+  public get sortOrder() {
+    return this._sortOrder;
+  }
+
+  public set sortOrder(newSortOrder: SortOrder) {
+    this._sortOrder = newSortOrder;
+    this._onDidChangeTreeData.fire();
+  }
 }
 
 /**
@@ -159,14 +203,16 @@ class HistoryTreeDataProvider
  */
 const DOUBLE_CLICK_TIME = 500;
 
-export class QueryHistoryManager {
+const NO_QUERY_SELECTED = 'No query selected. Select a query history item you have already run and try again.';
+export class QueryHistoryManager extends DisposableObject {
   treeDataProvider: HistoryTreeDataProvider;
   treeView: vscode.TreeView<CompletedQuery>;
   lastItemClick: { time: Date; item: CompletedQuery } | undefined;
   compareWithItem: CompletedQuery | undefined;
 
   constructor(
-    ctx: ExtensionContext,
+    private qs: QueryServerClient,
+    extensionPath: string,
     private queryHistoryConfigListener: QueryHistoryConfig,
     private selectedCallback: (item: CompletedQuery) => Promise<void>,
     private doCompareCallback: (
@@ -174,78 +220,117 @@ export class QueryHistoryManager {
       to: CompletedQuery
     ) => Promise<void>
   ) {
+    super();
+
     const treeDataProvider = (this.treeDataProvider = new HistoryTreeDataProvider(
-      ctx
+      extensionPath
     ));
     this.treeView = Window.createTreeView('codeQLQueryHistory', {
       treeDataProvider,
       canSelectMany: true,
     });
+    this.push(this.treeView);
+    this.push(treeDataProvider);
 
     // Lazily update the tree view selection due to limitations of TreeView API (see
     // `updateTreeViewSelectionIfVisible` doc for details)
-    this.treeView.onDidChangeVisibility(async (_ev) =>
-      this.updateTreeViewSelectionIfVisible()
+    this.push(
+      this.treeView.onDidChangeVisibility(async (_ev) =>
+        this.updateTreeViewSelectionIfVisible()
+      )
     );
     // Don't allow the selection to become empty
-    this.treeView.onDidChangeSelection(async (ev) => {
-      if (ev.selection.length == 0) {
-        this.updateTreeViewSelectionIfVisible();
-      }
-      this.updateCompareWith(ev.selection);
-    });
+    this.push(
+      this.treeView.onDidChangeSelection(async (ev) => {
+        if (ev.selection.length == 0) {
+          this.updateTreeViewSelectionIfVisible();
+        }
+        this.updateCompareWith(ev.selection);
+      })
+    );
+
     logger.log('Registering query history panel commands.');
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.openQuery',
         this.handleOpenQuery.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.removeHistoryItem',
         this.handleRemoveHistoryItem.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.sortByName',
+        this.handleSortByName.bind(this)
+      )
+    );
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.sortByDate',
+        this.handleSortByDate.bind(this)
+      )
+    );
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.sortByCount',
+        this.handleSortByCount.bind(this)
+      )
+    );
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.setLabel',
         this.handleSetLabel.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.compareWith',
         this.handleCompareWith.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.showQueryLog',
         this.handleShowQueryLog.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.showQueryText',
         this.handleShowQueryText.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
-        'codeQLQueryHistory.viewSarif',
-        this.handleViewSarif.bind(this)
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.viewCsvResults',
+        this.handleViewCsvResults.bind(this)
       )
     );
-    ctx.subscriptions.push(
-      vscode.commands.registerCommand(
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.viewSarifResults',
+        this.handleViewSarifResults.bind(this)
+      )
+    );
+    this.push(
+      commandRunner(
+        'codeQLQueryHistory.viewDil',
+        this.handleViewDil.bind(this)
+      )
+    );
+    this.push(
+      commandRunner(
         'codeQLQueryHistory.itemClicked',
-        async (item) => {
+        async (item: CompletedQuery) => {
           return this.handleItemClicked(item, [item]);
         }
       )
     );
-    queryHistoryConfigListener.onDidChangeQueryHistoryConfiguration(() => {
+    queryHistoryConfigListener.onDidChangeConfiguration(() => {
       this.treeDataProvider.refresh();
     });
 
@@ -276,19 +361,24 @@ export class QueryHistoryManager {
     singleItem: CompletedQuery,
     multiSelect: CompletedQuery[]
   ): Promise<void> {
-    if (!this.assertSingleQuery(multiSelect)) {
+    const { finalSingleItem, finalMultiSelect } = this.determineSelection(singleItem, multiSelect);
+    if (!this.assertSingleQuery(finalMultiSelect)) {
       return;
     }
 
+    if (!finalSingleItem) {
+      throw new Error(NO_QUERY_SELECTED);
+    }
+
     const textDocument = await vscode.workspace.openTextDocument(
-      vscode.Uri.file(singleItem.query.program.queryPath)
+      vscode.Uri.file(finalSingleItem.query.program.queryPath)
     );
     const editor = await vscode.window.showTextDocument(
       textDocument,
       vscode.ViewColumn.One
     );
-    const queryText = singleItem.options.queryText;
-    if (queryText !== undefined && singleItem.options.isQuickQuery) {
+    const queryText = finalSingleItem.options.queryText;
+    if (queryText !== undefined && finalSingleItem.options.isQuickQuery) {
       await editor.edit((edit) =>
         edit.replace(
           textDocument.validateRange(
@@ -304,7 +394,9 @@ export class QueryHistoryManager {
     singleItem: CompletedQuery,
     multiSelect: CompletedQuery[]
   ) {
-    (multiSelect || [singleItem]).forEach((item) => {
+    const { finalSingleItem, finalMultiSelect } = this.determineSelection(singleItem, multiSelect);
+
+    (finalMultiSelect || [finalSingleItem]).forEach((item) => {
       this.treeDataProvider.remove(item);
       item.dispose();
     });
@@ -315,6 +407,30 @@ export class QueryHistoryManager {
     }
   }
 
+  async handleSortByName() {
+    if (this.treeDataProvider.sortOrder === SortOrder.NameAsc) {
+      this.treeDataProvider.sortOrder = SortOrder.NameDesc;
+    } else {
+      this.treeDataProvider.sortOrder = SortOrder.NameAsc;
+    }
+  }
+
+  async handleSortByDate() {
+    if (this.treeDataProvider.sortOrder === SortOrder.DateAsc) {
+      this.treeDataProvider.sortOrder = SortOrder.DateDesc;
+    } else {
+      this.treeDataProvider.sortOrder = SortOrder.DateAsc;
+    }
+  }
+
+  async handleSortByCount() {
+    if (this.treeDataProvider.sortOrder === SortOrder.CountAsc) {
+      this.treeDataProvider.sortOrder = SortOrder.CountDesc;
+    } else {
+      this.treeDataProvider.sortOrder = SortOrder.CountAsc;
+    }
+  }
+
   async handleSetLabel(
     singleItem: CompletedQuery,
     multiSelect: CompletedQuery[]
@@ -330,11 +446,14 @@ export class QueryHistoryManager {
     });
     // undefined response means the user cancelled the dialog; don't change anything
     if (response !== undefined) {
-      if (response === '')
-        // Interpret empty string response as 'go back to using default'
-        singleItem.options.label = undefined;
-      else singleItem.options.label = response;
-      this.treeDataProvider.refresh();
+      // Interpret empty string response as 'go back to using default'
+      singleItem.options.label = response === '' ? undefined : response;
+      if (this.treeDataProvider.sortOrder === SortOrder.NameAsc ||
+        this.treeDataProvider.sortOrder === SortOrder.NameDesc) {
+        this.treeDataProvider.refresh();
+      } else {
+        this.treeDataProvider.refresh(singleItem);
+      }
     }
   }
 
@@ -354,7 +473,7 @@ export class QueryHistoryManager {
         this.doCompareCallback(from, to);
       }
     } catch (e) {
-      helpers.showAndLogErrorMessage(e.message);
+      showAndLogErrorMessage(e.message);
     }
   }
 
@@ -362,14 +481,20 @@ export class QueryHistoryManager {
     singleItem: CompletedQuery,
     multiSelect: CompletedQuery[]
   ) {
-    if (!this.assertSingleQuery(multiSelect)) {
+    const { finalSingleItem, finalMultiSelect } = this.determineSelection(singleItem, multiSelect);
+    if (!this.assertSingleQuery(finalMultiSelect)) {
       return;
     }
-    this.treeDataProvider.setCurrentItem(singleItem);
+
+    if (!finalSingleItem) {
+      throw new Error(NO_QUERY_SELECTED);
+    }
+
+    this.treeDataProvider.setCurrentItem(finalSingleItem);
 
     const now = new Date();
     const prevItemClick = this.lastItemClick;
-    this.lastItemClick = { time: now, item: singleItem };
+    this.lastItemClick = { time: now, item: finalSingleItem };
 
     if (
       prevItemClick !== undefined &&
@@ -395,7 +520,7 @@ export class QueryHistoryManager {
     if (singleItem.logFileLocation) {
       await this.tryOpenExternalFile(singleItem.logFileLocation);
     } else {
-      helpers.showAndLogWarningMessage('No log file available');
+      showAndLogWarningMessage('No log file available');
     }
   }
 
@@ -407,25 +532,25 @@ export class QueryHistoryManager {
       return;
     }
 
-    try {
-      const queryName = singleItem.queryName.endsWith('.ql')
-        ? singleItem.queryName
-        : singleItem.queryName + '.ql';
-      const params = new URLSearchParams({
-        isQuickEval: String(!!singleItem.query.quickEvalPosition),
-        queryText: encodeURIComponent(await this.getQueryText(singleItem)),
-      });
-      const uri = vscode.Uri.parse(
-        `codeql:${singleItem.query.queryID}-${queryName}?${params.toString()}`
-      );
-      const doc = await vscode.workspace.openTextDocument(uri);
-      await vscode.window.showTextDocument(doc, { preview: false });
-    } catch (e) {
-      helpers.showAndLogErrorMessage(e.message);
+    if (!singleItem) {
+      throw new Error(NO_QUERY_SELECTED);
     }
+
+    const queryName = singleItem.queryName.endsWith('.ql')
+      ? singleItem.queryName
+      : singleItem.queryName + '.ql';
+    const params = new URLSearchParams({
+      isQuickEval: String(!!singleItem.query.quickEvalPosition),
+      queryText: encodeURIComponent(await this.getQueryText(singleItem)),
+    });
+    const uri = vscode.Uri.parse(
+      `codeql:${singleItem.query.queryID}-${queryName}?${params.toString()}`, true
+    );
+    const doc = await vscode.workspace.openTextDocument(uri);
+    await vscode.window.showTextDocument(doc, { preview: false });
   }
 
-  async handleViewSarif(
+  async handleViewSarifResults(
     singleItem: CompletedQuery,
     multiSelect: CompletedQuery[]
   ) {
@@ -433,23 +558,45 @@ export class QueryHistoryManager {
       return;
     }
 
-    try {
-      const hasInterpretedResults = await singleItem.query.canHaveInterpretedResults();
-      if (hasInterpretedResults) {
-        await this.tryOpenExternalFile(
-          singleItem.query.resultsPaths.interpretedResultsPath
-        );
-      } else {
-        const label = singleItem.getLabel();
-        helpers.showAndLogInformationMessage(
-          `Query ${label} has no interpreted results.`
-        );
-      }
-    } catch (e) {
-      helpers.showAndLogErrorMessage(e.message);
+    const hasInterpretedResults = await singleItem.query.canHaveInterpretedResults();
+    if (hasInterpretedResults) {
+      await this.tryOpenExternalFile(
+        singleItem.query.resultsPaths.interpretedResultsPath
+      );
+    } else {
+      const label = singleItem.getLabel();
+      showAndLogInformationMessage(
+        `Query ${label} has no interpreted results.`
+      );
     }
   }
 
+  async handleViewCsvResults(
+    singleItem: CompletedQuery,
+    multiSelect: CompletedQuery[]
+  ) {
+    if (!this.assertSingleQuery(multiSelect)) {
+      return;
+    }
+
+    await this.tryOpenExternalFile(
+      await singleItem.query.ensureCsvProduced(this.qs)
+    );
+  }
+
+  async handleViewDil(
+    singleItem: CompletedQuery,
+    multiSelect: CompletedQuery[],
+  ) {
+    if (!this.assertSingleQuery(multiSelect)) {
+      return;
+    }
+
+    await this.tryOpenExternalFile(
+      await singleItem.query.ensureDilPath(this.qs)
+    );
+  }
+
   async getQueryText(queryHistoryItem: CompletedQuery): Promise<string> {
     if (queryHistoryItem.options.queryText) {
       return queryHistoryItem.options.queryText;
@@ -468,13 +615,16 @@ export class QueryHistoryManager {
     }
   }
 
-  addQuery(info: QueryWithResults): CompletedQuery {
+  buildCompletedQuery(info: QueryWithResults): CompletedQuery {
     const item = new CompletedQuery(info, this.queryHistoryConfigListener);
-    this.treeDataProvider.push(item);
-    this.updateTreeViewSelectionIfVisible();
     return item;
   }
 
+  addCompletedQuery(item: CompletedQuery) {
+    this.treeDataProvider.pushQuery(item);
+    this.updateTreeViewSelectionIfVisible();
+  }
+
   find(queryId: number): CompletedQuery | undefined {
     return this.treeDataProvider.find(queryId);
   }
@@ -502,7 +652,7 @@ export class QueryHistoryManager {
   private async tryOpenExternalFile(fileLocation: string) {
     const uri = vscode.Uri.file(fileLocation);
     try {
-      await vscode.window.showTextDocument(uri);
+      await vscode.window.showTextDocument(uri, { preview: false });
     } catch (e) {
       if (
         e.message.includes(
@@ -510,7 +660,7 @@ export class QueryHistoryManager {
         ) ||
         e.message.includes('too large to open')
       ) {
-        const res = await helpers.showBinaryChoiceDialog(
+        const res = await showBinaryChoiceDialog(
           `VS Code does not allow extensions to open files >50MB. This file
 exceeds that limit. Do you want to open it outside of VS Code?
 
@@ -521,11 +671,11 @@ the file in the file explorer and dragging it into the workspace.`
           try {
             await vscode.commands.executeCommand('revealFileInOS', uri);
           } catch (e) {
-            helpers.showAndLogErrorMessage(e.message);
+            showAndLogErrorMessage(e.message);
           }
         }
       } else {
-        helpers.showAndLogErrorMessage(`Could not open file ${fileLocation}`);
+        showAndLogErrorMessage(`Could not open file ${fileLocation}`);
         logger.log(e.message);
         logger.log(e.stack);
       }
@@ -579,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) {
-      helpers.showAndLogErrorMessage(
+      showAndLogErrorMessage(
         message
       );
       return false;
@@ -615,4 +765,36 @@ the file in the file explorer and dragging it into the workspace.`
       this.compareWithItem = undefined;
     }
   }
+
+  /**
+   * If no items are selected, attempt to grab the selection from the treeview.
+   * We need to use this method because when clicking on commands from the view title
+   * bar, the selections are not passed in.
+   *
+   * @param singleItem the single item selected, or undefined if no item is selected
+   * @param multiSelect a multi-select or undefined if no items are selected
+   */
+  private determineSelection(
+    singleItem: CompletedQuery,
+    multiSelect: CompletedQuery[]
+  ): { finalSingleItem: CompletedQuery; finalMultiSelect: CompletedQuery[] } {
+    if (singleItem === undefined && (multiSelect === undefined || multiSelect.length === 0 || multiSelect[0] === undefined)) {
+      const selection = this.treeView.selection;
+      if (selection) {
+        return {
+          finalSingleItem: selection[0],
+          finalMultiSelect: selection
+        };
+      }
+    }
+    return {
+      finalSingleItem: singleItem,
+      finalMultiSelect: multiSelect
+    };
+  }
+
+  async refreshTreeView(completedQuery: CompletedQuery): Promise<void> {
+    this.treeDataProvider.refresh(completedQuery);
+  }
 }
+

extensions/ql-vscode/src/query-results.ts

@@ -1,23 +1,24 @@
 import { env } from 'vscode';
 
 import { QueryWithResults, tmpDir, QueryInfo } from './run-queries';
-import * as messages from './messages';
-import * as helpers from './helpers';
+import * as messages from './pure/messages';
 import * as cli from './cli';
 import * as sarif from 'sarif';
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import { RawResultsSortState, SortedResultSetInfo, DatabaseInfo, QueryMetadata, InterpretedResultsSortState, ResultsPaths } from './interface-types';
+import { RawResultsSortState, SortedResultSetInfo, DatabaseInfo, QueryMetadata, InterpretedResultsSortState, ResultsPaths } from './pure/interface-types';
 import { QueryHistoryConfig } from './config';
 import { QueryHistoryItemOptions } from './query-history';
 
 export class CompletedQuery implements QueryWithResults {
+  readonly date: Date;
   readonly time: string;
   readonly query: QueryInfo;
   readonly result: messages.EvaluationResult;
   readonly database: DatabaseInfo;
   readonly logFileLocation?: string;
   options: QueryHistoryItemOptions;
+  resultCount: number;
   dispose: () => void;
 
   /**
@@ -45,15 +46,21 @@ export class CompletedQuery implements QueryWithResults {
     this.options = evaluation.options;
     this.dispose = evaluation.dispose;
 
-    this.time = new Date().toLocaleString(env.language);
+    this.date = new Date();
+    this.time = this.date.toLocaleString(env.language);
     this.sortedResultsInfo = new Map();
+    this.resultCount = 0;
+  }
+
+  setResultCount(value: number) {
+    this.resultCount = value;
   }
 
   get databaseName(): string {
     return this.database.name;
   }
   get queryName(): string {
-    return helpers.getQueryName(this.query);
+    return getQueryName(this.query);
   }
 
   get statusString(): string {
@@ -72,13 +79,21 @@ export class CompletedQuery implements QueryWithResults {
     }
   }
 
+  getResultsPath(selectedTable: string, useSorted = true): string {
+    if (!useSorted) {
+      return this.query.resultsPaths.resultsPath;
+    }
+    return this.sortedResultsInfo.get(selectedTable)?.resultsPath
+      || this.query.resultsPaths.resultsPath;
+  }
 
   interpolate(template: string): string {
-    const { databaseName, queryName, time, statusString } = this;
+    const { databaseName, queryName, time, resultCount, statusString } = this;
     const replacements: { [k: string]: string } = {
       t: time,
       q: queryName,
       d: databaseName,
+      r: resultCount.toString(),
       s: statusString,
       '%': '%',
     };
@@ -89,9 +104,8 @@ export class CompletedQuery implements QueryWithResults {
   }
 
   getLabel(): string {
-    if (this.options.label !== undefined)
-      return this.options.label;
-    return this.config.format;
+    return this.options?.label
+      || this.config.format;
   }
 
   get didRunSuccessfully(): boolean {
@@ -102,7 +116,11 @@ export class CompletedQuery implements QueryWithResults {
     return this.interpolate(this.getLabel());
   }
 
-  async updateSortState(server: cli.CodeQLCliServer, resultSetName: string, sortState: RawResultsSortState | undefined): Promise<void> {
+  async updateSortState(
+    server: cli.CodeQLCliServer,
+    resultSetName: string,
+    sortState?: RawResultsSortState
+  ): Promise<void> {
     if (sortState === undefined) {
       this.sortedResultsInfo.delete(resultSetName);
       return;
@@ -113,34 +131,68 @@ export class CompletedQuery implements QueryWithResults {
       sortState
     };
 
-    await server.sortBqrs(this.query.resultsPaths.resultsPath, sortedResultSetInfo.resultsPath, resultSetName, [sortState.columnIndex], [sortState.sortDirection]);
+    await server.sortBqrs(
+      this.query.resultsPaths.resultsPath,
+      sortedResultSetInfo.resultsPath,
+      resultSetName,
+      [sortState.columnIndex],
+      [sortState.sortDirection]
+    );
     this.sortedResultsInfo.set(resultSetName, sortedResultSetInfo);
   }
 
-  async updateInterpretedSortState(sortState: InterpretedResultsSortState | undefined): Promise<void> {
+  async updateInterpretedSortState(sortState?: InterpretedResultsSortState): Promise<void> {
     this.interpretedResultsSortState = sortState;
   }
 }
 
+
+/**
+ * Gets a human-readable name for an evaluated query.
+ * Uses metadata if it exists, and defaults to the query file name.
+ */
+export function getQueryName(query: QueryInfo) {
+  // Queries run through quick evaluation are not usually the entire query file.
+  // Label them differently and include the line numbers.
+  if (query.quickEvalPosition !== undefined) {
+    const { line, endLine, fileName } = query.quickEvalPosition;
+    const lineInfo = line === endLine ? `${line}` : `${line}-${endLine}`;
+    return `Quick evaluation of ${path.basename(fileName)}:${lineInfo}`;
+  } else if (query.metadata?.name) {
+    return query.metadata.name;
+  } else {
+    return path.basename(query.program.queryPath);
+  }
+}
+
+
 /**
  * Call cli command to interpret results.
  */
-export async function interpretResults(server: cli.CodeQLCliServer, metadata: QueryMetadata | undefined, resultsPaths: ResultsPaths, sourceInfo?: cli.SourceInfo): Promise<sarif.Log> {
+export async function interpretResults(
+  server: cli.CodeQLCliServer,
+  metadata: QueryMetadata | undefined,
+  resultsPaths: ResultsPaths,
+  sourceInfo?: cli.SourceInfo
+): Promise<sarif.Log> {
   const { resultsPath, interpretedResultsPath } = resultsPaths;
   if (await fs.pathExists(interpretedResultsPath)) {
     return JSON.parse(await fs.readFile(interpretedResultsPath, 'utf8'));
   }
+  return await server.interpretBqrs(ensureMetadataIsComplete(metadata), resultsPath, interpretedResultsPath, sourceInfo);
+}
+
+export function ensureMetadataIsComplete(metadata: QueryMetadata | undefined) {
   if (metadata === undefined) {
     throw new Error('Can\'t interpret results without query metadata');
   }
-  let { kind, id } = metadata;
-  if (kind === undefined) {
+  if (metadata.kind === undefined) {
     throw new Error('Can\'t interpret results without query metadata including kind');
   }
-  if (id === undefined) {
+  if (metadata.id === undefined) {
     // Interpretation per se doesn't really require an id, but the
     // SARIF format does, so in the absence of one, we use a dummy id.
-    id = 'dummy-id';
+    metadata.id = 'dummy-id';
   }
-  return await server.interpretBqrs({ kind, id }, resultsPath, interpretedResultsPath, sourceInfo);
+  return metadata;
 }

extensions/ql-vscode/src/queryserver-client.ts

@@ -1,13 +1,14 @@
 import * as cp from 'child_process';
 import * as path from 'path';
-import { DisposableObject } from './vscode-utils/disposable-object';
-import { Disposable } from 'vscode';
-import { CancellationToken, createMessageConnection, MessageConnection, RequestType } from 'vscode-jsonrpc';
+import { DisposableObject } from './pure/disposable-object';
+import { Disposable, CancellationToken, commands } from 'vscode';
+import { createMessageConnection, MessageConnection, RequestType } from 'vscode-jsonrpc';
 import * as cli from './cli';
 import { QueryServerConfig } from './config';
 import { Logger, ProgressReporter } from './logging';
-import { completeQuery, EvaluationResult, progress, ProgressMessage, WithProgressId } from './messages';
-import * as messages from './messages';
+import { completeQuery, EvaluationResult, progress, ProgressMessage, WithProgressId } from './pure/messages';
+import * as messages from './pure/messages';
+import { ProgressCallback, ProgressTask } from './commandRunner';
 
 type ServerOpts = {
   logger: Logger;
@@ -47,22 +48,36 @@ type WithProgressReporting = (task: (progress: ProgressReporter, token: Cancella
  * to restart it (which disposes the existing process and starts a new one).
  */
 export class QueryServerClient extends DisposableObject {
+
   serverProcess?: ServerProcess;
   evaluationResultCallbacks: { [key: number]: (res: EvaluationResult) => void };
   progressCallbacks: { [key: number]: ((res: ProgressMessage) => void) | undefined };
   nextCallback: number;
   nextProgress: number;
   withProgressReporting: WithProgressReporting;
+
+  private readonly queryServerStartListeners = [] as ProgressTask<void>[];
+
+  // Can't use standard vscode EventEmitter here since they do not cause the calling
+  // function to fail if one of the event handlers fail. This is something that
+  // we need here.
+  readonly onDidStartQueryServer = (e: ProgressTask<void>) => {
+    this.queryServerStartListeners.push(e);
+  }
+
   public activeQueryName: string | undefined;
 
-  constructor(readonly config: QueryServerConfig, readonly cliServer: cli.CodeQLCliServer, readonly opts: ServerOpts, withProgressReporting: WithProgressReporting) {
+  constructor(
+    readonly config: QueryServerConfig,
+    readonly cliServer: cli.CodeQLCliServer,
+    readonly opts: ServerOpts,
+    withProgressReporting: WithProgressReporting
+  ) {
     super();
     // When the query server configuration changes, restart the query server.
-    if (config.onDidChangeQueryServerConfiguration !== undefined) {
-      this.push(config.onDidChangeQueryServerConfiguration(async () => {
-        this.logger.log('Restarting query server due to configuration changes...');
-        await this.restartQueryServer();
-      }, this));
+    if (config.onDidChangeConfiguration !== undefined) {
+      this.push(config.onDidChangeConfiguration(() =>
+        commands.executeCommand('codeQL.restartQueryServer')));
     }
     this.withProgressReporting = withProgressReporting;
     this.nextCallback = 0;
@@ -85,9 +100,19 @@ export class QueryServerClient extends DisposableObject {
   }
 
   /** Restarts the query server by disposing of the current server process and then starting a new one. */
-  async restartQueryServer(): Promise<void> {
+  async restartQueryServer(
+    progress: ProgressCallback,
+    token: CancellationToken
+  ): Promise<void> {
     this.stopQueryServer();
     await this.startQueryServer();
+
+    // Ensure we await all responses from event handlers so that
+    // errors can be properly reported to the user.
+    await Promise.all(this.queryServerStartListeners.map(handler => handler(
+      progress,
+      token
+    )));
   }
 
   showLog(): void {
@@ -104,9 +129,28 @@ export class QueryServerClient extends DisposableObject {
   private async startQueryServerImpl(progressReporter: ProgressReporter): Promise<void> {
     const ramArgs = await this.cliServer.resolveRam(this.config.queryMemoryMb, progressReporter);
     const args = ['--threads', this.config.numThreads.toString()].concat(ramArgs);
+
+    if (this.config.saveCache) {
+      args.push('--save-cache');
+    }
+
+    if (this.config.cacheSize > 0) {
+      args.push('--max-disk-cache');
+      args.push(this.config.cacheSize.toString());
+    }
+
+    if (await this.cliServer.cliConstraints.supportsDatabaseRegistration()) {
+      args.push('--require-db-registration');
+    }
+
     if (this.config.debug) {
       args.push('--debug', '--tuple-counting');
     }
+
+    if (cli.shouldDebugQueryServer()) {
+      args.push('-J=-agentlib:jdwp=transport=dt_socket,address=localhost:9010,server=y,suspend=n,quiet=y');
+    }
+
     const child = cli.spawnServer(
       this.config.codeQlPath,
       'CodeQL query server',

extensions/ql-vscode/src/quick-query.ts

@@ -1,75 +1,83 @@
 import * as fs from 'fs-extra';
 import * as yaml from 'js-yaml';
 import * as path from 'path';
-import { ExtensionContext, window as Window, workspace, Uri } from 'vscode';
+import {
+  CancellationToken,
+  ExtensionContext,
+  window as Window,
+  workspace,
+  Uri
+} from 'vscode';
 import { ErrorCodes, ResponseError } from 'vscode-languageclient';
 import { CodeQLCliServer } from './cli';
 import { DatabaseUI } from './databases-ui';
-import * as helpers from './helpers';
-import { logger } from './logging';
-import { UserCancellationException } from './run-queries';
+import {
+  getInitialQueryContents,
+  getPrimaryDbscheme,
+  getQlPackForDbscheme,
+  showBinaryChoiceDialog,
+} from './helpers';
+import {
+  ProgressCallback,
+  UserCancellationException
+} from './commandRunner';
 
 const QUICK_QUERIES_DIR_NAME = 'quick-queries';
 const QUICK_QUERY_QUERY_NAME = 'quick-query.ql';
 const QUICK_QUERY_WORKSPACE_FOLDER_NAME = 'Quick Queries';
+const QLPACK_FILE_HEADER = '# This is an automatically generated file.\n\n';
 
 export function isQuickQueryPath(queryPath: string): boolean {
   return path.basename(queryPath) === QUICK_QUERY_QUERY_NAME;
 }
 
-/**
- * `getBaseText` heuristically returns an appropriate import statement
- * prelude based on the filename of the dbscheme file given. TODO: add
- * a 'default import' field to the qlpack itself, and use that.
- */
-function getBaseText(dbschemeBase: string) {
-  if (dbschemeBase == 'semmlecode.javascript.dbscheme') return 'import javascript\n\nselect ""';
-  if (dbschemeBase == 'semmlecode.cpp.dbscheme') return 'import cpp\n\nselect ""';
-  if (dbschemeBase == 'semmlecode.dbscheme') return 'import java\n\nselect ""';
-  if (dbschemeBase == 'semmlecode.python.dbscheme') return 'import python\n\nselect ""';
-  if (dbschemeBase == 'semmlecode.csharp.dbscheme') return 'import csharp\n\nselect ""';
-  if (dbschemeBase == 'go.dbscheme') return 'import go\n\nselect ""';
-  return 'select ""';
-}
-
-function getQuickQueriesDir(ctx: ExtensionContext): string {
+async function getQuickQueriesDir(ctx: ExtensionContext): Promise<string> {
   const storagePath = ctx.storagePath;
   if (storagePath === undefined) {
     throw new Error('Workspace storage path is undefined');
   }
   const queriesPath = path.join(storagePath, QUICK_QUERIES_DIR_NAME);
-  fs.ensureDir(queriesPath, { mode: 0o700 });
+  await fs.ensureDir(queriesPath, { mode: 0o700 });
   return queriesPath;
 }
 
+function updateQuickQueryDir(queriesDir: string, index: number, len: number) {
+  workspace.updateWorkspaceFolders(
+    index,
+    len,
+    { uri: Uri.file(queriesDir), name: QUICK_QUERY_WORKSPACE_FOLDER_NAME }
+  );
+}
 
-
+function findExistingQuickQueryEditor() {
+  return Window.visibleTextEditors.find(editor =>
+    path.basename(editor.document.uri.fsPath) === QUICK_QUERY_QUERY_NAME
+  );
+}
 
 /**
  * Show a buffer the user can enter a simple query into.
  */
-export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQLCliServer, databaseUI: DatabaseUI) {
-
-  function updateQuickQueryDir(queriesDir: string, index: number, len: number) {
-    workspace.updateWorkspaceFolders(
-      index,
-      len,
-      { uri: Uri.file(queriesDir), name: QUICK_QUERY_WORKSPACE_FOLDER_NAME }
-    );
-  }
+export async function displayQuickQuery(
+  ctx: ExtensionContext,
+  cliServer: CodeQLCliServer,
+  databaseUI: DatabaseUI,
+  progress: ProgressCallback,
+  token: CancellationToken
+) {
 
   try {
-    const workspaceFolders = workspace.workspaceFolders || [];
-    const queriesDir = await getQuickQueriesDir(ctx);
-
     // If there is already a quick query open, don't clobber it, just
     // show it.
-    const existing = workspace.textDocuments.find(doc => path.basename(doc.uri.fsPath) === QUICK_QUERY_QUERY_NAME);
-    if (existing !== undefined) {
-      Window.showTextDocument(existing);
+    const existing = findExistingQuickQueryEditor();
+    if (existing) {
+      await Window.showTextDocument(existing.document);
       return;
     }
 
+    const workspaceFolders = workspace.workspaceFolders || [];
+    const queriesDir = await getQuickQueriesDir(ctx);
+
     // We need to have a multi-root workspace to make quick query work
     // at all. Changing the workspace from single-root to multi-root
     // causes a restart of the whole extension host environment, so we
@@ -80,7 +88,7 @@ export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQL
     // being undefined) just let the user know that they're in for a
     // restart.
     if (workspace.workspaceFile === undefined) {
-      const makeMultiRoot = await helpers.showBinaryChoiceDialog('Quick query requires multiple folders in the workspace. Reload workspace as multi-folder workspace?');
+      const makeMultiRoot = await showBinaryChoiceDialog('Quick query requires multiple folders in the workspace. Reload workspace as multi-folder workspace?');
       if (makeMultiRoot) {
         updateQuickQueryDir(queriesDir, workspaceFolders.length, 0);
       }
@@ -88,43 +96,53 @@ export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQL
     }
 
     const index = workspaceFolders.findIndex(folder => folder.name === QUICK_QUERY_WORKSPACE_FOLDER_NAME);
-    if (index === -1)
+    if (index === -1) {
       updateQuickQueryDir(queriesDir, workspaceFolders.length, 0);
-    else
+    } else {
       updateQuickQueryDir(queriesDir, index, 1);
+    }
 
     // We're going to infer which qlpack to use from the current database
-    const dbItem = await databaseUI.getDatabaseItem();
+    const dbItem = await databaseUI.getDatabaseItem(progress, token);
     if (dbItem === undefined) {
       throw new Error('Can\'t start quick query without a selected database');
     }
 
     const datasetFolder = await dbItem.getDatasetFolder(cliServer);
-    const { qlpack, dbscheme } = await helpers.resolveDatasetFolder(cliServer, datasetFolder);
-    const quickQueryQlpackYaml: any = {
-      name: 'quick-query',
-      version: '1.0.0',
-      libraryPathDependencies: [qlpack]
-    };
-
-    const qlFile = path.join(queriesDir, QUICK_QUERY_QUERY_NAME);
+    const dbscheme = await getPrimaryDbscheme(datasetFolder);
+    const qlpack = await getQlPackForDbscheme(cliServer, dbscheme);
     const qlPackFile = path.join(queriesDir, 'qlpack.yml');
-    await fs.writeFile(qlFile, getBaseText(path.basename(dbscheme)), 'utf8');
-    await fs.writeFile(qlPackFile, yaml.safeDump(quickQueryQlpackYaml), 'utf8');
-    Window.showTextDocument(await workspace.openTextDocument(qlFile));
-  }
+    const qlFile = path.join(queriesDir, QUICK_QUERY_QUERY_NAME);
+    const shouldRewrite = await checkShouldRewrite(qlPackFile, qlpack);
 
-  // TODO: clean up error handling for top-level commands like this
-  catch (e) {
-    if (e instanceof UserCancellationException) {
-      logger.log(e.message);
+    // Only rewrite the qlpack file if the database has changed
+    if (shouldRewrite) {
+      const quickQueryQlpackYaml: any = {
+        name: 'quick-query',
+        version: '1.0.0',
+        libraryPathDependencies: [qlpack]
+      };
+      await fs.writeFile(qlPackFile, QLPACK_FILE_HEADER + yaml.safeDump(quickQueryQlpackYaml), 'utf8');
     }
-    else if (e instanceof ResponseError && e.code == ErrorCodes.RequestCancelled) {
-      logger.log(e.message);
+
+    if (shouldRewrite || !(await fs.pathExists(qlFile))) {
+      await fs.writeFile(qlFile, getInitialQueryContents(dbItem.language, dbscheme), 'utf8');
     }
-    else if (e instanceof Error)
-      helpers.showAndLogErrorMessage(e.message);
-    else
+
+    await Window.showTextDocument(await workspace.openTextDocument(qlFile));
+  } catch (e) {
+    if (e instanceof ResponseError && e.code == ErrorCodes.RequestCancelled) {
+      throw new UserCancellationException(e.message);
+    } else {
       throw e;
+    }
   }
 }
+
+async function checkShouldRewrite(qlPackFile: string, newDependency: string) {
+  if (!(await fs.pathExists(qlPackFile))) {
+    return true;
+  }
+  const qlPackContents: any = yaml.safeLoad(await fs.readFile(qlPackFile, 'utf8'));
+  return qlPackContents.libraryPathDependencies?.[0] !== newDependency;
+}

extensions/ql-vscode/src/run-queries.ts

@@ -1,21 +1,30 @@
 import * as crypto from 'crypto';
 import * as fs from 'fs-extra';
 import * as path from 'path';
-import * as tmp from 'tmp';
-import * as vscode from 'vscode';
+import * as tmp from 'tmp-promise';
+import {
+  CancellationToken,
+  ConfigurationTarget,
+  TextDocument,
+  TextEditor,
+  Uri,
+  window
+} from 'vscode';
 import { ErrorCodes, ResponseError } from 'vscode-languageclient';
 
 import * as cli from './cli';
 import * as config from './config';
-import { DatabaseItem, getUpgradesDirectories } from './databases';
-import * as helpers from './helpers';
-import { DatabaseInfo, QueryMetadata, ResultsPaths } from './interface-types';
+import { DatabaseItem } from './databases';
+import { getOnDiskWorkspaceFolders, showAndLogErrorMessage } from './helpers';
+import { ProgressCallback, UserCancellationException } from './commandRunner';
+import { DatabaseInfo, QueryMetadata, ResultsPaths } from './pure/interface-types';
 import { logger } from './logging';
-import * as messages from './messages';
+import * as messages from './pure/messages';
 import { QueryHistoryItemOptions } from './query-history';
 import * as qsClient from './queryserver-client';
 import { isQuickQueryPath } from './quick-query';
-import { upgradeDatabase } from './upgrades';
+import { compileDatabaseUpgradeSequence, hasNondestructiveUpgradeCapabilities, upgradeDatabaseExplicit } from './upgrades';
+import { ensureMetadataIsComplete } from './query-results';
 
 /**
  * run-queries.ts
@@ -34,8 +43,6 @@ export const tmpDirDisposal = {
   }
 };
 
-export class UserCancellationException extends Error { }
-
 /**
  * A collection of evaluation-time information about a query,
  * including the query itself, and where we have decided to put
@@ -46,8 +53,10 @@ export class QueryInfo {
   private static nextQueryId = 0;
 
   readonly compiledQueryPath: string;
+  readonly dilPath: string;
+  readonly csvPath: string;
   readonly resultsPaths: ResultsPaths;
-  readonly dataset: vscode.Uri; // guarantee the existence of a well-defined dataset dir at this point
+  readonly dataset: Uri; // guarantee the existence of a well-defined dataset dir at this point
   readonly queryID: number;
 
   constructor(
@@ -60,9 +69,11 @@ export class QueryInfo {
   ) {
     this.queryID = QueryInfo.nextQueryId++;
     this.compiledQueryPath = path.join(tmpDir.name, `compiledQuery${this.queryID}.qlo`);
+    this.dilPath = path.join(tmpDir.name, `results${this.queryID}.dil`);
+    this.csvPath = path.join(tmpDir.name, `results${this.queryID}.csv`);
     this.resultsPaths = {
       resultsPath: path.join(tmpDir.name, `results${this.queryID}.bqrs`),
-      interpretedResultsPath: path.join(tmpDir.name, `interpretedResults${this.queryID}.sarif`),
+      interpretedResultsPath: path.join(tmpDir.name, `interpretedResults${this.queryID}.sarif`)
     };
     if (dbItem.contents === undefined) {
       throw new Error('Can\'t run query on invalid database.');
@@ -72,6 +83,9 @@ export class QueryInfo {
 
   async run(
     qs: qsClient.QueryServerClient,
+    upgradeQlo: string | undefined,
+    progress: ProgressCallback,
+    token: CancellationToken,
   ): Promise<messages.EvaluationResult> {
     let result: messages.EvaluationResult | null = null;
 
@@ -79,7 +93,8 @@ export class QueryInfo {
 
     const queryToRun: messages.QueryToRun = {
       resultsPath: this.resultsPaths.resultsPath,
-      qlo: vscode.Uri.file(this.compiledQueryPath).toString(),
+      qlo: Uri.file(this.compiledQueryPath).toString(),
+      compiledUpgrade: upgradeQlo && Uri.file(upgradeQlo).toString(),
       allowUnknownTemplates: true,
       templateValues: this.templates,
       id: callbackId,
@@ -97,13 +112,7 @@ export class QueryInfo {
       useSequenceHint: false
     };
     try {
-      await helpers.withProgress({
-        location: vscode.ProgressLocation.Notification,
-        title: 'Running Query',
-        cancellable: true,
-      }, (progress, token) => {
-        return qs.sendRequest(messages.runQueries, params, token, progress);
-      });
+      await qs.sendRequest(messages.runQueries, params, token, progress);
     } finally {
       qs.unRegisterCallback(callbackId);
     }
@@ -118,6 +127,8 @@ export class QueryInfo {
 
   async compile(
     qs: qsClient.QueryServerClient,
+    progress: ProgressCallback,
+    token: CancellationToken,
   ): Promise<messages.CompilationMessage[]> {
     let compiled: messages.CheckQueryResult | undefined;
     try {
@@ -133,6 +144,7 @@ export class QueryInfo {
           localChecking: false,
           noComputeGetUrl: false,
           noComputeToString: false,
+          computeDefaultStrings: true
         },
         extraOptions: {
           timeoutSecs: qs.config.timeoutSecs
@@ -142,13 +154,7 @@ export class QueryInfo {
         target,
       };
 
-      compiled = await helpers.withProgress({
-        location: vscode.ProgressLocation.Notification,
-        title: 'Compiling Query',
-        cancellable: true,
-      }, (progress, token) => {
-        return qs.sendRequest(messages.compileQuery, params, token, progress);
-      });
+      compiled = await qs.sendRequest(messages.compileQuery, params, token, progress);
     } finally {
       qs.logger.log(' - - - COMPILATION DONE - - - ');
     }
@@ -163,7 +169,15 @@ export class QueryInfo {
     if (!hasMetadataFile) {
       logger.log('Cannot produce interpreted results since the database does not have a .dbinfo or codeql-database.yml file.');
     }
-    return hasMetadataFile;
+
+    const hasKind = !!this.metadata?.kind;
+    if (!hasKind) {
+      logger.log('Cannot produce interpreted results since the query does not have @kind metadata.');
+    }
+
+    const isTable = hasKind && this.metadata?.kind === 'table';
+
+    return hasMetadataFile && hasKind && !isTable;
   }
 
   /**
@@ -172,8 +186,57 @@ export class QueryInfo {
   async hasInterpretedResults(): Promise<boolean> {
     return fs.pathExists(this.resultsPaths.interpretedResultsPath);
   }
+
+  /**
+   * Holds if this query already has DIL produced
+   */
+  async hasDil(): Promise<boolean> {
+    return fs.pathExists(this.dilPath);
+  }
+
+  /**
+   * Holds if this query already has CSV results produced
+   */
+  async hasCsv(): Promise<boolean> {
+    return fs.pathExists(this.csvPath);
+  }
+
+  async ensureDilPath(qs: qsClient.QueryServerClient): Promise<string> {
+    if (await this.hasDil()) {
+      return this.dilPath;
+    }
+
+    if (!(await fs.pathExists(this.compiledQueryPath))) {
+      throw new Error(
+        `Cannot create DIL because compiled query is missing. ${this.compiledQueryPath}`
+      );
+    }
+
+    await qs.cliServer.generateDil(this.compiledQueryPath, this.dilPath);
+    return this.dilPath;
+  }
+
+  async ensureCsvProduced(qs: qsClient.QueryServerClient): Promise<string> {
+    if (await this.hasCsv()) {
+      return this.csvPath;
+    }
+
+    let sourceInfo;
+    if (this.dbItem.sourceArchive !== undefined) {
+      sourceInfo = {
+        sourceArchive: this.dbItem.sourceArchive.fsPath,
+        sourceLocationPrefix: await this.dbItem.getSourceLocationPrefix(
+          qs.cliServer
+        ),
+      };
+    }
+
+    await qs.cliServer.generateResultsCsv(ensureMetadataIsComplete(this.metadata), this.resultsPaths.resultsPath, this.csvPath, sourceInfo);
+    return this.csvPath;
+  }
 }
 
+
 export interface QueryWithResults {
   readonly query: QueryInfo;
   readonly result: messages.EvaluationResult;
@@ -184,7 +247,10 @@ export interface QueryWithResults {
 }
 
 export async function clearCacheInDatabase(
-  qs: qsClient.QueryServerClient, dbItem: DatabaseItem
+  qs: qsClient.QueryServerClient,
+  dbItem: DatabaseItem,
+  progress: ProgressCallback,
+  token: CancellationToken,
 ): Promise<messages.ClearCacheResult> {
   if (dbItem.contents === undefined) {
     throw new Error('Can\'t clear the cache in an invalid database.');
@@ -200,13 +266,7 @@ export async function clearCacheInDatabase(
     db,
   };
 
-  return helpers.withProgress({
-    location: vscode.ProgressLocation.Notification,
-    title: 'Clearing Cache',
-    cancellable: false,
-  }, (progress, token) =>
-    qs.sendRequest(messages.clearCache, params, token, progress)
-  );
+  return qs.sendRequest(messages.clearCache, params, token, progress);
 }
 
 /**
@@ -242,7 +302,7 @@ async function convertToQlPath(filePath: string): Promise<string> {
 
 
 /** Gets the selected position within the given editor. */
-async function getSelectedPosition(editor: vscode.TextEditor): Promise<messages.Position> {
+async function getSelectedPosition(editor: TextEditor): Promise<messages.Position> {
   const pos = editor.selection.start;
   const posEnd = editor.selection.end;
   // Convert from 0-based to 1-based line and column numbers.
@@ -264,12 +324,14 @@ async function getSelectedPosition(editor: vscode.TextEditor): Promise<messages.
 async function checkDbschemeCompatibility(
   cliServer: cli.CodeQLCliServer,
   qs: qsClient.QueryServerClient,
-  query: QueryInfo
+  query: QueryInfo,
+  progress: ProgressCallback,
+  token: CancellationToken,
 ): Promise<void> {
-  const searchPath = helpers.getOnDiskWorkspaceFolders();
+  const searchPath = getOnDiskWorkspaceFolders();
 
   if (query.dbItem.contents !== undefined && query.dbItem.contents.dbSchemeUri !== undefined) {
-    const { scripts, finalDbscheme } = await cliServer.resolveUpgrades(query.dbItem.contents.dbSchemeUri.fsPath, searchPath);
+    const { finalDbscheme } = await cliServer.resolveUpgrades(query.dbItem.contents.dbSchemeUri.fsPath, searchPath, false);
     const hash = async function(filename: string): Promise<string> {
       return crypto.createHash('sha256').update(await fs.readFile(filename)).digest('hex');
     };
@@ -288,28 +350,67 @@ async function checkDbschemeCompatibility(
     const upgradableTo = await hash(finalDbscheme);
 
     if (upgradableTo != dbschemeOfLib) {
-      logger.log(`Query ${query.program.queryPath} expects database scheme ${query.queryDbscheme}, but database has scheme ${query.program.dbschemePath}, and no upgrade path found`);
-      throw new Error(`Query ${query.program.queryPath} expects database scheme ${query.queryDbscheme}, but the current database has a different scheme, and no database upgrades are available. The current database scheme may be newer than the CodeQL query libraries in your workspace. Please try using a newer version of the query libraries.`);
+      reportNoUpgradePath(query);
     }
 
     if (upgradableTo == dbschemeOfLib &&
       dbschemeOfDb != dbschemeOfLib) {
       // Try to upgrade the database
-      await upgradeDatabase(
+      await upgradeDatabaseExplicit(
         qs,
         query.dbItem,
-        vscode.Uri.file(finalDbscheme),
-        getUpgradesDirectories(scripts)
+        progress,
+        token
       );
     }
   }
 }
 
+function reportNoUpgradePath(query: QueryInfo) {
+  throw new Error(`Query ${query.program.queryPath} expects database scheme ${query.queryDbscheme}, but the current database has a different scheme, and no database upgrades are available. The current database scheme may be newer than the CodeQL query libraries in your workspace.\n\nPlease try using a newer version of the query libraries.`);
+}
+
+/**
+ * Compile a non-destructive upgrade.
+ */
+async function compileNonDestructiveUpgrade(
+  qs: qsClient.QueryServerClient,
+  upgradeTemp: tmp.DirectoryResult,
+  query: QueryInfo,
+  progress: ProgressCallback,
+  token: CancellationToken,
+): Promise<string> {
+  const searchPath = getOnDiskWorkspaceFolders();
+
+  if (!query.dbItem?.contents?.dbSchemeUri) {
+    throw new Error('Database is invalid, and cannot be upgraded.');
+  }
+  const { scripts, matchesTarget } = await qs.cliServer.resolveUpgrades(query.dbItem.contents.dbSchemeUri.fsPath, searchPath, true, query.queryDbscheme);
+
+  if (!matchesTarget) {
+    reportNoUpgradePath(query);
+  }
+  const result = await compileDatabaseUpgradeSequence(qs, query.dbItem, scripts, upgradeTemp, progress, token);
+  if (result.compiledUpgrade === undefined) {
+    const error = result.error || '[no error message available]';
+    throw new Error(error);
+  }
+  // We can upgrade to the actual target
+  query.program.dbschemePath = query.queryDbscheme;
+  // We are new enough that we will always support single file upgrades.
+  return result.compiledUpgrade;
+
+}
+
 /**
  * Prompts the user to save `document` if it has unsaved changes.
- * Returns true if we should save changes.
+ *
+ * @param document The document to save.
+ *
+ * @returns true if we should save changes and false if we should continue without saving changes.
+ * @throws UserCancellationException if we should abort whatever operation triggered this prompt
  */
-async function promptUserToSaveChanges(document: vscode.TextDocument): Promise<boolean> {
+async function promptUserToSaveChanges(document: TextDocument): Promise<boolean> {
   if (document.isDirty) {
     if (config.AUTOSAVE_SETTING.getValue()) {
       return true;
@@ -317,18 +418,27 @@ async function promptUserToSaveChanges(document: vscode.TextDocument): Promise<b
     else {
       const yesItem = { title: 'Yes', isCloseAffordance: false };
       const alwaysItem = { title: 'Always Save', isCloseAffordance: false };
-      const noItem = { title: 'No', isCloseAffordance: true };
+      const noItem = { title: 'No (run version on disk)', isCloseAffordance: false };
+      const cancelItem = { title: 'Cancel', isCloseAffordance: true };
       const message = 'Query file has unsaved changes. Save now?';
-      const chosenItem = await vscode.window.showInformationMessage(message, { modal: true }, yesItem, alwaysItem, noItem);
+      const chosenItem = await window.showInformationMessage(
+        message,
+        { modal: true },
+        yesItem, alwaysItem, noItem, cancelItem
+      );
 
       if (chosenItem === alwaysItem) {
-        await config.AUTOSAVE_SETTING.updateValue(true, vscode.ConfigurationTarget.Workspace);
+        await config.AUTOSAVE_SETTING.updateValue(true, ConfigurationTarget.Workspace);
         return true;
       }
 
       if (chosenItem === yesItem) {
         return true;
       }
+
+      if (chosenItem === cancelItem) {
+        throw new UserCancellationException('Query run cancelled.', true);
+      }
     }
   }
   return false;
@@ -350,11 +460,11 @@ type SelectedQuery = {
  * @param selectedResourceUri The selected resource when the command was run.
  * @param quickEval Whether the command being run is `Quick Evaluation`.
 */
-export async function determineSelectedQuery(selectedResourceUri: vscode.Uri | undefined, quickEval: boolean): Promise<SelectedQuery> {
-  const editor = vscode.window.activeTextEditor;
+export async function determineSelectedQuery(selectedResourceUri: Uri | undefined, quickEval: boolean): Promise<SelectedQuery> {
+  const editor = window.activeTextEditor;
 
   // Choose which QL file to use.
-  let queryUri: vscode.Uri;
+  let queryUri: Uri;
   if (selectedResourceUri === undefined) {
     // No resource was passed to the command handler, so obtain it from the active editor.
     // This usually happens when the command is called from the Command Palette.
@@ -416,7 +526,9 @@ export async function compileAndRunQueryAgainstDatabase(
   qs: qsClient.QueryServerClient,
   db: DatabaseItem,
   quickEval: boolean,
-  selectedQueryUri: vscode.Uri | undefined,
+  selectedQueryUri: Uri | undefined,
+  progress: ProgressCallback,
+  token: CancellationToken,
   templates?: messages.TemplateDefinitions,
 ): Promise<QueryWithResults> {
   if (!db.contents || !db.contents.dbSchemeUri) {
@@ -435,10 +547,14 @@ export async function compileAndRunQueryAgainstDatabase(
   }
 
   // Get the workspace folder paths.
-  const diskWorkspaceFolders = helpers.getOnDiskWorkspaceFolders();
+  const diskWorkspaceFolders = getOnDiskWorkspaceFolders();
   // Figure out the library path for the query.
   const packConfig = await cliServer.resolveLibraryPath(diskWorkspaceFolders, queryPath);
 
+  if (!packConfig.dbscheme) {
+    throw new Error('Could not find a database scheme for this query. Please check that you have a valid qlpack.yml file for this query, which refers to a database scheme either in the `dbscheme` field or through one of its dependencies.');
+  }
+
   // Check whether the query has an entirely different schema from the
   // database. (Queries that merely need the database to be upgraded
   // won't trigger this check)
@@ -472,67 +588,85 @@ export async function compileAndRunQueryAgainstDatabase(
   }
 
   const query = new QueryInfo(qlProgram, db, packConfig.dbscheme, quickEvalPosition, metadata, templates);
-  await checkDbschemeCompatibility(cliServer, qs, query);
 
-  let errors;
+  const upgradeDir = await tmp.dir({ dir: upgradesTmpDir.name, unsafeCleanup: true });
   try {
-    errors = await query.compile(qs);
-  } catch (e) {
-    if (e instanceof ResponseError && e.code == ErrorCodes.RequestCancelled) {
-      return createSyntheticResult(query, db, historyItemOptions, 'Query cancelled', messages.QueryResultType.CANCELLATION);
+    let upgradeQlo;
+    if (await hasNondestructiveUpgradeCapabilities(qs)) {
+      upgradeQlo = await compileNonDestructiveUpgrade(qs, upgradeDir, query, progress, token);
     } else {
-      throw e;
+      await checkDbschemeCompatibility(cliServer, qs, query, progress, token);
     }
-  }
-
-  if (errors.length == 0) {
-    const result = await query.run(qs);
-    if (result.resultType !== messages.QueryResultType.SUCCESS) {
-      const message = result.message || 'Failed to run query';
-      logger.log(message);
-      helpers.showAndLogErrorMessage(message);
-    }
-    return {
-      query,
-      result,
-      database: {
-        name: db.name,
-        databaseUri: db.databaseUri.toString(true)
-      },
-      options: historyItemOptions,
-      logFileLocation: result.logFileLocation,
-      dispose: () => {
-        qs.logger.removeAdditionalLogLocation(result.logFileLocation);
+    let errors;
+    try {
+      errors = await query.compile(qs, progress, token);
+    } catch (e) {
+      if (e instanceof ResponseError && e.code == ErrorCodes.RequestCancelled) {
+        return createSyntheticResult(query, db, historyItemOptions, 'Query cancelled', messages.QueryResultType.CANCELLATION);
+      } else {
+        throw e;
       }
-    };
-  } else {
-    // Error dialogs are limited in size and scrollability,
-    // 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}:`);
-
-    const formattedMessages: string[] = [];
-
-    for (const error of errors) {
-      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);
     }
-    if (quickEval && formattedMessages.length <= 3) {
-      helpers.showAndLogErrorMessage('Quick evaluation compilation failed: \n' + formattedMessages.join('\n'));
+
+    if (errors.length === 0) {
+      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);
+      }
+      return {
+        query,
+        result,
+        database: {
+          name: db.name,
+          databaseUri: db.databaseUri.toString(true)
+        },
+        options: historyItemOptions,
+        logFileLocation: result.logFileLocation,
+        dispose: () => {
+          qs.logger.removeAdditionalLogLocation(result.logFileLocation);
+        }
+      };
     } else {
-      helpers.showAndLogErrorMessage((quickEval ? 'Quick evaluation' : 'Query') +
-        ' compilation failed. Please make sure there are no errors in the query, the database is up to date,' +
-        ' and the query and database use the same target language. For more details on the error, go to View > Output,' +
-        ' and choose CodeQL Query Server from the dropdown.');
-    }
+      // Error dialogs are limited in size and scrollability,
+      // 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}:`);
 
-    return createSyntheticResult(query, db, historyItemOptions, 'Query had compilation errors', messages.QueryResultType.OTHER_ERROR);
+      const formattedMessages: string[] = [];
+
+      for (const error of errors) {
+        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);
+      }
+      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'));
+      } else {
+        showAndLogErrorMessage((quickEval ? 'Quick evaluation' : 'Query') + compilationFailedErrorTail);
+      }
+
+      return createSyntheticResult(query, db, historyItemOptions, 'Query had compilation errors', messages.QueryResultType.OTHER_ERROR);
+    }
+  } finally {
+    try {
+      upgradeDir.cleanup();
+    } catch (e) {
+      qs.logger.log(`Could not clean up the upgrades dir. Reason: ${e.message || e}`);
+    }
   }
 }
 
+const compilationFailedErrorTail = ' compilation failed. Please make sure there are no errors in the query, the database is up to date,' +
+  ' and the query and database use the same target language. For more details on the error, go to View > Output,' +
+  ' and choose CodeQL Query Server from the dropdown.';
+
 function createSyntheticResult(
   query: QueryInfo,
   db: DatabaseItem,

extensions/ql-vscode/src/status-bar.ts

@@ -0,0 +1,48 @@
+import { ConfigurationChangeEvent, StatusBarAlignment, StatusBarItem, window, workspace } from 'vscode';
+import { CodeQLCliServer } from './cli';
+import { CANARY_FEATURES, CUSTOM_CODEQL_PATH_SETTING, DistributionConfigListener } from './config';
+import { DisposableObject } from './pure/disposable-object';
+
+/**
+ * Creates and manages a status bar item for codeql. THis item contains
+ * the current codeQL cli version as well as a notification if you are
+ * in canary mode
+ *
+ */
+export class CodeQlStatusBarHandler extends DisposableObject {
+
+  private readonly item: StatusBarItem;
+
+  constructor(private cli: CodeQLCliServer, distributionConfigListener: DistributionConfigListener) {
+    super();
+    this.item = window.createStatusBarItem(StatusBarAlignment.Right);
+    this.push(this.item);
+    this.push(workspace.onDidChangeConfiguration(this.handleDidChangeConfiguration, this));
+    this.push(distributionConfigListener.onDidChangeConfiguration(() => this.updateStatusItem()));
+    this.item.command = 'codeQL.openDocumentation';
+    this.updateStatusItem();
+  }
+
+  private handleDidChangeConfiguration(e: ConfigurationChangeEvent) {
+    if (
+      e.affectsConfiguration(CANARY_FEATURES.qualifiedName) ||
+      e.affectsConfiguration(CUSTOM_CODEQL_PATH_SETTING.qualifiedName)
+    ) {
+      // Wait a few seconds before updating the status item.
+      // This avoids a race condition where the cli's version
+      // is not updated before the status bar is refreshed.
+      setTimeout(() => this.updateStatusItem(), 3000);
+    }
+  }
+
+  private async updateStatusItem() {
+    const canary = CANARY_FEATURES.getValue() ? ' (Canary)' : '';
+    // since getting the verison may take a few seconds, initialize with some
+    // meaningful text.
+    this.item.text = `CodeQL${canary}`;
+
+    const version = await this.cli.getVersion();
+    this.item.text = `CodeQL CLI v${version}${canary}`;
+    this.item.show();
+  }
+}

extensions/ql-vscode/src/telemetry.ts

@@ -0,0 +1,214 @@
+import { ConfigurationTarget, Extension, ExtensionContext, ConfigurationChangeEvent } from 'vscode';
+import TelemetryReporter from 'vscode-extension-telemetry';
+import { ConfigListener, CANARY_FEATURES, ENABLE_TELEMETRY, GLOBAL_ENABLE_TELEMETRY, LOG_TELEMETRY } from './config';
+import * as appInsights from 'applicationinsights';
+import { logger } from './logging';
+import { UserCancellationException } from './commandRunner';
+import { showBinaryChoiceWithUrlDialog } from './helpers';
+
+// Key is injected at build time through the APP_INSIGHTS_KEY environment variable.
+const key = 'REPLACE-APP-INSIGHTS-KEY';
+
+export enum CommandCompletion {
+  Success = 'Success',
+  Failed = 'Failed',
+  Cancelled = 'Cancelled'
+}
+
+// Avoid sending the following data to App insights since we don't need it.
+const tagsToRemove = [
+  'ai.application.ver',
+  'ai.device.id',
+  'ai.cloud.roleInstance',
+  'ai.cloud.role',
+  'ai.device.id',
+  'ai.device.osArchitecture',
+  'ai.device.osPlatform',
+  'ai.device.osVersion',
+  'ai.internal.sdkVersion',
+  'ai.session.id'
+];
+
+const baseDataPropertiesToRemove = [
+  'common.os',
+  'common.platformversion',
+  'common.remotename',
+  'common.uikind',
+  'common.vscodesessionid'
+];
+
+export class TelemetryListener extends ConfigListener {
+
+  static relevantSettings = [ENABLE_TELEMETRY, CANARY_FEATURES];
+
+  private reporter?: TelemetryReporter;
+
+  constructor(
+    private readonly id: string,
+    private readonly version: string,
+    private readonly key: string,
+    private readonly ctx: ExtensionContext
+  ) {
+    super();
+  }
+
+  /**
+   * This function handles changes to relevant configuration elements. There are 2 configuration
+   * ids that this function cares about:
+   *
+   *     * `codeQL.telemetry.enableTelemetry`: If this one has changed, then we need to re-initialize
+   *        the reporter and the reporter may wind up being removed.
+   *     * `codeQL.canary`: A change here could possibly re-trigger a dialog popup.
+   *
+   * Note that the global telemetry setting also gate-keeps whether or not to send telemetry events
+   * to Application Insights. However, this gatekeeping happens inside of the vscode-extension-telemetry
+   * package. So, this does not need to be handled here.
+   *
+   * @param e the configuration change event
+   */
+  async handleDidChangeConfiguration(e: ConfigurationChangeEvent): Promise<void> {
+    if (
+      e.affectsConfiguration('codeQL.telemetry.enableTelemetry') ||
+      e.affectsConfiguration('telemetry.enableTelemetry')
+    ) {
+      await this.initialize();
+    }
+
+    // Re-request telemetry so that users can see the dialog again.
+    // Re-request if codeQL.canary is being set to `true` and telemetry
+    // is not currently enabled.
+    if (
+      e.affectsConfiguration('codeQL.canary') &&
+      CANARY_FEATURES.getValue() &&
+      !ENABLE_TELEMETRY.getValue()
+    ) {
+      await Promise.all([
+        this.setTelemetryRequested(false),
+        this.requestTelemetryPermission()
+      ]);
+    }
+  }
+
+  async initialize() {
+    await this.requestTelemetryPermission();
+
+    this.disposeReporter();
+
+    if (ENABLE_TELEMETRY.getValue<boolean>()) {
+      this.createReporter();
+    }
+  }
+
+  private createReporter() {
+    this.reporter = new TelemetryReporter(
+      this.id,
+      this.version,
+      this.key,
+      /* anonymize stack traces */ true
+    );
+    this.push(this.reporter);
+
+    const client = (this.reporter as any).appInsightsClient as appInsights.TelemetryClient;
+    if (client) {
+      // add a telemetry processor to delete unwanted properties
+      client.addTelemetryProcessor((envelope: any) => {
+        tagsToRemove.forEach(tag => delete envelope.tags[tag]);
+        const baseDataProperties = (envelope.data as any)?.baseData?.properties;
+        if (baseDataProperties) {
+          baseDataPropertiesToRemove.forEach(prop => delete baseDataProperties[prop]);
+        }
+
+        if (LOG_TELEMETRY.getValue<boolean>()) {
+          logger.log(`Telemetry: ${JSON.stringify(envelope)}`);
+        }
+        return true;
+      });
+    }
+  }
+
+  dispose() {
+    super.dispose();
+    this.reporter?.dispose();
+  }
+
+  sendCommandUsage(name: string, executionTime: number, error?: Error) {
+    if (!this.reporter) {
+      return;
+    }
+    const status = !error
+      ? CommandCompletion.Success
+      : error instanceof UserCancellationException
+        ? CommandCompletion.Cancelled
+        : CommandCompletion.Failed;
+
+    const isCanary = (!!CANARY_FEATURES.getValue<boolean>()).toString();
+
+    this.reporter.sendTelemetryEvent(
+      'command-usage',
+      {
+        name,
+        status,
+        isCanary
+      },
+      { executionTime }
+    );
+  }
+
+  /**
+   * Displays a popup asking the user if they want to enable telemetry
+   * for this extension.
+   */
+  async requestTelemetryPermission() {
+    if (!this.wasTelemetryRequested()) {
+      // if global telemetry is disabled, avoid showing the dialog or making any changes
+      let result = undefined;
+      if (GLOBAL_ENABLE_TELEMETRY.getValue()) {
+        // Extension won't start until this completes.
+        result = await showBinaryChoiceWithUrlDialog(
+          'Does the CodeQL Extension by GitHub have your permission to collect usage data and metrics to help us improve CodeQL for VSCode?',
+          'https://codeql.github.com/docs/codeql-for-visual-studio-code/about-telemetry-in-codeql-for-visual-studio-code'
+        );
+      }
+      if (result !== undefined) {
+        await Promise.all([
+          this.setTelemetryRequested(true),
+          ENABLE_TELEMETRY.updateValue<boolean>(result, ConfigurationTarget.Global),
+        ]);
+      }
+    }
+  }
+
+  /**
+   * Exposed for testing
+   */
+  get _reporter() {
+    return this.reporter;
+  }
+
+  private disposeReporter() {
+    if (this.reporter) {
+      this.reporter.dispose();
+      this.reporter = undefined;
+    }
+  }
+
+  private wasTelemetryRequested(): boolean {
+    return !!this.ctx.globalState.get<boolean>('telemetry-request-viewed');
+  }
+
+  private async setTelemetryRequested(newValue: boolean): Promise<void> {
+    await this.ctx.globalState.update('telemetry-request-viewed', newValue);
+  }
+}
+
+
+/**
+ * The global Telemetry instance
+ */
+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();
+  ctx.subscriptions.push(telemetryListener);
+}

extensions/ql-vscode/src/test-adapter.ts

@@ -15,8 +15,7 @@ import {
 import { TestAdapterRegistrar } from 'vscode-test-adapter-util';
 import { QLTestFile, QLTestNode, QLTestDirectory, QLTestDiscovery } from './qltest-discovery';
 import { Event, EventEmitter, CancellationTokenSource, CancellationToken } from 'vscode';
-import { DisposableObject } from './vscode-utils/disposable-object';
-import { QLPackDiscovery } from './qlpack-discovery';
+import { DisposableObject } from './pure/disposable-object';
 import { CodeQLCliServer } from './cli';
 import { getOnDiskWorkspaceFolders } from './helpers';
 import { testLogger } from './logging';
@@ -82,7 +81,6 @@ function changeExtension(p: string, ext: string): string {
  * Test adapter for QL tests.
  */
 export class QLTestAdapter extends DisposableObject implements TestAdapter {
-  private readonly qlPackDiscovery: QLPackDiscovery;
   private readonly qlTestDiscovery: QLTestDiscovery;
   private readonly _tests = this.push(
     new EventEmitter<TestLoadStartedEvent | TestLoadFinishedEvent>());
@@ -97,9 +95,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
   ) {
     super();
 
-    this.qlPackDiscovery = this.push(new QLPackDiscovery(workspaceFolder, cliServer));
-    this.qlTestDiscovery = this.push(new QLTestDiscovery(this.qlPackDiscovery, workspaceFolder, cliServer));
-    this.qlPackDiscovery.refresh();
+    this.qlTestDiscovery = this.push(new QLTestDiscovery(workspaceFolder, cliServer));
     this.qlTestDiscovery.refresh();
 
     this.push(this.qlTestDiscovery.onDidChangeTests(this.discoverTests, this));
@@ -160,20 +156,20 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
   private discoverTests(): void {
     this._tests.fire({ type: 'started' } as TestLoadStartedEvent);
 
-    const testDirectories = this.qlTestDiscovery.testDirectories;
-    const children = testDirectories.map(
-      testDirectory => QLTestAdapter.createTestSuiteInfo(testDirectory, testDirectory.name)
-    );
-    const testSuite: TestSuiteInfo = {
-      type: 'suite',
-      label: 'CodeQL',
-      id: '.',
-      children
-    };
-
+    const testDirectory = this.qlTestDiscovery.testDirectory;
+    let testSuite: TestSuiteInfo | undefined;
+    if (testDirectory?.children.length) {
+      const children = QLTestAdapter.createTestOrSuiteInfos(testDirectory.children);
+      testSuite = {
+        type: 'suite',
+        label: 'CodeQL',
+        id: testDirectory.path,
+        children
+      };
+    }
     this._tests.fire({
       type: 'finished',
-      suite: children.length > 0 ? testSuite : undefined
+      suite: testSuite
     } as TestLoadFinishedEvent);
   }
 
@@ -221,10 +217,25 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
       cancellationToken: cancellationToken,
       logger: testLogger
     })) {
+      const state = event.pass
+        ? 'passed'
+        : event.messages?.length
+          ? 'errored'
+          : 'failed';
+      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);
+      }
       this._testStates.fire({
         type: 'test',
-        state: event.pass ? 'passed' : 'failed',
-        test: event.test
+        state,
+        test: event.test,
+        message,
+        decorations: event.messages?.map(msg => ({
+          line: msg.position.line,
+          message: msg.message
+        }))
       });
     }
   }

extensions/ql-vscode/src/test-ui.ts

@@ -1,10 +1,20 @@
 import * as fs from 'fs-extra';
 import * as path from 'path';
 import { Uri, TextDocumentShowOptions, commands, window } from 'vscode';
+import {
+  TestHub,
+  TestController,
+  TestAdapter,
+  TestRunStartedEvent,
+  TestRunFinishedEvent,
+  TestEvent,
+  TestSuiteEvent
+} from 'vscode-test-adapter-api';
+
+import { showAndLogWarningMessage } from './helpers';
 import { TestTreeNode } from './test-tree-node';
-import { DisposableObject } from './vscode-utils/disposable-object';
+import { DisposableObject } from './pure/disposable-object';
 import { UIService } from './vscode-utils/ui-service';
-import { TestHub, TestController, TestAdapter, TestRunStartedEvent, TestRunFinishedEvent, TestEvent, TestSuiteEvent } from 'vscode-test-adapter-api';
 import { QLTestAdapter, getExpectedFile, getActualFile } from './test-adapter';
 import { logger } from './logging';
 
@@ -78,12 +88,17 @@ export class TestUIService extends UIService implements TestController {
         preserveFocus: true,
         preview: true
       };
+
+      if (!await fs.pathExists(expectedPath)) {
+        showAndLogWarningMessage(`'${path.basename(expectedPath)}' does not exist. Creating an empty file.`);
+        await fs.createFile(expectedPath);
+      }
+
       if (await fs.pathExists(actualPath)) {
         const actualUri = Uri.file(actualPath);
         await commands.executeCommand<void>('vscode.diff', expectedUri, actualUri,
           `Expected vs. Actual for ${path.basename(testId)}`, options);
-      }
-      else {
+      } else {
         await window.showTextDocument(expectedUri, options);
       }
     }

extensions/ql-vscode/src/upgrades.ts

@@ -1,10 +1,14 @@
 import * as vscode from 'vscode';
-import { DatabaseItem } from './databases';
-import * as helpers from './helpers';
+import { getOnDiskWorkspaceFolders, showAndLogErrorMessage } from './helpers';
+import { ProgressCallback, UserCancellationException } from './commandRunner';
 import { logger } from './logging';
-import * as messages from './messages';
+import * as messages from './pure/messages';
 import * as qsClient from './queryserver-client';
-import { upgradesTmpDir, UserCancellationException } from './run-queries';
+import { upgradesTmpDir } from './run-queries';
+import * as tmp from 'tmp-promise';
+import * as path from 'path';
+import * as semver from 'semver';
+import { DatabaseItem } from './databases';
 
 /**
  * Maximum number of lines to include from database upgrade message,
@@ -14,68 +18,99 @@ import { upgradesTmpDir, UserCancellationException } from './run-queries';
 const MAX_UPGRADE_MESSAGE_LINES = 10;
 
 /**
- * Checks whether the given database can be upgraded to the given target DB scheme,
- * and whether the user wants to proceed with the upgrade.
+ * Check that we support non-destructive upgrades.
+ *
+ * This requires 3 features. The ability to compile an upgrade sequence; The ability to
+ * run a non-destructive upgrades as a query; the ability to specify a target when
+ * resolving upgrades. We check for a version of codeql that has all three features.
+ */
+export async function hasNondestructiveUpgradeCapabilities(qs: qsClient.QueryServerClient): Promise<boolean> {
+  return semver.gte(await qs.cliServer.getVersion(), '2.4.2');
+}
+
+
+/**
+ * Compile a database upgrade sequence.
+ * Callers must check that this is valid with the current queryserver first.
+ */
+export async function compileDatabaseUpgradeSequence(
+  qs: qsClient.QueryServerClient,
+  db: DatabaseItem,
+  resolvedSequence: string[],
+  currentUpgradeTmp: tmp.DirectoryResult,
+  progress: ProgressCallback,
+  token: vscode.CancellationToken
+): Promise<messages.CompileUpgradeSequenceResult> {
+  if (db.contents === undefined || db.contents.dbSchemeUri === undefined) {
+    throw new Error('Database is invalid, and cannot be upgraded.');
+  }
+  if (!await hasNondestructiveUpgradeCapabilities(qs)) {
+    throw new Error('The version of codeql is too old to run non-destructive upgrades.');
+  }
+  // If possible just compile the upgrade sequence
+  return await qs.sendRequest(messages.compileUpgradeSequence, {
+    upgradeTempDir: currentUpgradeTmp.path,
+    upgradePaths: resolvedSequence
+  }, token, progress);
+}
+
+async function compileDatabaseUpgrade(
+  qs: qsClient.QueryServerClient,
+  db: DatabaseItem,
+  targetDbScheme: string,
+  resolvedSequence: string[],
+  currentUpgradeTmp: tmp.DirectoryResult,
+  progress: ProgressCallback,
+  token: vscode.CancellationToken
+): Promise<messages.CompileUpgradeResult> {
+  if (!db.contents?.dbSchemeUri) {
+    throw new Error('Database is invalid, and cannot be upgraded.');
+  }
+  // We have the upgrades we want but compileUpgrade
+  // requires searching for them.  So we use the parent directories of the upgrades
+  // as the upgrade path.
+  const parentDirs = resolvedSequence.map(dir => path.dirname(dir));
+  const uniqueParentDirs = new Set(parentDirs);
+  progress({
+    step: 1,
+    maxStep: 3,
+    message: 'Checking for database upgrades'
+  });
+  return qs.sendRequest(messages.compileUpgrade, {
+    upgrade: {
+      fromDbscheme: db.contents.dbSchemeUri.fsPath,
+      toDbscheme: targetDbScheme,
+      additionalUpgrades: Array.from(uniqueParentDirs)
+    },
+    upgradeTempDir: currentUpgradeTmp.path,
+    singleFileUpgrades: true,
+  }, token, progress);
+}
+
+/**
+ * Checks whether the user wants to proceed with the upgrade.
  * Reports errors to both the user and the console.
- * @returns the `UpgradeParams` needed to start the upgrade, if the upgrade is possible and was confirmed by the user, or `undefined` otherwise.
  */
 async function checkAndConfirmDatabaseUpgrade(
-  qs: qsClient.QueryServerClient, db: DatabaseItem, targetDbScheme: vscode.Uri, upgradesDirectories: vscode.Uri[]
-): Promise<messages.UpgradeParams | undefined> {
-  if (db.contents === undefined || db.contents.dbSchemeUri === undefined) {
-    helpers.showAndLogErrorMessage('Database is invalid, and cannot be upgraded.');
-    return;
-  }
-  const params: messages.UpgradeParams = {
-    fromDbscheme: db.contents.dbSchemeUri.fsPath,
-    toDbscheme: targetDbScheme.fsPath,
-    additionalUpgrades: upgradesDirectories.map(uri => uri.fsPath)
-  };
+  compiled: messages.CompiledUpgrades,
+  db: DatabaseItem,
+  quiet: boolean
+): Promise<void> {
 
-  let checkUpgradeResult: messages.CheckUpgradeResult;
-  try {
-    qs.logger.log('Checking database upgrade...');
-    checkUpgradeResult = await checkDatabaseUpgrade(qs, params);
-  }
-  catch (e) {
-    helpers.showAndLogErrorMessage(`Database cannot be upgraded: ${e}`);
-    return;
-  }
-  finally {
-    qs.logger.log('Done checking database upgrade.');
-  }
-
-  const checkedUpgrades = checkUpgradeResult.checkedUpgrades;
-  if (checkedUpgrades === undefined) {
-    const error = checkUpgradeResult.upgradeError || '[no error message available]';
-    await helpers.showAndLogErrorMessage(`Database cannot be upgraded: ${error}`);
-    return;
-  }
-
-  if (checkedUpgrades.scripts.length === 0) {
-    await helpers.showAndLogInformationMessage('Database is already up to date; nothing to do.');
-    return;
-  }
-
-  let curSha = checkedUpgrades.initialSha;
   let descriptionMessage = '';
-  for (const script of checkedUpgrades.scripts) {
+  const descriptions = getUpgradeDescriptions(compiled);
+  for (const script of descriptions) {
     descriptionMessage += `Would perform upgrade: ${script.description}\n`;
     descriptionMessage += `\t-> Compatibility: ${script.compatibility}\n`;
-    curSha = script.newSha;
   }
+  logger.log(descriptionMessage);
 
-  const targetSha = checkedUpgrades.targetSha;
-  if (curSha != targetSha) {
-    // Newlines aren't rendered in notifications: https://github.com/microsoft/vscode/issues/48900
-    // A modal dialog would be rendered better, but is more intrusive.
-    await helpers.showAndLogErrorMessage(`Database cannot be upgraded to the target database scheme.
-    Can upgrade from ${checkedUpgrades.initialSha} (current) to ${curSha}, but cannot reach ${targetSha} (target).`);
-    // TODO: give a more informative message if we think the DB is ahead of the target DB scheme
+
+  // If the quiet flag is set, do the upgrade without a popup.
+  if (quiet) {
     return;
   }
 
-  logger.log(descriptionMessage);
   // Ask the user to confirm the upgrade.
 
   const showLogItem: vscode.MessageItem = { title: 'No, Show Changes', isCloseAffordance: true };
@@ -97,88 +132,99 @@ async function checkAndConfirmDatabaseUpgrade(
     logger.outputChannel.show();
   }
 
-  if (chosenItem === yesItem) {
-    return params;
-  }
-  else {
+  if (chosenItem !== yesItem) {
     throw new UserCancellationException('User cancelled the database upgrade.');
   }
 }
 
+/**
+ * Get the descriptions from a compiled upgrade
+ */
+function getUpgradeDescriptions(compiled: messages.CompiledUpgrades): messages.UpgradeDescription[] {
+  // We use the presence of compiledUpgradeFile to check
+  // if it is multifile or not. We need to explicitly check undefined
+  // as the types claim the empty string is a valid value
+  if (compiled.compiledUpgradeFile === undefined) {
+    return compiled.scripts.map(script => script.description);
+  } else {
+    return compiled.descriptions;
+  }
+}
+
 /**
  * Command handler for 'Upgrade Database'.
  * Attempts to upgrade the given database to the given target DB scheme, using the given directory of upgrades.
  * First performs a dry-run and prompts the user to confirm the upgrade.
  * Reports errors during compilation and evaluation of upgrades to the user.
  */
-export async function upgradeDatabase(
-  qs: qsClient.QueryServerClient, db: DatabaseItem, targetDbScheme: vscode.Uri, upgradesDirectories: vscode.Uri[]
+export async function upgradeDatabaseExplicit(
+  qs: qsClient.QueryServerClient,
+  db: DatabaseItem,
+  progress: ProgressCallback,
+  token: vscode.CancellationToken,
 ): Promise<messages.RunUpgradeResult | undefined> {
-  const upgradeParams = await checkAndConfirmDatabaseUpgrade(qs, db, targetDbScheme, upgradesDirectories);
 
-  if (upgradeParams === undefined) {
-    return;
+  const searchPath: string[] = getOnDiskWorkspaceFolders();
+
+  if (!db?.contents?.dbSchemeUri) {
+    throw new Error('Database is invalid, and cannot be upgraded.');
   }
+  const upgradeInfo = await qs.cliServer.resolveUpgrades(
+    db.contents.dbSchemeUri.fsPath,
+    searchPath,
+    false
+  );
 
-  let compileUpgradeResult: messages.CompileUpgradeResult;
+  const { scripts, finalDbscheme } = upgradeInfo;
+
+  if (finalDbscheme === undefined) {
+    throw new Error('Could not determine target dbscheme to upgrade to.');
+  }
+  const currentUpgradeTmp = await tmp.dir({ dir: upgradesTmpDir.name, prefix: 'upgrade_', keep: false, unsafeCleanup: true });
   try {
-    compileUpgradeResult = await compileDatabaseUpgrade(qs, upgradeParams);
-  }
-  catch (e) {
-    helpers.showAndLogErrorMessage(`Compilation of database upgrades failed: ${e}`);
-    return;
-  }
-  finally {
-    qs.logger.log('Done compiling database upgrade.');
-  }
+    let compileUpgradeResult: messages.CompileUpgradeResult;
+    try {
+      compileUpgradeResult = await compileDatabaseUpgrade(qs, db, finalDbscheme, scripts, currentUpgradeTmp, progress, token);
+    }
+    catch (e) {
+      showAndLogErrorMessage(`Compilation of database upgrades failed: ${e}`);
+      return;
+    }
+    finally {
+      qs.logger.log('Done compiling database upgrade.');
+    }
 
-  if (compileUpgradeResult.compiledUpgrades === undefined) {
-    const error = compileUpgradeResult.error || '[no error message available]';
-    helpers.showAndLogErrorMessage(`Compilation of database upgrades failed: ${error}`);
-    return;
-  }
+    if (!compileUpgradeResult.compiledUpgrades) {
+      const error = compileUpgradeResult.error || '[no error message available]';
+      showAndLogErrorMessage(`Compilation of database upgrades failed: ${error}`);
+      return;
+    }
 
-  try {
-    qs.logger.log('Running the following database upgrade:');
-    qs.logger.log(compileUpgradeResult.compiledUpgrades.scripts.map(s => s.description.description).join('\n'));
-    return await runDatabaseUpgrade(qs, db, compileUpgradeResult.compiledUpgrades);
-  }
-  catch (e) {
-    helpers.showAndLogErrorMessage(`Database upgrade failed: ${e}`);
-    return;
-  }
-  finally {
-    qs.logger.log('Done running database upgrade.');
-  }
-}
+    await checkAndConfirmDatabaseUpgrade(compileUpgradeResult.compiledUpgrades, db, qs.cliServer.quiet);
 
-async function checkDatabaseUpgrade(
-  qs: qsClient.QueryServerClient, upgradeParams: messages.UpgradeParams
-): Promise<messages.CheckUpgradeResult> {
-  return helpers.withProgress({
-    location: vscode.ProgressLocation.Notification,
-    title: 'Checking for database upgrades',
-    cancellable: true,
-  }, (progress, token) => qs.sendRequest(messages.checkUpgrade, upgradeParams, token, progress));
-}
+    try {
+      qs.logger.log('Running the following database upgrade:');
 
-async function compileDatabaseUpgrade(
-  qs: qsClient.QueryServerClient, upgradeParams: messages.UpgradeParams
-): Promise<messages.CompileUpgradeResult> {
-  const params: messages.CompileUpgradeParams = {
-    upgrade: upgradeParams,
-    upgradeTempDir: upgradesTmpDir.name
-  };
-
-  return helpers.withProgress({
-    location: vscode.ProgressLocation.Notification,
-    title: 'Compiling database upgrades',
-    cancellable: true,
-  }, (progress, token) => qs.sendRequest(messages.compileUpgrade, params, token, progress));
+      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}`);
+      return;
+    } finally {
+      qs.logger.log('Done running database upgrade.');
+    }
+  } finally {
+    currentUpgradeTmp.cleanup();
+  }
 }
 
 async function runDatabaseUpgrade(
-  qs: qsClient.QueryServerClient, db: DatabaseItem, upgrades: messages.CompiledUpgrades
+  qs: qsClient.QueryServerClient,
+  db: DatabaseItem,
+  upgrades: messages.CompiledUpgrades,
+  progress: ProgressCallback,
+  token: vscode.CancellationToken,
 ): Promise<messages.RunUpgradeResult> {
 
   if (db.contents === undefined || db.contents.datasetUri === undefined) {
@@ -195,9 +241,5 @@ async function runDatabaseUpgrade(
     toRun: upgrades
   };
 
-  return helpers.withProgress({
-    location: vscode.ProgressLocation.Notification,
-    title: 'Running database upgrades',
-    cancellable: true,
-  }, (progress, token) => qs.sendRequest(messages.runUpgrade, params, token, progress));
+  return qs.sendRequest(messages.runUpgrade, params, token, progress);
 }

extensions/ql-vscode/src/view/RawTableHeader.tsx

@@ -1,12 +1,12 @@
 import * as React from 'react';
 
 import { vscode } from './vscode-api';
-import { RawResultsSortState, SortDirection } from '../interface-types';
+import { RawResultsSortState, SortDirection } from '../pure/interface-types';
 import { nextSortDirection } from './result-table-utils';
-import { ColumnSchema } from '../bqrs-types';
+import { Column } from '../pure/bqrs-cli-types';
 
 interface Props {
-  readonly columns: readonly ColumnSchema[];
+  readonly columns: readonly Column[];
   readonly schemaName: string;
   readonly sortState?: RawResultsSortState;
   readonly preventSort?: boolean;
@@ -31,9 +31,9 @@ function toggleSortStateForColumn(
     nextDirection === undefined
       ? undefined
       : {
-          columnIndex: index,
-          sortDirection: nextDirection,
-        };
+        columnIndex: index,
+        sortDirection: nextDirection,
+      };
   vscode.postMessage({
     t: 'changeSort',
     resultSetName: schemaName,
@@ -46,7 +46,7 @@ export default function RawTableHeader(props: Props) {
     <thead>
       <tr>
         {[
-           (
+          (
             <th key={-1}>
               <b>#</b>
             </th>

extensions/ql-vscode/src/view/RawTableRow.tsx

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { ResultRow } from '../adapt';
+import { ResultRow } from '../pure/bqrs-cli-types';
 import { zebraStripe } from './result-table-utils';
 import RawTableValue from './RawTableValue';
 
@@ -23,6 +23,6 @@ export default function RawTableRow(props: Props) {
           />
         </td>
       ))}
-  </tr>
+    </tr>
   );
 }

extensions/ql-vscode/src/view/RawTableValue.tsx

@@ -1,22 +1,22 @@
 import * as React from 'react';
 
-import { ResultValue } from '../adapt';
 import { renderLocation } from './result-table-utils';
+import { ColumnValue } from '../pure/bqrs-cli-types';
 
 interface Props {
-  value: ResultValue;
+  value: ColumnValue;
   databaseUri: string;
 }
 
 export default function RawTableValue(props: Props): JSX.Element {
   const v = props.value;
-  if (typeof v === 'string') {
-    return <span>{v}</span>;
-  }
-  else if ('uri' in v) {
-    return <a href={v.uri}>{v.uri}</a>;
-  }
-  else {
-    return renderLocation(v.location, v.label, props.databaseUri);
+  if (
+    typeof v === 'string'
+    || typeof v === 'number'
+    || typeof v === 'boolean'
+  ) {
+    return <span>{v.toString()}</span>;
   }
+
+  return renderLocation(v.url, v.label, props.databaseUri);
 }

extensions/ql-vscode/src/view/alert-table.tsx

@@ -1,15 +1,19 @@
 import * as path from 'path';
 import * as React from 'react';
 import * as Sarif from 'sarif';
-import * as Keys from '../result-keys';
-import { LocationStyle } from '../bqrs-types';
+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 { onNavigation, NavigationEvent } from './results';
-import { PathTableResultSet } from '../interface-types';
-import { parseSarifPlainTextMessage, parseSarifLocation } from '../sarif-utils';
-import { InterpretedResultsSortColumn, SortDirection, InterpretedResultsSortState } from '../interface-types';
+import { PathTableResultSet } from '../pure/interface-types';
+import {
+  parseSarifPlainTextMessage,
+  parseSarifLocation,
+  isNoLocation
+} from '../pure/sarif-utils';
+import { InterpretedResultsSortColumn, SortDirection, InterpretedResultsSortState } from '../pure/interface-types';
 import { vscode } from './vscode-api';
+import { isWholeFileLoc, isLineColumnLoc } from '../pure/bqrs-utils';
 
 export type PathTableProps = ResultTableProps & { resultSet: PathTableResultSet };
 export interface PathTableState {
@@ -98,20 +102,18 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
         relatedLocationsById[loc.id!] = loc;
       }
 
-      const result: JSX.Element[] = [];
       // match things like `[link-text](related-location-id)`
       const parts = parseSarifPlainTextMessage(msg);
 
-
-      for (const part of parts) {
+      return parts.map((part, i) => {
         if (typeof part === 'string') {
-          result.push(<span>{part} </span>);
+          return <span key={i}>{part}</span>;
         } else {
           const renderedLocation = renderSarifLocationWithText(part.text, relatedLocationsById[part.dest],
             undefined);
-          result.push(<span>{renderedLocation} </span>);
+          return <span key={i}>{renderedLocation}</span>;
         }
-      } return result;
+      });
     }
 
     function renderNonLocation(msg: string | undefined, locationHint: string): JSX.Element | undefined {
@@ -131,34 +133,54 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
 
     function renderSarifLocationWithText(text: string | undefined, loc: Sarif.Location, pathNodeKey: Keys.PathNode | undefined): JSX.Element | undefined {
       const parsedLoc = parseSarifLocation(loc, sourceLocationPrefix);
-      switch (parsedLoc.t) {
-        case 'NoLocation':
-          return renderNonLocation(text, parsedLoc.hint);
-        case LocationStyle.FivePart:
-        case LocationStyle.WholeFile:
-          return renderLocation(parsedLoc, text, databaseUri, undefined, updateSelectionCallback(pathNodeKey));
+      if ('hint' in parsedLoc) {
+        return renderNonLocation(text, parsedLoc.hint);
+      } else if (isWholeFileLoc(parsedLoc) || isLineColumnLoc(parsedLoc)) {
+        return renderLocation(
+          parsedLoc,
+          text,
+          databaseUri,
+          undefined,
+          updateSelectionCallback(pathNodeKey)
+        );
+      } else {
+        return undefined;
       }
-      return undefined;
     }
 
     /**
      * Render sarif location as a link with the text being simply a
      * human-readable form of the location itself.
      */
-    function renderSarifLocation(loc: Sarif.Location, pathNodeKey: Keys.PathNode | undefined): JSX.Element | undefined {
+    function renderSarifLocation(
+      loc: Sarif.Location,
+      pathNodeKey: Keys.PathNode | undefined
+    ): JSX.Element | undefined {
       const parsedLoc = parseSarifLocation(loc, sourceLocationPrefix);
-      let shortLocation, longLocation: string;
-      switch (parsedLoc.t) {
-        case 'NoLocation':
-          return renderNonLocation('[no location]', parsedLoc.hint);
-        case LocationStyle.WholeFile:
-          shortLocation = `${path.basename(parsedLoc.userVisibleFile)}`;
-          longLocation = `${parsedLoc.userVisibleFile}`;
-          return renderLocation(parsedLoc, shortLocation, databaseUri, longLocation, updateSelectionCallback(pathNodeKey));
-        case LocationStyle.FivePart:
-          shortLocation = `${path.basename(parsedLoc.userVisibleFile)}:${parsedLoc.lineStart}:${parsedLoc.colStart}`;
-          longLocation = `${parsedLoc.userVisibleFile}`;
-          return renderLocation(parsedLoc, shortLocation, databaseUri, longLocation, updateSelectionCallback(pathNodeKey));
+      if ('hint' in parsedLoc) {
+        return renderNonLocation('[no location]', parsedLoc.hint);
+      } else if (isWholeFileLoc(parsedLoc)) {
+        const shortLocation = `${path.basename(parsedLoc.userVisibleFile)}`;
+        const longLocation = `${parsedLoc.userVisibleFile}`;
+        return renderLocation(
+          parsedLoc,
+          shortLocation,
+          databaseUri,
+          longLocation,
+          updateSelectionCallback(pathNodeKey)
+        );
+      } else if (isLineColumnLoc(parsedLoc)) {
+        const shortLocation = `${path.basename(parsedLoc.userVisibleFile)}:${parsedLoc.startLine}:${parsedLoc.startColumn}`;
+        const longLocation = `${parsedLoc.userVisibleFile}`;
+        return renderLocation(
+          parsedLoc,
+          shortLocation,
+          databaseUri,
+          longLocation,
+          updateSelectionCallback(pathNodeKey)
+        );
+      } else {
+        return undefined;
       }
     }
 
@@ -166,9 +188,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
       return (e) => this.toggle(e, indices);
     };
 
-    if (resultSet.sarif.runs.length === 0 ||
-      resultSet.sarif.runs[0].results === undefined ||
-      resultSet.sarif.runs[0].results.length === 0) {
+    if (!resultSet.sarif.runs?.[0]?.results?.length) {
       return this.renderNoResults();
     }
 
@@ -205,7 +225,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
           [expansionIndex];
 
         rows.push(
-          <tr {...zebraStripe(resultIndex)}>
+          <tr {...zebraStripe(resultIndex)} key={resultIndex}>
             <td className="vscode-codeql__icon-cell vscode-codeql__dropdown-cell" onMouseDown={toggler(indices)}>
               {indicator}
             </td>
@@ -226,7 +246,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
           if (currentResultExpanded) {
             const indicator = currentPathExpanded ? octicons.chevronDown : octicons.chevronRight;
             rows.push(
-              <tr {...zebraStripe(resultIndex)}>
+              <tr {...zebraStripe(resultIndex)} key={`${resultIndex}-${pathIndex}`}>
                 <td className="vscode-codeql__icon-cell"><span className="vscode-codeql__vertical-rule"></span></td>
                 <td className="vscode-codeql__icon-cell vscode-codeql__dropdown-cell" onMouseDown={toggler([expansionIndex])}>{indicator}</td>
                 <td className="vscode-codeql__text-center" colSpan={3}>
@@ -252,7 +272,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
               const stepIndex = pathNodeIndex + 1; // Convert to 1-based
               const zebraIndex = resultIndex + stepIndex;
               rows.push(
-                <tr className={isSelected ? 'vscode-codeql__selected-path-node' : undefined}>
+                <tr className={isSelected ? 'vscode-codeql__selected-path-node' : undefined} key={`${resultIndex}-${pathIndex}-${pathNodeIndex}`}>
                   <td className="vscode-codeql__icon-cell"><span className="vscode-codeql__vertical-rule"></span></td>
                   <td className="vscode-codeql__icon-cell"><span className="vscode-codeql__vertical-rule"></span></td>
                   <td {...selectableZebraStripe(isSelected, zebraIndex, 'vscode-codeql__path-index-cell')}>{stepIndex}</td>
@@ -267,9 +287,13 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
     });
 
     if (numTruncatedResults > 0) {
-      rows.push(<tr><td colSpan={5} style={{ textAlign: 'center', fontStyle: 'italic' }}>
-        Too many results to show at once. {numTruncatedResults} result(s) omitted.
-      </td></tr>);
+      rows.push(
+        <tr key="truncatd-message">
+          <td colSpan={5} style={{ textAlign: 'center', fontStyle: 'italic' }}>
+            Too many results to show at once. {numTruncatedResults} result(s) omitted.
+          </td>
+        </tr>
+      );
     }
 
     return <table className={className}>
@@ -290,10 +314,14 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
       if (nextIndex < 0 || nextIndex >= path.locations.length) return prevState;
 
       const sarifLoc = path.locations[nextIndex].location;
-      if (sarifLoc === undefined) return prevState;
+      if (sarifLoc === undefined) {
+        return prevState;
+      }
 
       const loc = parseSarifLocation(sarifLoc, this.props.resultSet.sourceLocationPrefix);
-      if (loc.t === 'NoLocation') return prevState;
+      if (isNoLocation(loc)) {
+        return prevState;
+      }
 
       jumpToLocation(loc, this.props.databaseUri);
       const newSelection = { ...selectedPathNode, pathNodeIndex: nextIndex };

extensions/ql-vscode/src/view/raw-results-table.tsx

@@ -1,10 +1,10 @@
 import * as React from 'react';
 import { ResultTableProps, className } from './result-table-utils';
-import { RAW_RESULTS_LIMIT, RawResultsSortState } from '../interface-types';
-import { RawTableResultSet } from '../interface-types';
+import { RAW_RESULTS_LIMIT, RawResultsSortState } from '../pure/interface-types';
+import { RawTableResultSet } from '../pure/interface-types';
 import RawTableHeader from './RawTableHeader';
 import RawTableRow from './RawTableRow';
-import { ResultRow } from '../adapt';
+import { ResultRow } from '../pure/bqrs-cli-types';
 
 export type RawTableProps = ResultTableProps & {
   resultSet: RawTableResultSet;

extensions/ql-vscode/src/view/result-table-utils.tsx

@@ -1,9 +1,9 @@
 import * as React from 'react';
-import { LocationValue, ResolvableLocationValue } from '../bqrs-types';
-import { tryGetResolvableLocation } from '../bqrs-utils';
-import { RawResultsSortState, QueryMetadata, SortDirection } from '../interface-types';
-import { assertNever } from '../helpers-pure';
-import { ResultSet } from '../interface-types';
+import { UrlValue, ResolvableLocationValue } from '../pure/bqrs-cli-types';
+import { isStringLoc, tryGetResolvableLocation } from '../pure/bqrs-utils';
+import { RawResultsSortState, QueryMetadata, SortDirection } from '../pure/interface-types';
+import { assertNever } from '../pure/helpers-pure';
+import { ResultSet } from '../pure/interface-types';
 import { vscode } from './vscode-api';
 
 export interface ResultTableProps {
@@ -28,7 +28,8 @@ export interface ResultTableProps {
 }
 
 export const className = 'vscode-codeql__result-table';
-export const tableSelectionHeaderClassName = 'vscode-codeql__table-selection-header';
+export const tableHeaderClassName = 'vscode-codeql__table-selection-header';
+export const tableHeaderItemClassName = 'vscode-codeql__table-selection-header-item';
 export const alertExtrasClassName = `${className}-alert-extras`;
 export const toggleDiagnosticsClassName = `${className}-toggle-diagnostics`;
 export const evenRowClassName = 'vscode-codeql__result-table-row--even';
@@ -45,7 +46,9 @@ export function jumpToLocationHandler(
     jumpToLocation(loc, databaseUri);
     e.preventDefault();
     e.stopPropagation();
-    if (callback) callback();
+    if (callback) {
+      callback();
+    }
   };
 }
 
@@ -57,31 +60,51 @@ export function jumpToLocation(loc: ResolvableLocationValue, databaseUri: string
   });
 }
 
+export function openFile(filePath: string): void {
+  vscode.postMessage({
+    t: 'openFile',
+    filePath
+  });
+}
+
 /**
  * Render a location as a link which when clicked displays the original location.
  */
-export function renderLocation(loc: LocationValue | undefined, label: string | undefined,
-  databaseUri: string, title?: string, callback?: () => void): JSX.Element {
+export function renderLocation(
+  loc: UrlValue | undefined,
+  label: string | undefined,
+  databaseUri: string,
+  title?: string,
+  callback?: () => void
+): JSX.Element {
 
   // If the label was empty, use a placeholder instead, so the link is still clickable.
   let displayLabel = label;
-  if (label === undefined || label === '')
+  if (!label) {
     displayLabel = '[empty string]';
-  else if (label.match(/^\s+$/))
+  } else if (label.match(/^\s+$/)) {
     displayLabel = `[whitespace: "${label}"]`;
+  }
 
-  if (loc !== undefined) {
-    const resolvableLoc = tryGetResolvableLocation(loc);
-    if (resolvableLoc !== undefined) {
-      return <a href="#"
+  if (loc === undefined) {
+    return <span>{displayLabel}</span>;
+  } else if (isStringLoc(loc)) {
+    return <a href={loc}>{loc}</a>;
+  }
+
+  const resolvableLoc = tryGetResolvableLocation(loc);
+  if (resolvableLoc !== undefined) {
+    return (
+      <a href="#"
         className="vscode-codeql__result-table-location-link"
         title={title}
-        onClick={jumpToLocationHandler(resolvableLoc, databaseUri, callback)}>{displayLabel}</a>;
-    } else {
-      return <span title={title}>{displayLabel}</span>;
-    }
+        onClick={jumpToLocationHandler(resolvableLoc, databaseUri, callback)}>
+        {displayLabel}
+      </a>
+    );
+  } else {
+    return <span title={title}>{displayLabel}</span>;
   }
-  return <span />;
 }
 
 /**

extensions/ql-vscode/src/view/result-tables.tsx

@@ -6,19 +6,28 @@ import {
   QueryMetadata,
   ResultsPaths,
   InterpretedResultsSortState,
-  RAW_RESULTS_PAGE_SIZE,
   ResultSet,
   ALERTS_TABLE_NAME,
   SELECT_TABLE_NAME,
   getDefaultResultSetName,
-} from '../interface-types';
+  ParsedResultSets,
+  IntoResultsViewMsg,
+} from '../pure/interface-types';
 import { PathTable } from './alert-table';
 import { RawTable } from './raw-results-table';
-import { ResultTableProps, tableSelectionHeaderClassName, toggleDiagnosticsClassName, alertExtrasClassName } from './result-table-utils';
-import { ParsedResultSets } from '../adapt';
+import {
+  ResultTableProps,
+  tableHeaderClassName,
+  tableHeaderItemClassName,
+  toggleDiagnosticsClassName,
+  alertExtrasClassName,
+  openFile
+} from './result-table-utils';
 import { vscode } from './vscode-api';
 
 
+const FILE_PATH_REGEX = /^(?:.+[\\/])*(.+)$/;
+
 /**
  * Properties for the `ResultTables` component.
  */
@@ -33,6 +42,8 @@ export interface ResultTablesProps {
   sortStates: Map<string, RawResultsSortState>;
   interpretedSortState?: InterpretedResultsSortState;
   isLoadingNewResults: boolean;
+  queryName: string;
+  queryPath: string;
 }
 
 /**
@@ -41,6 +52,7 @@ export interface ResultTablesProps {
 interface ResultTablesState {
   selectedTable: string; // name of selected result set
   selectedPage: string; // stringified selected page
+  problemsViewSelected: boolean;
 }
 
 const UPDATING_RESULTS_TEXT_CLASS_NAME = 'vscode-codeql__result-tables-updating-text';
@@ -48,7 +60,7 @@ const UPDATING_RESULTS_TEXT_CLASS_NAME = 'vscode-codeql__result-tables-updating-
 function getResultCount(resultSet: ResultSet): number {
   switch (resultSet.t) {
     case 'RawResultSet':
-      return resultSet.schema.tupleCount;
+      return resultSet.schema.rows;
     case 'SarifResultSet':
       return resultSet.numTotalResults;
   }
@@ -56,7 +68,7 @@ function getResultCount(resultSet: ResultSet): number {
 
 function renderResultCountString(resultSet: ResultSet): JSX.Element {
   const resultCount = getResultCount(resultSet);
-  return <span className="number-of-results">
+  return <span className={tableHeaderItemClassName}>
     {resultCount} {resultCount === 1 ? 'result' : 'results'}
   </span>;
 }
@@ -81,7 +93,11 @@ export class ResultTables
         // unused stubs because a SarifResultSet schema isn't used the
         // same way as a RawResultSet. Probably should pull `name` field
         // out.
-        schema: { name: ALERTS_TABLE_NAME, version: 0, columns: [], tupleCount: 1 },
+        schema: {
+          name: ALERTS_TABLE_NAME,
+          rows: 1,
+          columns: []
+        },
         name: ALERTS_TABLE_NAME,
         ...this.props.interpretation,
       });
@@ -89,7 +105,7 @@ export class ResultTables
     return resultSets;
   }
 
-  private getResultSetNames(resultSets: ResultSet[]): string[] {
+  private getResultSetNames(): string[] {
     return this.props.parsedResultSets.resultSetNames.concat([ALERTS_TABLE_NAME]);
   }
 
@@ -97,7 +113,17 @@ export class ResultTables
     super(props);
     const selectedTable = props.parsedResultSets.selectedTable || getDefaultResultSet(this.getResultSets());
     const selectedPage = (props.parsedResultSets.pageNumber + 1) + '';
-    this.state = { selectedTable, selectedPage };
+    this.state = {
+      selectedTable,
+      selectedPage,
+      problemsViewSelected: false
+    };
+  }
+
+  untoggleProblemsView() {
+    this.setState({
+      problemsViewSelected: false
+    });
   }
 
   private onTableSelectionChange = (event: React.ChangeEvent<HTMLSelectElement>): void => {
@@ -111,31 +137,44 @@ export class ResultTables
 
   private alertTableExtras(): JSX.Element | undefined {
     const { database, resultsPath, metadata, origResultsPaths } = this.props;
+    const handleCheckboxChanged = (e: React.ChangeEvent<HTMLInputElement>) => {
+      if (e.target.checked === this.state.problemsViewSelected) {
+        // no change
+        return;
+      }
+      this.setState({
+        problemsViewSelected: e.target.checked
+      });
+      if (resultsPath !== undefined) {
+        vscode.postMessage({
+          t: 'toggleDiagnostics',
+          origResultsPaths: origResultsPaths,
+          databaseUri: database.databaseUri,
+          visible: e.target.checked,
+          metadata: metadata
+        });
+      }
+    };
 
-    const displayProblemsAsAlertsToggle =
-      <div className={toggleDiagnosticsClassName}>
-        <input type="checkbox" id="toggle-diagnostics" name="toggle-diagnostics" onChange={(e) => {
-          if (resultsPath !== undefined) {
-            vscode.postMessage({
-              t: 'toggleDiagnostics',
-              origResultsPaths: origResultsPaths,
-              databaseUri: database.databaseUri,
-              visible: e.target.checked,
-              metadata: metadata
-            });
-          }
-        }} />
-        <label htmlFor="toggle-diagnostics">Show results in Problems view</label>
-      </div>;
-
-    return <div className={alertExtrasClassName}>
-      {displayProblemsAsAlertsToggle}
-    </div>;
+    return (
+      <div className={alertExtrasClassName}>
+        <div className={toggleDiagnosticsClassName}>
+          <input
+            type="checkbox"
+            id="toggle-diagnostics"
+            name="toggle-diagnostics"
+            onChange={handleCheckboxChanged}
+            checked={this.state.problemsViewSelected}
+          />
+          <label htmlFor="toggle-diagnostics">Show results in Problems view</label>
+        </div>
+      </div>
+    );
   }
 
   getOffset(): number {
     const { parsedResultSets } = this.props;
-    return parsedResultSets.pageNumber * RAW_RESULTS_PAGE_SIZE;
+    return parsedResultSets.pageNumber * parsedResultSets.pageSize;
   }
 
   renderPageButtons(): JSX.Element {
@@ -180,32 +219,50 @@ export class ResultTables
       });
     };
 
-    return <span className="vscode-codeql__table-selection-header">
-      <button onClick={prevPage} >&#xab;</button>
-      <input
-        type="number"
-        size={3}
-        value={this.state.selectedPage}
-        onChange={onChange}
-        onBlur={e => choosePage(e.target.value)}
-        onKeyDown={e => {
-          if (e.keyCode === 13) {
-            choosePage((e.target as HTMLInputElement).value);
-          }
-        }
-        }
-      />
-      <span>
-        / {numPages}
+    const openQuery = () => {
+      openFile(this.props.queryPath);
+    };
+    const fileName = FILE_PATH_REGEX.exec(this.props.queryPath)?.[1] || 'query';
+
+    return (
+      <span className="vscode-codeql__table-selection-pagination">
+        <button onClick={prevPage} >&#xab;</button>
+        <input
+          type="number"
+          size={3}
+          value={this.state.selectedPage}
+          min="1"
+          max={numPages}
+          onChange={onChange}
+          onBlur={e => choosePage(e.target.value)}
+          onKeyDown={e => {
+            if (e.keyCode === 13) {
+              choosePage((e.target as HTMLInputElement).value);
+            }
+          }}
+        />
+        <span>
+          /&nbsp;{numPages}
+        </span>
+        <button value=">" onClick={nextPage} >&#xbb;</button>
+        <div className={tableHeaderItemClassName}>
+          {this.props.queryName}
+        </div>
+        <div className={tableHeaderItemClassName}>
+          <a
+            href="#"
+            onClick={openQuery}
+            className="vscode-codeql__result-table-location-link"
+          >Open {fileName}</a>
+        </div>
       </span>
-      <button value=">" onClick={nextPage} >&#xbb;</button>
-    </span>;
+    );
   }
 
   render(): React.ReactNode {
     const { selectedTable } = this.state;
     const resultSets = this.getResultSets();
-    const resultSetNames = this.getResultSetNames(resultSets);
+    const resultSetNames = this.getResultSetNames();
 
     const resultSet = resultSets.find(resultSet => resultSet.schema.name == selectedTable);
     const nonemptyRawResults = resultSets.some(resultSet => resultSet.t == 'RawResultSet' && resultSet.rows.length > 0);
@@ -213,32 +270,67 @@ export class ResultTables
 
     const resultSetOptions =
       resultSetNames.map(name => <option key={name} value={name}>{name}</option>);
-
-    return <div>
-      {this.renderPageButtons()}
-      <div className={tableSelectionHeaderClassName}>
-        <select value={selectedTable} onChange={this.onTableSelectionChange}>
-          {resultSetOptions}
-        </select>
-        {numberOfResults}
-        {selectedTable === ALERTS_TABLE_NAME ? this.alertTableExtras() : undefined}
+    return (
+      <div>
+        {this.renderPageButtons()}
+        <div className={tableHeaderClassName}>
+        </div>
+        <div className={tableHeaderClassName}>
+          <select value={selectedTable} onChange={this.onTableSelectionChange}>
+            {resultSetOptions}
+          </select>
+          {numberOfResults}
+          {selectedTable === ALERTS_TABLE_NAME ? this.alertTableExtras() : undefined}
+          {
+            this.props.isLoadingNewResults ?
+              <span className={UPDATING_RESULTS_TEXT_CLASS_NAME}>Updating results…</span>
+              : null
+          }
+        </div>
         {
-          this.props.isLoadingNewResults ?
-            <span className={UPDATING_RESULTS_TEXT_CLASS_NAME}>Updating results…</span>
-            : null
+          resultSet &&
+          <ResultTable key={resultSet.schema.name} resultSet={resultSet}
+            databaseUri={this.props.database.databaseUri}
+            resultsPath={this.props.resultsPath}
+            sortState={this.props.sortStates.get(resultSet.schema.name)}
+            nonemptyRawResults={nonemptyRawResults}
+            showRawResults={() => { this.setState({ selectedTable: SELECT_TABLE_NAME }); }}
+            offset={this.getOffset()} />
         }
       </div>
-      {
-        resultSet &&
-        <ResultTable key={resultSet.schema.name} resultSet={resultSet}
-          databaseUri={this.props.database.databaseUri}
-          resultsPath={this.props.resultsPath}
-          sortState={this.props.sortStates.get(resultSet.schema.name)}
-          nonemptyRawResults={nonemptyRawResults}
-          showRawResults={() => { this.setState({ selectedTable: SELECT_TABLE_NAME }); }}
-          offset={this.getOffset()} />
-      }
-    </div>;
+    );
+  }
+
+  handleMessage(msg: IntoResultsViewMsg): void {
+    switch (msg.t) {
+      case 'untoggleShowProblems':
+        this.setState({
+          problemsViewSelected: false
+        });
+        break;
+
+      default:
+      // noop
+    }
+  }
+
+  // TODO: Duplicated from results.tsx consider a way to
+  // avoid this duplication
+  componentDidMount(): void {
+    this.vscodeMessageHandler = this.vscodeMessageHandler.bind(this);
+    window.addEventListener('message', this.vscodeMessageHandler);
+  }
+
+  componentWillUnmount(): void {
+    if (this.vscodeMessageHandler) {
+      window.removeEventListener('message', this.vscodeMessageHandler);
+    }
+  }
+
+  private vscodeMessageHandler(evt: MessageEvent) {
+    evt.origin === window.origin
+      ? this.handleMessage(evt.data as IntoResultsViewMsg)
+      : console.error(`Invalid event origin ${evt.origin}`);
   }
 }
 

extensions/ql-vscode/src/view/results.tsx

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import * as Rdom from 'react-dom';
-import { assertNever } from '../helpers-pure';
+import { assertNever } from '../pure/helpers-pure';
 import {
   DatabaseInfo,
   Interpretation,
@@ -11,13 +11,11 @@ import {
   QueryMetadata,
   ResultsPaths,
   ALERTS_TABLE_NAME,
-} from '../interface-types';
+  ParsedResultSets,
+} from '../pure/interface-types';
 import { EventHandlers as EventHandlerList } from './event-handler-list';
 import { ResultTables } from './result-tables';
-import {
-  ParsedResultSets,
-} from '../adapt';
-import { ResultSet } from '../interface-types';
+import { ResultSet } from '../pure/interface-types';
 import { vscode } from './vscode-api';
 
 /**
@@ -39,6 +37,8 @@ interface ResultsInfo {
    */
   shouldKeepOldResultsWhileRendering: boolean;
   metadata?: QueryMetadata;
+  queryName: string;
+  queryPath: string;
 }
 
 interface Results {
@@ -98,6 +98,8 @@ class App extends React.Component<{}, ResultsViewState> {
           shouldKeepOldResultsWhileRendering:
             msg.shouldKeepOldResultsWhileRendering,
           metadata: msg.metadata,
+          queryName: msg.queryName,
+          queryPath: msg.queryPath,
         });
 
         this.loadResults();
@@ -107,13 +109,18 @@ class App extends React.Component<{}, ResultsViewState> {
           resultsPath: '', // FIXME: Not used for interpreted, refactor so this is not needed
           parsedResultSets: {
             numPages: msg.numPages,
+            pageSize: msg.pageSize,
             numInterpretedPages: msg.numPages,
             resultSetNames: msg.resultSetNames,
             pageNumber: msg.pageNumber,
             resultSet: {
               t: 'SarifResultSet',
               name: ALERTS_TABLE_NAME,
-              schema: { name: ALERTS_TABLE_NAME, version: 0, columns: [], tupleCount: 1 },
+              schema: {
+                name: ALERTS_TABLE_NAME,
+                rows: 1,
+                columns: []
+              },
               ...msg.interpretation,
             },
             selectedTable: ALERTS_TABLE_NAME,
@@ -124,6 +131,8 @@ class App extends React.Component<{}, ResultsViewState> {
           interpretation: msg.interpretation,
           shouldKeepOldResultsWhileRendering: true,
           metadata: msg.metadata,
+          queryName: msg.queryName,
+          queryPath: msg.queryPath,
         });
         this.loadResults();
         break;
@@ -135,6 +144,11 @@ class App extends React.Component<{}, ResultsViewState> {
       case 'navigatePath':
         onNavigation.fire(msg);
         break;
+
+      case 'untoggleShowProblems':
+        // noop
+        break;
+
       default:
         assertNever(msg);
     }
@@ -170,11 +184,17 @@ class App extends React.Component<{}, ResultsViewState> {
     });
   }
 
-  private async getResultSets(
+  private getResultSets(
     resultsInfo: ResultsInfo
-  ): Promise<readonly ResultSet[]> {
+  ): readonly ResultSet[] {
     const parsedResultSets = resultsInfo.parsedResultSets;
-    return [{ t: 'RawResultSet', ...parsedResultSets.resultSet }];
+    const resultSet = parsedResultSets.resultSet;
+    if (!resultSet.t) {
+      throw new Error(
+        'Missing result set type. Should be either "SarifResultSet" or "RawResultSet".'
+      );
+    }
+    return [resultSet];
   }
 
   private async loadResults(): Promise<void> {
@@ -186,7 +206,7 @@ class App extends React.Component<{}, ResultsViewState> {
     let results: Results | null = null;
     let statusText = '';
     try {
-      const resultSets = await this.getResultSets(resultsInfo);
+      const resultSets = this.getResultSets(resultsInfo);
       results = {
         resultSets,
         database: resultsInfo.database,
@@ -266,6 +286,8 @@ class App extends React.Component<{}, ResultsViewState> {
             this.state.isExpectingResultsUpdate ||
             this.state.nextResultsInfo !== null
           }
+          queryName={displayedResults.resultsInfo.queryName}
+          queryPath={displayedResults.resultsInfo.queryPath}
         />
       );
     } else {
@@ -274,11 +296,7 @@ class App extends React.Component<{}, ResultsViewState> {
   }
 
   componentDidMount(): void {
-    this.vscodeMessageHandler = (evt) =>
-      evt.origin === window.origin
-        ? this.handleMessage(evt.data as IntoResultsViewMsg)
-        : console.error(`Invalid event origin ${evt.origin}`);
-
+    this.vscodeMessageHandler = this.vscodeMessageHandler.bind(this);
     window.addEventListener('message', this.vscodeMessageHandler);
   }
 
@@ -288,9 +306,11 @@ class App extends React.Component<{}, ResultsViewState> {
     }
   }
 
-  private vscodeMessageHandler:
-    | ((ev: MessageEvent) => void)
-    | undefined = undefined;
+  private vscodeMessageHandler(evt: MessageEvent) {
+    evt.origin === window.origin
+      ? this.handleMessage(evt.data as IntoResultsViewMsg)
+      : console.error(`Invalid event origin ${evt.origin}`);
+  }
 }
 
 Rdom.render(<App />, document.getElementById('root'));

extensions/ql-vscode/src/view/resultsView.css

@@ -8,13 +8,24 @@
   display: flex;
   padding: 0.5em 0;
   align-items: center;
+  justify-content: space-between;
+}
+
+.vscode-codeql__table-selection-pagination {
+  display: flex;
+  padding: 0.5em 0;
+  align-items: center;
+}
+
+.vscode-codeql__table-selection-header-item {
+  padding-left: 2em;
 }
 
 .vscode-codeql__table-selection-header select {
   border: 0;
 }
 
-.vscode-codeql__table-selection-header button {
+.vscode-codeql__table-selection-pagination button {
   padding: 0.3rem;
   margin: 0.2rem;
   border: 0;
@@ -25,11 +36,11 @@
   opacity: 0.8;
 }
 
-.vscode-codeql__table-selection-header button:hover {
+.vscode-codeql__table-selection-pagination button:hover {
   opacity: 1;
 }
 
-.vscode-codeql__table-selection-header input[type="number"] {
+.vscode-codeql__table-selection-pagination input[type="number"] {
   border-radius: 0;
   padding: 0.3rem;
   margin: 0.2rem;
@@ -185,10 +196,6 @@ td.vscode-codeql__path-index-cell {
   opacity: 0.6;
 }
 
-.number-of-results {
-  padding-left: 3em;
-}
-
 .vscode-codeql__compare-header {
   display: flex;
 }

extensions/ql-vscode/src/view/vscode-api.ts

@@ -1,4 +1,4 @@
-import { FromCompareViewMessage, FromResultsViewMsg } from '../interface-types';
+import { FromCompareViewMessage, FromResultsViewMsg } from '../pure/interface-types';
 
 export interface VsCodeApi {
   /**

extensions/ql-vscode/src/vscode-tests/cli-integration/data/qlpack.yml

@@ -0,0 +1,3 @@
+name: integration-test-queries-javascript
+version: 0.0.0
+libraryPathDependencies: codeql-javascript

extensions/ql-vscode/src/vscode-tests/cli-integration/data/simple-query.ql

@@ -0,0 +1,8 @@
+predicate edges(int i, int j) {
+  i = 1 and j = 2 or i = 2 and j = 3
+}
+
+
+from int i, int j
+where edges(i, j)
+select i, j

extensions/ql-vscode/src/vscode-tests/cli-integration/databases.test.ts

@@ -0,0 +1,84 @@
+import * as sinon from 'sinon';
+import * as path from 'path';
+import { fail } from 'assert';
+import { expect } from 'chai';
+import { extensions, CancellationToken, Uri, window } from 'vscode';
+
+import { CodeQLExtensionInterface } from '../../extension';
+import { DatabaseManager } from '../../databases';
+import { promptImportLgtmDatabase, importArchiveDatabase, promptImportInternetDatabase } from '../../databaseFetcher';
+import { ProgressCallback } from '../../commandRunner';
+import { dbLoc, DB_URL, storagePath } from './global.helper';
+
+/**
+ * Run various integration tests for databases
+ */
+describe('Databases', function() {
+  this.timeout(60000);
+
+  const LGTM_URL = 'https://lgtm.com/projects/g/aeisenberg/angular-bind-notifier/';
+
+  let databaseManager: DatabaseManager;
+  let sandbox: sinon.SinonSandbox;
+  let inputBoxStub: sinon.SinonStub;
+  let progressCallback: ProgressCallback;
+
+  beforeEach(async () => {
+    try {
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      if ('databaseManager' in extension) {
+        databaseManager = extension.databaseManager;
+      } else {
+        throw new Error('Extension not initialized. Make sure cli is downloaded and installed properly.');
+      }
+
+      sandbox = sinon.createSandbox();
+      // the uri.fsPath function on windows returns a lowercase drive letter
+      // so, force the storage path string to be lowercase, too.
+      progressCallback = sandbox.spy();
+      inputBoxStub = sandbox.stub(window, 'showInputBox');
+    } catch (e) {
+      fail(e);
+    }
+  });
+
+  afterEach(() => {
+    try {
+      sandbox.restore();
+    } catch (e) {
+      fail(e);
+    }
+  });
+
+  it('should add a database from a folder', async () => {
+    const progressCallback = sandbox.spy() as ProgressCallback;
+    const uri = Uri.file(dbLoc);
+    let dbItem = await importArchiveDatabase(uri.toString(true), databaseManager, storagePath, progressCallback, {} as CancellationToken);
+    expect(dbItem).to.be.eq(databaseManager.currentDatabaseItem);
+    expect(dbItem).to.be.eq(databaseManager.databaseItems[0]);
+    expect(dbItem).not.to.be.undefined;
+    dbItem = dbItem!;
+    expect(dbItem.name).to.eq('db');
+    expect(dbItem.databaseUri.fsPath).to.eq(path.join(storagePath, 'db', 'db'));
+  });
+
+  it('should add a database from lgtm with only one language', async () => {
+    inputBoxStub.resolves(LGTM_URL);
+    let dbItem = await promptImportLgtmDatabase(databaseManager, storagePath, progressCallback, {} as CancellationToken);
+    expect(dbItem).not.to.be.undefined;
+    dbItem = dbItem!;
+    expect(dbItem.name).to.eq('aeisenberg_angular-bind-notifier_106179a');
+    expect(dbItem.databaseUri.fsPath).to.eq(path.join(storagePath, 'javascript', 'aeisenberg_angular-bind-notifier_106179a'));
+  });
+
+  it('should add a database from a url', async () => {
+    inputBoxStub.resolves(DB_URL);
+
+    let dbItem = await promptImportInternetDatabase(databaseManager, storagePath, progressCallback, {} as CancellationToken);
+    expect(dbItem).not.to.be.undefined;
+    dbItem = dbItem!;
+    expect(dbItem.name).to.eq('db');
+    expect(dbItem.databaseUri.fsPath).to.eq(path.join(storagePath, 'simple-db', 'db'));
+  });
+
+});

extensions/ql-vscode/src/vscode-tests/cli-integration/global.helper.ts

@@ -0,0 +1,86 @@
+import * as path from 'path';
+import * as tmp from 'tmp';
+import * as fs from 'fs-extra';
+import fetch from 'node-fetch';
+
+import { fail } from 'assert';
+import { ConfigurationTarget, extensions, workspace } from 'vscode';
+import { CodeQLExtensionInterface } from '../../extension';
+
+// This file contains helpers shared between actual tests.
+
+export const DB_URL = 'https://github.com/github/vscode-codeql/files/5586722/simple-db.zip';
+
+// We need to resolve the path, but the final three segments won't exist until later, so we only resolve the
+// first portion of the path.
+export const dbLoc = path.join(fs.realpathSync(path.join(__dirname, '../../../')), 'build/tests/db.zip');
+export let storagePath: string;
+
+export default function(mocha: Mocha) {
+  // create an extension storage location
+  let removeStorage: tmp.DirResult['removeCallback'] | undefined;
+
+  // ensure the test database is downloaded
+  (mocha.options as any).globalSetup.push(
+    async () => {
+      fs.mkdirpSync(path.dirname(dbLoc));
+      if (!fs.existsSync(dbLoc)) {
+        try {
+          await new Promise((resolve, reject) => {
+            fetch(DB_URL).then(response => {
+              const dest = fs.createWriteStream(dbLoc);
+              response.body.pipe(dest);
+
+              response.body.on('error', reject);
+              dest.on('error', reject);
+              dest.on('close', () => {
+                resolve(dbLoc);
+              });
+            });
+          });
+        } catch (e) {
+          fail('Failed to download test database: ' + e);
+        }
+      }
+    }
+  );
+
+  // Set the CLI version here before activation to ensure we don't accidentally try to download a cli
+  (mocha.options as any).globalSetup.push(
+    async () => {
+      await workspace.getConfiguration().update('codeQL.cli.executablePath', process.env.CLI_PATH, ConfigurationTarget.Global);
+    }
+  );
+
+  // Create the temp directory to be used as extension local storage.
+  (mocha.options as any).globalSetup.push(
+    () => {
+      const dir = tmp.dirSync();
+      storagePath = fs.realpathSync(dir.name);
+      if (storagePath.substring(0, 2).match(/[A-Z]:/)) {
+        storagePath = storagePath.substring(0, 1).toLocaleLowerCase() + storagePath.substring(1);
+      }
+
+      removeStorage = dir.removeCallback;
+    }
+  );
+
+  // ensure etension is cleaned up.
+  (mocha.options as any).globalTeardown.push(
+    async () => {
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('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) {
+        extension.dispose();
+      }
+    }
+  );
+
+  // ensure temp directory is cleaned up.
+  (mocha.options as any).globalTeardown.push(
+    () => {
+      removeStorage?.();
+    }
+  );
+}

extensions/ql-vscode/src/vscode-tests/cli-integration/index.ts

@@ -0,0 +1,8 @@
+import 'mocha';
+import 'sinon-chai';
+import { runTestsInDirectory } from '../index-template';
+
+// The simple database used throughout the tests
+export function run(): Promise<void> {
+  return runTestsInDirectory(__dirname, true);
+}

extensions/ql-vscode/src/vscode-tests/cli-integration/queries.test.ts

@@ -0,0 +1,176 @@
+import { fail } from 'assert';
+import { CancellationToken, commands, ExtensionContext, extensions, Uri } from 'vscode';
+import * as sinon from 'sinon';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+import 'mocha';
+import { expect } from 'chai';
+import * as yaml from 'js-yaml';
+
+import { DatabaseItem, DatabaseManager } from '../../databases';
+import { CodeQLExtensionInterface } from '../../extension';
+import { dbLoc, storagePath } from './global.helper';
+import { importArchiveDatabase } from '../../databaseFetcher';
+import { compileAndRunQueryAgainstDatabase } from '../../run-queries';
+import { CodeQLCliServer } from '../../cli';
+import { QueryServerClient } from '../../queryserver-client';
+import { skipIfNoCodeQL } from '../ensureCli';
+import { QueryResultType } from '../../pure/messages';
+
+
+/**
+ * Integration tests for queries
+ */
+describe('Queries', function() {
+  this.timeout(20000);
+
+  before(function() {
+    skipIfNoCodeQL(this);
+  });
+
+  let dbItem: DatabaseItem;
+  let databaseManager: DatabaseManager;
+  let cli: CodeQLCliServer;
+  let qs: QueryServerClient;
+  let sandbox: sinon.SinonSandbox;
+  let progress: sinon.SinonSpy;
+  let token: CancellationToken;
+  let ctx: ExtensionContext;
+
+  let qlpackFile: string;
+  let qlFile: string;
+
+
+  beforeEach(async () => {
+    sandbox = sinon.createSandbox();
+
+    try {
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      if ('databaseManager' in extension) {
+        databaseManager = extension.databaseManager;
+        cli = extension.cliServer;
+        qs = extension.qs;
+        cli.quiet = true;
+        ctx = extension.ctx;
+        qlpackFile = `${ctx.storagePath}/quick-queries/qlpack.yml`;
+        qlFile = `${ctx.storagePath}/quick-queries/quick-query.ql`;
+      } else {
+        throw new Error('Extension not initialized. Make sure cli is downloaded and installed properly.');
+      }
+
+      progress = sandbox.spy();
+      token = {} as CancellationToken;
+
+      // Add a database
+      const uri = Uri.file(dbLoc);
+      const maybeDbItem = await importArchiveDatabase(
+        uri.toString(true),
+        databaseManager,
+        storagePath,
+        progress,
+        token
+      );
+
+      if (!maybeDbItem) {
+        throw new Error('Could not import database');
+      }
+      dbItem = maybeDbItem;
+    } catch (e) {
+      fail(e);
+    }
+  });
+
+  afterEach(() => {
+    try {
+      sandbox.restore();
+    } catch (e) {
+      fail(e);
+    }
+  });
+
+  it('should run a query', async () => {
+    try {
+      const queryPath = path.join(__dirname, 'data', 'simple-query.ql');
+      const result = await compileAndRunQueryAgainstDatabase(
+        cli,
+        qs,
+        dbItem,
+        false,
+        Uri.file(queryPath),
+        progress,
+        token
+      );
+
+      // just check that the query was successful
+      expect(result.database.name).to.eq('db');
+      expect(result.options.queryText).to.eq(fs.readFileSync(queryPath, 'utf8'));
+      expect(result.result.resultType).to.eq(QueryResultType.SUCCESS);
+    } catch (e) {
+      console.error('Test Failed');
+      fail(e);
+    }
+  });
+
+  // Asserts a fix for bug https://github.com/github/vscode-codeql/issues/733
+  it('should restart the database and run a query', async () => {
+    try {
+      await commands.executeCommand('codeQL.restartQueryServer');
+      const queryPath = path.join(__dirname, 'data', 'simple-query.ql');
+      const result = await compileAndRunQueryAgainstDatabase(
+        cli,
+        qs,
+        dbItem,
+        false,
+        Uri.file(queryPath),
+        progress,
+        token
+      );
+
+      // this message would indicate that the databases were not properly reregistered
+      expect(result.result.message).not.to.eq('No result from server');
+      expect(result.options.queryText).to.eq(fs.readFileSync(queryPath, 'utf8'));
+      expect(result.result.resultType).to.eq(QueryResultType.SUCCESS);
+    } catch (e) {
+      console.error('Test Failed');
+      fail(e);
+    }
+  });
+
+  it('should create a quick query', async () => {
+    safeDel(qlFile);
+    safeDel(qlpackFile);
+
+    await commands.executeCommand('codeQL.quickQuery');
+
+    // should have created the quick query file and query pack file
+    expect(fs.pathExistsSync(qlFile)).to.be.true;
+    expect(fs.pathExistsSync(qlpackFile)).to.be.true;
+
+    const qlpackContents: any = await yaml.safeLoad(
+      fs.readFileSync(qlpackFile, 'utf8')
+    );
+    // Should have chosen the js libraries
+    expect(qlpackContents.libraryPathDependencies[0]).to.eq('codeql-javascript');
+  });
+
+  it('should avoid creating a quick query', async () => {
+    fs.writeFileSync(qlpackFile, yaml.safeDump({
+      name: 'quick-query',
+      version: '1.0.0',
+      libraryPathDependencies: ['codeql-javascript']
+    }));
+    fs.writeFileSync(qlFile, 'xxx');
+    await commands.executeCommand('codeQL.quickQuery');
+
+    // should not have created the quick query file because database schema hasn't changed
+    expect(fs.readFileSync(qlFile, 'utf8')).to.eq('xxx');
+  });
+
+  function safeDel(file: string) {
+    try {
+      fs.unlinkSync(file);
+    } catch (e) {
+      // ignore
+    }
+  }
+});

extensions/ql-vscode/src/vscode-tests/cli-integration/query.test.ts

@@ -5,16 +5,17 @@ import * as path from 'path';
 import * as tmp from 'tmp';
 import * as url from 'url';
 import { CancellationTokenSource } from 'vscode-jsonrpc';
-import * as messages from '../../src/messages';
-import * as qsClient from '../../src/queryserver-client';
-import * as cli from '../../src/cli';
-import { ProgressReporter, Logger } from '../../src/logging';
-import { ColumnValue } from '../../src/bqrs-cli-types';
+import * as messages from '../../pure/messages';
+import * as qsClient from '../../queryserver-client';
+import * as cli from '../../cli';
+import { ColumnValue } from '../../pure/bqrs-cli-types';
+import { extensions } from 'vscode';
+import { CodeQLExtensionInterface } from '../../extension';
+import { fail } from 'assert';
+import { skipIfNoCodeQL } from '../ensureCli';
 
 
-declare module 'url' {
-  export function pathToFileURL(urlStr: string): Url;
-}
+const baseDir = path.join(__dirname, '../../../test/data');
 
 const tmpDir = tmp.dirSync({ prefix: 'query_test_', keep: false, unsafeCleanup: true });
 
@@ -32,7 +33,10 @@ class Checkpoint<T> {
   constructor() {
     this.res = () => { /**/ };
     this.rej = () => { /**/ };
-    this.promise = new Promise((res, rej) => { this.res = res; this.rej = rej; });
+    this.promise = new Promise((res, rej) => {
+      this.res = res as () => {};
+      this.rej = rej;
+    });
   }
 
   async done(): Promise<T> {
@@ -60,13 +64,19 @@ type QueryTestCase = {
 // Test cases: queries to run and their expected results.
 const queryTestCases: QueryTestCase[] = [
   {
-    queryPath: path.join(__dirname, '../data/query.ql'),
+    queryPath: path.join(baseDir, 'query.ql'),
     expectedResultSets: {
       '#select': [[42, 3.14159, 'hello world', true]]
     }
   },
   {
-    queryPath: path.join(__dirname, '../data/multiple-result-sets.ql'),
+    queryPath: path.join(baseDir, 'compute-default-strings.ql'),
+    expectedResultSets: {
+      '#select': [[{ label: '(no string representation)' }]]
+    }
+  },
+  {
+    queryPath: path.join(baseDir, 'multiple-result-sets.ql'),
     expectedResultSets: {
       'edges': [[1, 2], [2, 3]],
       '#select': [['s']]
@@ -74,60 +84,40 @@ const queryTestCases: QueryTestCase[] = [
   }
 ];
 
+const db: messages.Dataset = {
+  dbDir: path.join(__dirname, '../test-db'),
+  workingSet: 'default',
+};
+
 describe('using the query server', function() {
   before(function() {
-    if (process.env['CODEQL_PATH'] === undefined) {
-      console.log('The environment variable CODEQL_PATH is not set. The query server tests, which require the CodeQL CLI, will be skipped.');
-      this.skip();
-    }
+    skipIfNoCodeQL(this);
   });
 
   // Note this does not work with arrow functions as the test case bodies:
   // ensure they are all written with standard anonymous functions.
-  this.timeout(10000);
+  this.timeout(20000);
 
-  const codeQlPath = process.env['CODEQL_PATH']!;
   let qs: qsClient.QueryServerClient;
   let cliServer: cli.CodeQLCliServer;
   const queryServerStarted = new Checkpoint<void>();
-  after(() => {
-    if (qs) {
-      qs.dispose();
-    }
-    if (cliServer) {
-      cliServer.dispose();
+
+  beforeEach(async () => {
+    try {
+      const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+      if ('cliServer' in extension && 'qs' in extension) {
+        cliServer = extension.cliServer;
+        qs = extension.qs;
+        cliServer.quiet = true;
+      } else {
+        throw new Error('Extension not initialized. Make sure cli is downloaded and installed properly.');
+      }
+    } catch (e) {
+      fail(e);
     }
   });
 
   it('should be able to start the query server', async function() {
-    const consoleProgressReporter: ProgressReporter = {
-      report: (v: { message: string }) => console.log(`progress reporter says ${v.message}`)
-    };
-    const logger: Logger = {
-      log: async (s: string) => console.log('logger says', s),
-      show: () => { /**/ },
-      removeAdditionalLogLocation: async () => { /**/ },
-      getBaseLocation: () => ''
-    };
-    cliServer = new cli.CodeQLCliServer({
-      async getCodeQlPathWithoutVersionCheck(): Promise<string | undefined> {
-        return codeQlPath;
-      },
-    }, logger);
-    qs = new qsClient.QueryServerClient(
-      {
-        codeQlPath,
-        numThreads: 1,
-        queryMemoryMb: 1024,
-        timeoutSecs: 1000,
-        debug: false
-      },
-      cliServer,
-      {
-        logger
-      },
-      task => task(consoleProgressReporter, token)
-    );
     await qs.startQueryServer();
     queryServerStarted.resolve();
   });
@@ -138,13 +128,19 @@ describe('using the query server', function() {
     const evaluationSucceeded = new Checkpoint<void>();
     const parsedResults = new Checkpoint<void>();
 
+    it('should register the database if necessary', async () => {
+      if (await cliServer.cliConstraints.supportsDatabaseRegistration()) {
+        await qs.sendRequest(messages.registerDatabases, { databases: [db] }, token, (() => { /**/ }) as any);
+      }
+    });
+
     it(`should be able to compile query ${queryName}`, async function() {
       await queryServerStarted.done();
       expect(fs.existsSync(queryTestCase.queryPath)).to.be.true;
       try {
         const qlProgram: messages.QlProgram = {
           libraryPath: [],
-          dbschemePath: path.join(__dirname, '../data/test.dbscheme'),
+          dbschemePath: path.join(baseDir, 'test.dbscheme'),
           queryPath: queryTestCase.queryPath
         };
         const params: messages.CompileQueryParams = {
@@ -156,6 +152,7 @@ describe('using the query server', function() {
             localChecking: false,
             noComputeGetUrl: false,
             noComputeToString: false,
+            computeDefaultStrings: true
           },
           queryToCheck: qlProgram,
           resultPath: COMPILED_QUERY_PATH,
@@ -183,15 +180,11 @@ describe('using the query server', function() {
           id: callbackId,
           timeoutSecs: 1000,
         };
-        const db: messages.Dataset = {
-          dbDir: path.join(__dirname, '../test-db'),
-          workingSet: 'default',
-        };
         const params: messages.EvaluateQueriesParams = {
           db,
           evaluateId: callbackId,
           queries: [queryToRun],
-          stopOnError: false,
+          stopOnError: true,
           useSequenceHint: false
         };
         await qs.sendRequest(messages.runQueries, params, token, () => { /**/ });

extensions/ql-vscode/src/vscode-tests/cli-integration/run-cli.test.ts

@@ -0,0 +1,53 @@
+import { expect } from 'chai';
+import { extensions } from 'vscode';
+import { SemVer } from 'semver';
+
+import { CodeQLCliServer } from '../../cli';
+import { CodeQLExtensionInterface } from '../../extension';
+import { skipIfNoCodeQL } from '../ensureCli';
+import { getOnDiskWorkspaceFolders } from '../../helpers';
+
+/**
+ * Perform proper integration tests by running the CLI
+ */
+describe('Use cli', function() {
+  this.timeout(60000);
+
+  let cli: CodeQLCliServer;
+
+  beforeEach(async () => {
+    const extension = await extensions.getExtension<CodeQLExtensionInterface | {}>('GitHub.vscode-codeql')!.activate();
+    if ('cliServer' in extension) {
+      cli = extension.cliServer;
+    } else {
+      throw new Error('Extension not initialized. Make sure cli is downloaded and installed properly.');
+    }
+  });
+
+  it('should have the correct version of the cli', async () => {
+    expect(
+      (await cli.getVersion()).toString()
+    ).to.eq(
+      new SemVer(process.env.CLI_VERSION || '').toString()
+    );
+  });
+
+  it('should resolve ram', async () => {
+    const result = await (cli as any).resolveRam(8192);
+    expect(result).to.deep.eq([
+      '-J-Xmx4096M',
+      '--off-heap-ram=4096'
+    ]);
+  });
+
+  it('should resolve query packs', async function() {
+    skipIfNoCodeQL(this);
+    const qlpacks = await cli.resolveQlpacks(getOnDiskWorkspaceFolders());
+    // should have a bunch of qlpacks. just check that a few known ones exist
+    expect(qlpacks['codeql-cpp']).not.to.be.undefined;
+    expect(qlpacks['codeql-csharp']).not.to.be.undefined;
+    expect(qlpacks['codeql-java']).not.to.be.undefined;
+    expect(qlpacks['codeql-javascript']).not.to.be.undefined;
+    expect(qlpacks['codeql-python']).not.to.be.undefined;
+  });
+});