Merge pull request #379 from jcreedcmu/jcreed/v1.2.0-take-2

Increment version for minor release
2020-05-19 14:28:49 -04:00 · 2020-05-19 14:26:16 -04:00 · 2020-05-19 14:25:07 -04:00 · 2020-05-19 14:22:12 -04:00 · 2020-05-19 14:17:33 -04:00 · 2020-05-19 14:14:59 -04:00
70 changed files with 2531 additions and 396 deletions
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -7,6 +7,6 @@ Replace this with a description of the changes your pull request makes.

 ## Checklist

- [ ] [CHANGELOG.md](../extensions/ql-vscode/CHANGELOG.md) has been updated to incorporate all user visible changes made by this pull request.
+- [ ] [CHANGELOG.md](https://github.com/github/vscode-codeql/blob/master/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/product-docs-dsp` has been cc'd in all issues for UI or other user-facing changes made by this pull request.
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -62,11 +62,17 @@ jobs:
          npm run build-ci
        shell: bash

+      - name: Lint
+        run: |
+          cd extensions/ql-vscode
+          npm run lint
+
      - name: Install CodeQL
        run: |
          mkdir codeql-home
          curl -L --silent https://github.com/github/codeql-cli-binaries/releases/latest/download/codeql.zip -o codeql-home/codeql.zip
          unzip -q -o codeql-home/codeql.zip -d codeql-home
+          unzip -q -o codeql-home/codeql.zip codeql/codeql.exe -d codeql-home
          rm codeql-home/codeql.zip
        shell: bash

--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -8,8 +8,7 @@
      "request": "launch",
      "runtimeExecutable": "${execPath}",
      "args": [
-        "--extensionDevelopmentPath=${workspaceRoot}/dist/vscode-codeql",
-        "${workspaceRoot}/../vscode-codeql-starter/vscode-codeql-starter.code-workspace"
+        "--extensionDevelopmentPath=${workspaceRoot}/dist/vscode-codeql"
      ],
      "stopOnEntry": false,
      "sourceMaps": true,
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -32,5 +32,7 @@
  "eslint.options": {
    // This is necessary so that eslint can properly resolve its plugins
    "resolvePluginsRelativeTo": "./extensions/ql-vscode"
-  }
+  },
+  // Force this to false since this will cause too many changes on each commit
+  "editor.formatOnSave": false
 }
--- a/common/config/rush/pnpm-lock.yaml
+++ b/common/config/rush/pnpm-lock.yaml
--- a/configs/typescript-config/common.tsconfig.json
+++ b/configs/typescript-config/common.tsconfig.json
@@ -27,4 +27,4 @@
    "../../test",
    "../../**/view"
  ]
-}
+}
--- a/extensions/ql-vscode/.eslintrc.js
+++ b/extensions/ql-vscode/.eslintrc.js
@@ -3,9 +3,6 @@ module.exports = {
  parserOptions: {
    ecmaVersion: 2018,
    sourceType: 'module',
-    ecmaFeatures: {
-      modules: true,
-    },
    project: ['tsconfig.json', './src/**/tsconfig.json'],
  },
  plugins: ['@typescript-eslint'],
@@ -29,10 +26,9 @@ module.exports = {
    "@typescript-eslint/no-explicit-any": "off",
    "prefer-const": ["warn", {"destructuring": "all"}],
    "indent": "off",
-    "@typescript-eslint/indent": ["error", 2, {
-      "SwitchCase": 1,
-      "FunctionDeclaration": { "body": 1, "parameters": 1 }
-    }],
-    "@typescript-eslint/no-throw-literal": "error"
+    "@typescript-eslint/indent": "off",
+    "@typescript-eslint/no-throw-literal": "error",
+    "no-useless-escape": 0,
+    "semi": 2
  },
 };
--- a/extensions/ql-vscode/CHANGELOG.md
+++ b/extensions/ql-vscode/CHANGELOG.md
@@ -1,5 +1,41 @@
 # CodeQL for Visual Studio Code: Changelog

+## 1.2.0 - 19 May 2020
+
+- Enable 'Go to Definition' and 'Go to References' on source archive
+  files in CodeQL databases. This is handled by a CodeQL query.
+- Fix adding database archive files on Windows.
+- Enable adding remote and local database archive files from the
+  command palette.
+
+## 1.1.5 - 15 May 2020
+
+- Links in results are no longer underlined and monospaced.
+- Add the ability to choose a database either from an archive, a folder, or from the internet.
+- New icons for commands on the databases view.
+
+## 1.1.4 - 13 May 2020
+
+- Add the ability to download and install databases archives from the internet.
+
+## 1.1.3 - 8 May 2020
+
+- Add a suggestion in alerts view to view raw results, when there are
+  raw results but no alerts.
+- Add the ability to rename databases in the database view.
+- Add the ability to open the directory in the filesystem
+  of a database.
+
+## 1.1.2 - 28 April 2020
+
+- Implement syntax highlighting for the new `unique` aggregate.
+- Implement XML syntax highlighting for `.qhelp` files.
+- Add option to auto save queries before running them.
+- Add new command in query history to view the query text of the
+  selected query (note that this may be different from the current
+  contents of the query file if the file has been edited).
+- Add ability to sort CodeQL databases by name or by date added.
+
 ## 1.1.1 - 23 March 2020

 - Fix quick evaluation in `.qll` files.
@@ -39,7 +75,7 @@
 ## 1.0.3 - 13 January 2020

 - Reduce the frequency of CodeQL CLI update checks to help avoid hitting GitHub API limits of 60 requests per
-hour for unauthenticated IPs.
+  hour for unauthenticated IPs.
 - Fix sorting of result sets with names containing special characters.

 ## 1.0.2 - 13 December 2019
@@ -48,8 +84,7 @@ hour for unauthenticated IPs.
 - Allow customization of query history labels from settings and from
  query history view context menu.
 - Show number of results in results view.
- Add commands `CodeQL: Show Next Step on Path` and `CodeQL: Show
-  Previous Step on Path` for navigating the steps on the currently
+- Add commands `CodeQL: Show Next Step on Path` and `CodeQL: Show Previous Step on Path` for navigating the steps on the currently
  shown path result.

 ## 1.0.1 - 21 November 2019
--- a/extensions/ql-vscode/README.md
+++ b/extensions/ql-vscode/README.md
@@ -66,12 +66,11 @@ While you can use the [CodeQL CLI to create your own databases](https://help.sem
 1. Find a project you're interested in and display the **Integrations** tab (for example, [Apache Kafka](https://lgtm.com/projects/g/apache/kafka/ci/)).
 1. Scroll to the **CodeQL databases for local analysis** section at the bottom of the page.
 1. Download databases for the languages that you want to explore.
-1. Unzip the databases.
 1. For each database that you want to import:
-    1. In the VS Code sidebar, go to **CodeQL** > **Databases** and click **+**.
-    1. Browse to the unzipped database folder (the parent folder that contains `db-<language>` and `src`) and select **Choose database** to add it.
+    1. Go to the CodeQL Databases view in the sidebar. Hover over the Databases title bar and click the icon to **Choose Database from Archive**.
+    1. Browse to the zipped database that you downloaded from LGTM.

-When the import is complete, each CodeQL database is displayed in the CodeQL sidebar under **Databases**.
+Once you've added a CodeQL database, it is displayed in the Databases view.

 ### Running a query

--- a/extensions/ql-vscode/gulpfile.js/webpack.config.ts
+++ b/extensions/ql-vscode/gulpfile.js/webpack.config.ts
@@ -10,7 +10,7 @@ export const config: webpack.Configuration = {
    path: path.resolve(__dirname, '..', 'out'),
    filename: "[name].js"
  },
-  devtool: 'source-map',
+  devtool: "inline-source-map",
  resolve: {
    extensions: ['.js', '.ts', '.tsx', '.json']
  },
--- a/extensions/ql-vscode/media/dark/archive-plus.svg
+++ b/extensions/ql-vscode/media/dark/archive-plus.svg
@@ -0,0 +1,5 @@
+<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="M14.5 1H1.5L1 1.5V4.5L1.5 5H2V13.5L2.5 14H13.5L14 13.5V5H14.5L15 4.5V1.5L14.5 1ZM13.5 4H2.5H2V2H14V4H13.5ZM3 13V5H13V13H3ZM11 7H5V8H11V7Z" fill="#C5C5C5"/>
+<line y2="12" x2="8" y1="12" x1="16" stroke-width="1" stroke="green" fill="none"/>
+<line y2="8" x2="12" y1="16" x1="12" stroke-width="1" stroke="green" fill="none"/>
+</svg>
--- a/extensions/ql-vscode/media/check-dark-mode.svg
+++ b/extensions/ql-vscode/media/check-dark-mode.svg
--- a/extensions/ql-vscode/media/dark/cloud-download.svg
+++ b/extensions/ql-vscode/media/dark/cloud-download.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="M11.9565 6H12.0064C12.8004 6 13.5618 6.31607 14.1232 6.87868C14.6846 7.44129 15 8.20435 15 9C15 9.79565 14.6846 10.5587 14.1232 11.1213C13.5618 11.6839 12.8004 12 12.0064 12V11C12.5357 11 13.0434 10.7893 13.4176 10.4142C13.7919 10.0391 14.0021 9.53044 14.0021 9C14.0021 8.46957 13.7919 7.96086 13.4176 7.58579C13.0434 7.21072 12.5357 7 12.0064 7H11.0924L10.9687 6.143C10.8938 5.60541 10.6456 5.10711 10.2618 4.72407C9.87801 4.34103 9.37977 4.09427 8.84303 4.02143C8.30629 3.94859 7.76051 4.05365 7.2889 4.3206C6.81729 4.58754 6.44573 5.00173 6.23087 5.5L5.89759 6.262L5.08933 6.073C4.90382 6.02699 4.71364 6.0025 4.52255 6C3.86093 6 3.22641 6.2634 2.75858 6.73224C2.29075 7.20108 2.02792 7.83696 2.02792 8.5C2.02792 9.16304 2.29075 9.79893 2.75858 10.2678C3.22641 10.7366 3.86093 11 4.52255 11H5.02148V12H4.52255C4.02745 12.0043 3.5371 11.903 3.08403 11.7029C2.63096 11.5028 2.22553 11.2084 1.89461 10.8394C1.5637 10.4703 1.31488 10.0349 1.16465 9.56211C1.01442 9.08932 0.966217 8.58992 1.02324 8.09704C1.08026 7.60416 1.24121 7.12906 1.4954 6.70326C1.74959 6.27745 2.09121 5.91068 2.49762 5.62727C2.90402 5.34385 3.36591 5.15027 3.85264 5.05937C4.33938 4.96847 4.83984 4.98232 5.32083 5.1C5.6241 4.40501 6.14511 3.82799 6.80496 3.45635C7.4648 3.08472 8.22753 2.9387 8.9776 3.04044C9.72768 3.14217 10.4242 3.4861 10.9618 4.02014C11.4993 4.55418 11.8485 5.24923 11.9565 6ZM6.70719 11.1214L8.0212 12.4354V7H9.01506V12.3992L10.2929 11.1214L11 11.8285L8.85356 13.9749H8.14645L6.00008 11.8285L6.70719 11.1214Z" fill="#C5C5C5"/>
+</svg>
--- a/extensions/ql-vscode/media/dark/folder-opened-plus.svg
+++ b/extensions/ql-vscode/media/dark/folder-opened-plus.svg
@@ -0,0 +1,5 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M0.5 14H12.5L12.98 13.63L15.61 6.63L15.13 6H13V3.5L12.5 3H6.70996L5.84998 2.15002L5.5 2H0.5L0 2.5V13.5L0.5 14ZM1 3H5.29004L6.15002 3.84998L6.5 4H12V6H8.5L8.15002 6.15002L7.29004 7H2.5L2.03003 7.33997L1.03003 10.42L1 3ZM12.13 13H1.18994L2.85999 8H7.5L7.84998 7.84998L8.70996 7H14.5L12.13 13Z" fill="#C5C5C5"/>
+<line y2="12" x2="8" y1="12" x1="16" stroke-width="1" stroke="green" fill="none"/>
+<line y2="8" x2="12" y1="16" x1="12" stroke-width="1" stroke="green" fill="none"/>
+</svg>
--- a/extensions/ql-vscode/media/white-plus.svg
+++ b/extensions/ql-vscode/media/white-plus.svg
--- a/extensions/ql-vscode/media/dark/sort-alpha.svg
+++ b/extensions/ql-vscode/media/dark/sort-alpha.svg
@@ -0,0 +1,17 @@
+<?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"/>
+			<polygon points="301.44,304.32 427.947,120.853 427.947,93.973 250.88,93.973 250.88,128.107 376.32,128.107 250.027,310.72
+				250.027,338.24 432,338.24 432,304.32" fill="#C5C5C5"/>
+			<polygon points="234.24,422.933 283.947,373.227 184.533,373.227" fill="#C5C5C5"/>
+			<path d="M226.773,338.24L130.987,93.76H96L0,338.24h39.253l19.627-52.267h109.013l19.627,52.267H226.773z M71.893,250.987
+				L113.28,140.48l41.387,110.507H71.893z" fill="#C5C5C5"/>
+		</g>
+	</g>
+</g>
+</svg>
--- a/extensions/ql-vscode/media/dark/sort-date.svg
+++ b/extensions/ql-vscode/media/dark/sort-date.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="M7 2L6 3V6H7V3H14V5.45306L14.2071 5.29286L15 6.08576V3L14 2H7ZM8 4H10V6H8V4ZM5 9H3V11H5V9ZM2 7L1 8V13L2 14H9L10 13V8L9 7H2ZM2 13V8H9V13H2ZM8 10H6V12H8V10ZM13 4H12V7.86388L10.818 6.68192L10.1109 7.38903L12.1465 9.42454L12.8536 9.42454L14.889 7.38908L14.1819 6.68197L13 7.86388V4Z" fill="#C5C5C5"/>
+</svg>
--- a/extensions/ql-vscode/media/light/archive-plus.svg
+++ b/extensions/ql-vscode/media/light/archive-plus.svg
@@ -0,0 +1,5 @@
+<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="M14.5 1H1.5L1 1.5V4.5L1.5 5H2V13.5L2.5 14H13.5L14 13.5V5H14.5L15 4.5V1.5L14.5 1ZM13.5 4H2.5H2V2H14V4H13.5ZM3 13V5H13V13H3ZM11 7H5V8H11V7Z" fill="#424242"/>
+<line y2="12" x2="8" y1="12" x1="16" stroke-width="1" stroke="green" fill="none"/>
+<line y2="8" x2="12" y1="16" x1="12" stroke-width="1" stroke="green" fill="none"/>
+</svg>
--- a/extensions/ql-vscode/media/check-light-mode.svg
+++ b/extensions/ql-vscode/media/check-light-mode.svg
--- a/extensions/ql-vscode/media/light/cloud-download.svg
+++ b/extensions/ql-vscode/media/light/cloud-download.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="M11.9565 6H12.0064C12.8004 6 13.5618 6.31607 14.1232 6.87868C14.6846 7.44129 15 8.20435 15 9C15 9.79565 14.6846 10.5587 14.1232 11.1213C13.5618 11.6839 12.8004 12 12.0064 12V11C12.5357 11 13.0434 10.7893 13.4176 10.4142C13.7919 10.0391 14.0021 9.53044 14.0021 9C14.0021 8.46957 13.7919 7.96086 13.4176 7.58579C13.0434 7.21072 12.5357 7 12.0064 7H11.0924L10.9687 6.143C10.8938 5.60541 10.6456 5.10711 10.2618 4.72407C9.87801 4.34103 9.37977 4.09427 8.84303 4.02143C8.30629 3.94859 7.76051 4.05365 7.2889 4.3206C6.81729 4.58754 6.44573 5.00173 6.23087 5.5L5.89759 6.262L5.08933 6.073C4.90382 6.02699 4.71364 6.0025 4.52255 6C3.86093 6 3.22641 6.2634 2.75858 6.73224C2.29075 7.20108 2.02792 7.83696 2.02792 8.5C2.02792 9.16304 2.29075 9.79893 2.75858 10.2678C3.22641 10.7366 3.86093 11 4.52255 11H5.02148V12H4.52255C4.02745 12.0043 3.5371 11.903 3.08403 11.7029C2.63096 11.5028 2.22553 11.2084 1.89461 10.8394C1.5637 10.4703 1.31488 10.0349 1.16465 9.56211C1.01442 9.08932 0.966217 8.58992 1.02324 8.09704C1.08026 7.60416 1.24121 7.12906 1.4954 6.70326C1.74959 6.27745 2.09121 5.91068 2.49762 5.62727C2.90402 5.34385 3.36591 5.15027 3.85264 5.05937C4.33938 4.96847 4.83984 4.98232 5.32083 5.1C5.6241 4.40501 6.14511 3.82799 6.80496 3.45635C7.4648 3.08472 8.22753 2.9387 8.9776 3.04044C9.72768 3.14217 10.4242 3.4861 10.9618 4.02014C11.4993 4.55418 11.8485 5.24923 11.9565 6ZM6.70719 11.1214L8.0212 12.4354V7H9.01506V12.3992L10.2929 11.1214L11 11.8285L8.85356 13.9749H8.14645L6.00008 11.8285L6.70719 11.1214Z" fill="#424242"/>
+</svg>
--- a/extensions/ql-vscode/media/light/folder-opened-plus.svg
+++ b/extensions/ql-vscode/media/light/folder-opened-plus.svg
@@ -0,0 +1,12 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<g clip-path="url(#clip0)">
+<path d="M0.499817 14H12.4998L12.9798 13.63L15.6098 6.63L15.1298 6H12.9998V3.5L12.4998 3H6.70978L5.84979 2.15002L5.49982 2H0.499817L-0.000183105 2.5V13.5L0.499817 14ZM0.999817 3H5.28986L6.14984 3.84998L6.49982 4H11.9998V6H8.49982L8.14984 6.15002L7.28986 7H2.49982L2.02985 7.33997L1.02985 10.42L0.999817 3ZM12.1298 13H1.18976L2.8598 8H7.49982L7.84979 7.84998L8.70978 7H14.4998L12.1298 13Z" fill="#424242"/>
+<line y2="12" x2="8" y1="12" x1="16" stroke-width="1" stroke="green" fill="none"/>
+<line y2="8" x2="12" y1="16" x1="12" stroke-width="1" stroke="green" fill="none"/>
+</g>
+<defs>
+<clipPath id="clip0">
+<path d="M-0.000183105 0H15.9998V16H-0.000183105V0Z" fill="white"/>
+</clipPath>
+</defs>
+</svg>
--- a/extensions/ql-vscode/media/light/plus.svg
+++ b/extensions/ql-vscode/media/light/plus.svg
--- a/extensions/ql-vscode/media/light/sort-alpha.svg
+++ b/extensions/ql-vscode/media/light/sort-alpha.svg
@@ -0,0 +1,17 @@
+<?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 			"/>
+			<polygon points="301.44,304.32 427.947,120.853 427.947,93.973 250.88,93.973 250.88,128.107 376.32,128.107 250.027,310.72 
+				250.027,338.24 432,338.24 432,304.32 			"/>
+			<polygon points="234.24,422.933 283.947,373.227 184.533,373.227 			"/>
+			<path d="M226.773,338.24L130.987,93.76H96L0,338.24h39.253l19.627-52.267h109.013l19.627,52.267H226.773z M71.893,250.987
+				L113.28,140.48l41.387,110.507H71.893z"/>
+		</g>
+	</g>
+</g>
+</svg>
--- a/extensions/ql-vscode/media/light/sort-date.svg
+++ b/extensions/ql-vscode/media/light/sort-date.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="M7 2L6 3V6H7V3H14V5.45306L14.2071 5.29286L15 6.08576V3L14 2H7ZM8 4H10V6H8V4ZM5 9H3V11H5V9ZM2 7L1 8V13L2 14H9L10 13V8L9 7H2ZM2 13V8H9V13H2ZM8 10H6V12H8V10ZM13 4H12V7.86388L10.818 6.68192L10.1109 7.38903L12.1465 9.42454L12.8536 9.42454L14.889 7.38908L14.1819 6.68197L13 7.86388V4Z" fill="#424242"/>
+</svg>
--- a/extensions/ql-vscode/package.json
+++ b/extensions/ql-vscode/package.json
@@ -4,7 +4,7 @@
  "description": "CodeQL for Visual Studio Code",
  "author": "GitHub",
  "private": true,
-  "version": "1.1.1",
+  "version": "1.2.0",
  "publisher": "GitHub",
  "license": "MIT",
  "icon": "media/VS-marketplace-CodeQL-icon.png",
@@ -27,8 +27,13 @@
    "onView:codeQLQueryHistory",
    "onView:test-explorer",
    "onCommand:codeQL.checkForUpdatesToCLI",
-    "onCommand:codeQL.chooseDatabase",
+    "onCommand:codeQLDatabases.chooseDatabaseFolder",
+    "onCommand:codeQLDatabases.chooseDatabaseArchive",
+    "onCommand:codeQLDatabases.chooseDatabaseInternet",
    "onCommand:codeQL.setCurrentDatabase",
+    "onCommand:codeQL.chooseDatabaseFolder",
+    "onCommand:codeQL.chooseDatabaseArchive",
+    "onCommand:codeQL.chooseDatabaseInternet",
    "onCommand:codeQLDatabases.chooseDatabase",
    "onCommand:codeQLDatabases.setCurrentDatabase",
    "onCommand:codeQL.quickQuery",
@@ -77,6 +82,12 @@
          ".dbscheme"
        ],
        "configuration": "./language-configuration.json"
+      },
+      {
+        "id": "xml",
+        "extensions": [
+          ".qhelp"
+        ]
      }
    ],
    "grammars": [
@@ -132,6 +143,11 @@
          "default": false,
          "description": "Enable debug logging and tuple counting when running CodeQL queries. This information is useful for debugging query performance."
        },
+        "codeQL.runningQueries.autoSave": {
+          "type": "boolean",
+          "default": false,
+          "description": "Enable automatically saving a modified query file when running a query."
+        },
        "codeQL.queryHistory.format": {
          "type": "string",
          "default": "[%t] %q on %d - %s",
@@ -161,11 +177,27 @@
        "title": "CodeQL: Quick Query"
      },
      {
-        "command": "codeQL.chooseDatabase",
-        "title": "CodeQL: Choose Database",
+        "command": "codeQLDatabases.chooseDatabaseFolder",
+        "title": "Choose Database from Folder",
        "icon": {
-          "light": "media/black-plus.svg",
-          "dark": "media/white-plus.svg"
+          "light": "media/light/folder-opened-plus.svg",
+          "dark": "media/dark/folder-opened-plus.svg"
+        }
+      },
+      {
+        "command": "codeQLDatabases.chooseDatabaseArchive",
+        "title": "Choose Database from Archive",
+        "icon": {
+          "light": "media/light/archive-plus.svg",
+          "dark": "media/dark/archive-plus.svg"
+        }
+      },
+      {
+        "command": "codeQLDatabases.chooseDatabaseInternet",
+        "title": "Download Database",
+        "icon": {
+          "light": "media/light/cloud-download.svg",
+          "dark": "media/dark/cloud-download.svg"
        }
      },
      {
@@ -192,6 +224,42 @@
        "command": "codeQLDatabases.upgradeDatabase",
        "title": "Upgrade Database"
      },
+      {
+        "command": "codeQLDatabases.renameDatabase",
+        "title": "Rename Database"
+      },
+      {
+        "command": "codeQLDatabases.openDatabaseFolder",
+        "title": "Show Database Directory"
+      },
+      {
+        "command": "codeQL.chooseDatabaseFolder",
+        "title": "CodeQL: Choose Database from Folder"
+      },
+      {
+        "command": "codeQL.chooseDatabaseArchive",
+        "title": "CodeQL: Choose Database from Archive"
+      },
+      {
+        "command": "codeQL.chooseDatabaseInternet",
+        "title": "CodeQL: Download Database"
+      },
+      {
+        "command": "codeQLDatabases.sortByName",
+        "title": "Sort by Name",
+        "icon": {
+          "light": "media/light/sort-alpha.svg",
+          "dark": "media/dark/sort-alpha.svg"
+        }
+      },
+      {
+        "command": "codeQLDatabases.sortByDateAdded",
+        "title": "Sort by Date Added",
+        "icon": {
+          "light": "media/light/sort-date.svg",
+          "dark": "media/dark/sort-date.svg"
+        }
+      },
      {
        "command": "codeQL.checkForUpdatesToCLI",
        "title": "CodeQL: Check for CLI Updates"
@@ -212,6 +280,10 @@
        "command": "codeQLQueryHistory.showQueryLog",
        "title": "Show Query Log"
      },
+      {
+        "command": "codeQLQueryHistory.showQueryText",
+        "title": "Show Query Text"
+      },
      {
        "command": "codeQLQueryResults.nextPathStep",
        "title": "CodeQL: Show Next Step on Path"
@@ -240,7 +312,27 @@
    "menus": {
      "view/title": [
        {
-          "command": "codeQL.chooseDatabase",
+          "command": "codeQLDatabases.sortByName",
+          "when": "view == codeQLDatabases",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLDatabases.sortByDateAdded",
+          "when": "view == codeQLDatabases",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseFolder",
+          "when": "view == codeQLDatabases",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseArchive",
+          "when": "view == codeQLDatabases",
+          "group": "navigation"
+        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseInternet",
          "when": "view == codeQLDatabases",
          "group": "navigation"
        }
@@ -261,6 +353,16 @@
          "group": "9_qlCommands",
          "when": "view == codeQLDatabases"
        },
+        {
+          "command": "codeQLDatabases.renameDatabase",
+          "group": "9_qlCommands",
+          "when": "view == codeQLDatabases"
+        },
+        {
+          "command": "codeQLDatabases.openDatabaseFolder",
+          "group": "9_qlCommands",
+          "when": "view == codeQLDatabases"
+        },
        {
          "command": "codeQLQueryHistory.openQuery",
          "group": "9_qlCommands",
@@ -281,6 +383,11 @@
          "group": "9_qlCommands",
          "when": "view == codeQLQueryHistory"
        },
+        {
+          "command": "codeQLQueryHistory.showQueryText",
+          "group": "9_qlCommands",
+          "when": "view == codeQLQueryHistory"
+        },
        {
          "command": "codeQLTests.showOutputDifferences",
          "group": "qltest@1",
@@ -296,7 +403,7 @@
        {
          "command": "codeQL.setCurrentDatabase",
          "group": "9_qlCommands",
-          "when": "resourceScheme == codeql-zip-archive || explorerResourceIsFolder"
+          "when": "resourceScheme == codeql-zip-archive || explorerResourceIsFolder || resourceExtname == .zip"
        },
        {
          "command": "codeQL.runQuery",
@@ -321,10 +428,42 @@
          "command": "codeQLDatabases.setCurrentDatabase",
          "when": "false"
        },
+        {
+          "command": "codeQLDatabases.renameDatabase",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.openDatabaseFolder",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.sortByName",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.sortByDateAdded",
+          "when": "false"
+        },
        {
          "command": "codeQLDatabases.removeDatabase",
          "when": "false"
        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseFolder",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseArchive",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.chooseDatabaseInternet",
+          "when": "false"
+        },
+        {
+          "command": "codeQLDatabases.upgradeDatabase",
+          "when": "false"
+        },
        {
          "command": "codeQLQueryHistory.openQuery",
          "when": "false"
@@ -341,6 +480,10 @@
          "command": "codeQLQueryHistory.showQueryLog",
          "when": "false"
        },
+        {
+          "command": "codeQLQueryHistory.showQueryText",
+          "when": "false"
+        },
        {
          "command": "codeQLQueryHistory.setLabel",
          "when": "false"
@@ -387,9 +530,10 @@
    "preintegration": "rm -rf ./out/vscode-tests && gulp",
    "integration": "node ./out/vscode-tests/run-integration-tests.js",
    "update-vscode": "node ./node_modules/vscode/bin/install",
-    "postinstall": "node ./node_modules/vscode/bin/install",
+    "postinstall": "npm rebuild && node ./node_modules/vscode/bin/install",
    "format": "tsfmt -r",
-    "lint": "eslint . --ext .ts,.tsx"
+    "lint": "eslint src test --ext .ts,.tsx",
+    "format-staged": "lint-staged"
  },
  "dependencies": {
    "child-process-promise": "^2.2.1",
@@ -406,8 +550,8 @@
    "tmp": "^0.1.0",
    "tree-kill": "~1.2.2",
    "unzipper": "~0.10.5",
-    "vscode-jsonrpc": "^4.0.0",
-    "vscode-languageclient": "^5.2.1",
+    "vscode-jsonrpc": "^5.0.1",
+    "vscode-languageclient": "^6.1.3",
    "vscode-test-adapter-api": "~1.7.0",
    "vscode-test-adapter-util": "~0.7.0",
    "minimist": "~1.2.5"
@@ -465,6 +609,24 @@
    "sinon-chai": "~3.5.0",
    "@types/sinon-chai": "~3.2.3",
    "proxyquire": "~2.1.3",
-    "@types/proxyquire": "~1.3.28"
+    "@types/proxyquire": "~1.3.28",
+    "eslint-plugin-react": "~7.19.0",
+    "husky": "~4.2.5",
+    "lint-staged": "~10.2.2",
+    "prettier": "~2.0.5"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm run format-staged",
+      "pre-push": "npm run lint"
+    }
+  },
+  "lint-staged": {
+    "./**/*.{json,css,scss,md}": [
+      "prettier --write"
+    ],
+    "./**/*.{ts,tsx}": [
+      "tsfmt -r"
+    ]
  }
 }
--- a/extensions/ql-vscode/src/adapt.ts
+++ b/extensions/ql-vscode/src/adapt.ts
@@ -0,0 +1,103 @@
+import { DecodedBqrsChunk, ResultSetSchema, ColumnKind, Column, ColumnValue } from "./bqrs-cli-types";
+import { LocationValue, ResultSetSchema as AdaptedSchema, ColumnSchema, ColumnType, LocationStyle } from 'semmle-bqrs';
+
+// 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),
+  };
+}
--- a/extensions/ql-vscode/src/bqrs-cli-types.ts
+++ b/extensions/ql-vscode/src/bqrs-cli-types.ts
@@ -1,14 +1,34 @@

 export const PAGE_SIZE = 1000;

-export type ColumnKind = "f" | "i" | "s" | "b" | "d" | "e";
+/**
+ * The single-character codes used in the bqrs format for the the kind
+ * of a result column. This namespace is intentionally not an enum, see
+ * the "for the sake of extensibility" comment in messages.ts.
+ */
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export namespace ColumnKindCode {
+  export const FLOAT = "f";
+  export const INTEGER = "i";
+  export const STRING = "s";
+  export const BOOLEAN = "b";
+  export const DATE = "d";
+  export const ENTITY = "e";
+}
+
+export type ColumnKind =
+  | typeof ColumnKindCode.FLOAT
+  | typeof ColumnKindCode.INTEGER
+  | typeof ColumnKindCode.STRING
+  | typeof ColumnKindCode.BOOLEAN
+  | typeof ColumnKindCode.DATE
+  | typeof ColumnKindCode.ENTITY;

 export interface Column {
  name?: string;
  kind: ColumnKind;
 }

-
 export interface ResultSetSchema {
  name: string;
  rows: number;
--- a/extensions/ql-vscode/src/cli-version.ts
+++ b/extensions/ql-vscode/src/cli-version.ts
@@ -34,7 +34,7 @@ export function tryParseVersionString(versionString: string): Version | undefine
    patchVersion: Number.parseInt(match[3], 10),
    prereleaseVersion: match[4],
    rawString: versionString,
-  }
+  };
 }

 /**
--- a/extensions/ql-vscode/src/cli.ts
+++ b/extensions/ql-vscode/src/cli.ts
@@ -10,10 +10,10 @@ import * as tk from 'tree-kill';
 import * as util 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 { Logger, ProgressReporter } from './logging';
+import { DistributionProvider } from "./distribution";
+import { assertNever } from "./helpers-pure";
+import { QueryMetadata, SortDirection } from "./interface-types";
+import { Logger, ProgressReporter } from "./logging";

 /**
 * The version of the SARIF format that we are using.
@@ -165,7 +165,7 @@ export class CodeQLCliServer implements Disposable {
    // If the server is not running a command run this immediately
    // otherwise add to the front of the queue (as we want to run this after the next command()).
    if (this.commandInProcess) {
-      this.commandQueue.unshift(callback)
+      this.commandQueue.unshift(callback);
    } else {
      callback();
    }
@@ -188,19 +188,19 @@ export class CodeQLCliServer implements Disposable {
   */
  private async launchProcess(): Promise<child_process.ChildProcessWithoutNullStreams> {
    const config = await this.getCodeQlPath();
-    return spawnServer(config, "CodeQL CLI Server", ["execute", "cli-server"], [], this.logger, _data => { /**/ })
+    return spawnServer(config, "CodeQL CLI Server", ["execute", "cli-server"], [], this.logger, _data => { /**/ });
  }

  private async runCodeQlCliInternal(command: string[], commandArgs: string[], description: string): Promise<string> {
    const stderrBuffers: Buffer[] = [];
    if (this.commandInProcess) {
-      throw new Error("runCodeQlCliInternal called while cli was running")
+      throw new Error("runCodeQlCliInternal called while cli was running");
    }
    this.commandInProcess = true;
    try {
      //Launch the process if it doesn't exist
      if (!this.process) {
-        this.process = await this.launchProcess()
+        this.process = await this.launchProcess();
      }
      // Grab the process so that typescript know that it is always defined.
      const process = this.process;
@@ -230,8 +230,8 @@ export class CodeQLCliServer implements Disposable {
          // Listen for process exit.
          process.addListener("close", (code) => reject(code));
          // Write the command followed by a null terminator.
-          process.stdin.write(JSON.stringify(args), "utf8")
-          process.stdin.write(this.nullBuffer)
+          process.stdin.write(JSON.stringify(args), "utf8");
+          process.stdin.write(this.nullBuffer);
        });
        // Join all the data together
        const fullBuffer = Buffer.concat(stdoutBuffers);
@@ -252,8 +252,8 @@ export class CodeQLCliServer implements Disposable {
      } finally {
        this.logger.log(Buffer.concat(stderrBuffers).toString("utf8"));
        // Remove the listeners we set up.
-        process.stdout.removeAllListeners('data')
-        process.stderr.removeAllListeners('data')
+        process.stdout.removeAllListeners('data');
+        process.stderr.removeAllListeners('data');
        process.removeAllListeners("close");
      }
    } finally {
@@ -349,7 +349,7 @@ export class CodeQLCliServer implements Disposable {
      try {
        yield JSON.parse(event) as EventType;
      } catch (err) {
-        throw new Error(`Parsing output of ${description} failed: ${err.stderr || err}`)
+        throw new Error(`Parsing output of ${description} failed: ${err.stderr || err}`);
      }
    }
  }
@@ -375,11 +375,11 @@ export class CodeQLCliServer implements Disposable {
        } catch (err) {
          reject(err);
        }
-      }
+      };
      // If the server is not running a command, then run the given command immediately,
      // otherwise add to the queue
      if (this.commandInProcess) {
-        this.commandQueue.push(callback)
+        this.commandQueue.push(callback);
      } else {
        callback();
      }
@@ -401,7 +401,7 @@ export class CodeQLCliServer implements Disposable {
    try {
      return JSON.parse(result) as OutputType;
    } catch (err) {
-      throw new Error(`Parsing output of ${description} failed: ${err.stderr || err}`)
+      throw new Error(`Parsing output of ${description} failed: ${err.stderr || err}`);
    }
  }

@@ -535,12 +535,12 @@ export class CodeQLCliServer implements Disposable {
    try {
      output = await fs.readFile(interpretedResultsPath, 'utf8');
    } catch (err) {
-      throw new Error(`Reading output of interpretation failed: ${err.stderr || err}`)
+      throw new Error(`Reading output of interpretation failed: ${err.stderr || err}`);
    }
    try {
      return JSON.parse(output) as sarif.Log;
    } catch (err) {
-      throw new Error(`Parsing output of interpretation failed: ${err.stderr || err}`)
+      throw new Error(`Parsing output of interpretation failed: ${err.stderr || err}`);
    }
  }

@@ -614,6 +614,27 @@ export class CodeQLCliServer implements Disposable {
      "Resolving qlpack information",
    );
  }
+
+  /**
+   * Gets information about queries in a query suite.
+   * @param suite The suite to resolve.
+   * @param additionalPacks A list of directories to search for qlpacks before searching in `searchPath`.
+   * @param searchPath A list of directories to search for packs not found in `additionalPacks`. If undefined,
+   *   the default CLI search path is used.
+   * @returns A list of query files found.
+   */
+  resolveQueriesInSuite(suite: string, additionalPacks: string[], searchPath?: string[]): Promise<string[]> {
+    const args = ['--additional-packs', additionalPacks.join(path.delimiter)];
+    if (searchPath !== undefined) {
+      args.push('--search-path', path.join(...searchPath));
+    }
+    args.push(suite);
+    return this.runJsonCodeQlCliCommand<string[]>(
+      ['resolve', 'queries'],
+      args,
+      "Resolving queries",
+    );
+  }
 }

 /**
@@ -693,7 +714,7 @@ export async function runCodeQlCliCommand(codeQlPath: string, command: string[],
    logger.log(`CLI command succeeded.`);
    return result.stdout;
  } catch (err) {
-    throw new Error(`${description} failed: ${err.stderr || err}`)
+    throw new Error(`${description} failed: ${err.stderr || err}`);
  }
 }

--- a/extensions/ql-vscode/src/config.ts
+++ b/extensions/ql-vscode/src/config.ts
@@ -1,5 +1,5 @@
 import { DisposableObject } from 'semmle-vscode-utils';
-import { workspace, Event, EventEmitter, ConfigurationChangeEvent } from 'vscode';
+import { workspace, Event, EventEmitter, ConfigurationChangeEvent, ConfigurationTarget } from 'vscode';
 import { DistributionManager } from './distribution';
 import { logger } from './logging';

@@ -27,10 +27,30 @@ class Setting {
    }
    return workspace.getConfiguration(this.parent.qualifiedName).get<T>(this.name)!;
  }
+
+  updateValue<T>(value: T, target: ConfigurationTarget): Thenable<void> {
+    if (this.parent === undefined) {
+      throw new Error('Cannot update the value of a root setting.');
+    }
+    return workspace.getConfiguration(this.parent.qualifiedName).update(this.name, value, target);
+  }
+
 }

 const ROOT_SETTING = new Setting('codeQL');

+// Enable experimental features
+
+/**
+ * Any settings below are deliberately not in package.json so that
+ * they do not appear in the settings ui in vscode itself. If users
+ * want to enable experimental features, they can add them directly in
+ * their vscode settings json file.
+ */
+
+/* Advanced setting: used to enable bqrs parsing in the cli instead of in the webview. */
+export const EXPERIMENTAL_BQRS_SETTING = new Setting('experimentalBqrsParsing', ROOT_SETTING);
+
 // Distribution configuration

 const DISTRIBUTION_SETTING = new Setting('cli', ROOT_SETTING);
@@ -59,6 +79,7 @@ const NUMBER_OF_THREADS_SETTING = new Setting('numberOfThreads', RUNNING_QUERIES
 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);
+export const AUTOSAVE_SETTING = new Setting('autoSave', RUNNING_QUERIES_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];
--- a/extensions/ql-vscode/src/databaseFetcher.ts
+++ b/extensions/ql-vscode/src/databaseFetcher.ts
@@ -0,0 +1,220 @@
+import * as fetch from "node-fetch";
+import * as unzipper from "unzipper";
+import { Uri, ProgressOptions, ProgressLocation, commands, window } from "vscode";
+import * as fs from "fs-extra";
+import * as path from "path";
+import { DatabaseManager, DatabaseItem } from "./databases";
+import { ProgressCallback, showAndLogErrorMessage, withProgress, showAndLogInformationMessage } from "./helpers";
+
+/**
+ * Prompts a user to fetch a database from a remote location. Database is assumed to be an archive file.
+ *
+ * @param databasesManager the DatabaseManager
+ * @param storagePath where to store the unzipped database.
+ */
+export async function promptImportInternetDatabase(databasesManager: DatabaseManager, storagePath: string): 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)));
+      commands.executeCommand('codeQLDatabases.focus');
+    }
+    showAndLogInformationMessage('Database downloaded and imported successfully.');
+  } catch (e) {
+    showAndLogErrorMessage(e.message);
+  }
+
+  return item;
+}
+
+
+/**
+ * Imports a database from a local archive.
+ *
+ * @param databaseUrl the file url of the archive to import
+ * @param databasesManager the DatabaseManager
+ * @param storagePath where to store the unzipped database.
+ */
+export async function importArchiveDatabase(databaseUrl: string, databasesManager: DatabaseManager, storagePath: string): 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)));
+    commands.executeCommand('codeQLDatabases.focus');
+
+    showAndLogInformationMessage('Database unzipped and imported successfully.');
+  } catch (e) {
+    showAndLogErrorMessage(e.message);
+  }
+  return item;
+}
+
+
+/**
+ * Fetches an archive database. The database might be on the internet
+ * or in the local filesystem.
+ *
+ * @param databaseUrl URL from which to grab the database
+ * @param databasesManager the DatabaseManager
+ * @param storagePath where to store the unzipped database.
+ * @param progressCallback optional callback to send progress messages to
+ */
+async function databaseArchiveFetcher(
+  databaseUrl: string,
+  databasesManager: DatabaseManager,
+  storagePath: string,
+  progressCallback?: ProgressCallback
+): Promise<DatabaseItem> {
+  progressCallback?.({
+    maxStep: 3,
+    message: 'Getting database',
+    step: 1
+  });
+  if (!storagePath) {
+    throw new Error("No storage path specified.");
+  }
+  await fs.ensureDir(storagePath);
+  const unzipPath = await getStorageFolder(storagePath, databaseUrl);
+
+  if (isFile(databaseUrl)) {
+    await readAndUnzip(databaseUrl, unzipPath);
+  } else {
+    await fetchAndUnzip(databaseUrl, unzipPath, progressCallback);
+  }
+
+  progressCallback?.({
+    maxStep: 3,
+    message: 'Opening database',
+    step: 3
+  });
+
+  // find the path to the database. The actual database might be in a sub-folder
+  const dbPath = await findDirWithFile(unzipPath, '.dbinfo', 'codeql-database.yml');
+  if (dbPath) {
+    const item = await databasesManager.openDatabase(Uri.parse(`file:${dbPath}`));
+    databasesManager.setCurrentDatabaseItem(item);
+    return item;
+  } else {
+    throw new Error('Database not found in archive.');
+  }
+}
+
+async function getStorageFolder(storagePath: string, urlStr: string) {
+  // we need to generate a folder name for the unzipped archive,
+  // this needs to be human readable since we may use this name as the initial
+  // name for the database
+  const url = Uri.parse(urlStr);
+  // MacOS has a max filename length of 255
+  // and remove a few extra chars in case we need to add a counter at the end.
+  let lastName = path.basename(url.path).substring(0, 250);
+  if (lastName.endsWith(".zip")) {
+    lastName = lastName.substring(0, lastName.length - 4);
+  }
+
+  const realpath = await fs.realpath(storagePath);
+  let folderName = path.join(realpath, lastName);
+
+  // avoid overwriting existing folders
+  let counter = 0;
+  while (await fs.pathExists(folderName)) {
+    counter++;
+    folderName = path.join(realpath, `${lastName}-${counter}`);
+    if (counter > 100) {
+      throw new Error("Could not find a unique name for downloaded database.");
+    }
+  }
+  return folderName;
+}
+
+
+function validateHttpsUrl(databaseUrl: string) {
+  let uri;
+  try {
+    uri = Uri.parse(databaseUrl, true);
+  } catch (e) {
+    throw new Error(`Invalid url: ${databaseUrl}`);
+  }
+
+  if (uri.scheme !== 'https') {
+    throw new Error('Must use https for downloading a database.');
+  }
+}
+
+async function readAndUnzip(databaseUrl: string, unzipPath: string) {
+  const unzipStream = unzipper.Extract({
+    path: unzipPath
+  });
+
+  await new Promise((resolve, reject) => {
+    // we already know this is a file scheme
+    const databaseFile = Uri.parse(databaseUrl).fsPath;
+    const stream = fs.createReadStream(databaseFile);
+    stream.on('error', reject);
+    unzipStream.on('error', reject);
+    unzipStream.on('close', resolve);
+    stream.pipe(unzipStream);
+  });
+}
+
+async function fetchAndUnzip(databaseUrl: string, unzipPath: string, progressCallback?: ProgressCallback) {
+  const response = await fetch.default(databaseUrl);
+  const unzipStream = unzipper.Extract({
+    path: unzipPath
+  });
+  progressCallback?.({
+    maxStep: 3,
+    message: 'Unzipping database',
+    step: 2
+  });
+  await new Promise((resolve, reject) => {
+    response.body.on('error', reject);
+    unzipStream.on('error', reject);
+    unzipStream.on('close', resolve);
+    response.body.pipe(unzipStream);
+  });
+}
+
+function isFile(databaseUrl: string) {
+  return Uri.parse(databaseUrl).scheme === 'file';
+}
+
+/**
+ * Recursively looks for a file in a directory. If the file exists, then returns the directory containing the file.
+ *
+ * @param dir The directory to search
+ * @param toFind The file to recursively look for in this directory
+ *
+ * @returns the directory containing the file, or undefined if not found.
+ */
+async function findDirWithFile(dir: string, ...toFind: string[]): Promise<string | undefined> {
+  if (!(await fs.stat(dir)).isDirectory()) {
+    return;
+  }
+  const files = await fs.readdir(dir);
+  if (toFind.some(file => files.includes(file))) {
+    return dir;
+  }
+  for (const file of files) {
+    const newPath = path.join(dir, file);
+    const result = await findDirWithFile(newPath, ...toFind);
+    if (result) {
+      return result;
+    }
+  }
+  return;
+}
--- a/extensions/ql-vscode/src/databases-ui.ts
+++ b/extensions/ql-vscode/src/databases-ui.ts
@@ -1,13 +1,14 @@
 import * as path from 'path';
 import { DisposableObject } from 'semmle-vscode-utils';
-import { commands, Event, EventEmitter, ExtensionContext, ProviderResult, TreeDataProvider, TreeItem, Uri, window } from 'vscode';
+import { commands, Event, EventEmitter, ExtensionContext, ProviderResult, TreeDataProvider, TreeItem, Uri, window, env } from 'vscode';
 import * as cli from './cli';
 import { DatabaseItem, DatabaseManager, getUpgradesDirectories } from './databases';
-import { getOnDiskWorkspaceFolders } from './helpers';
+import { getOnDiskWorkspaceFolders, showAndLogErrorMessage } from './helpers';
 import { logger } from './logging';
 import { clearCacheInDatabase, UserCancellationException } from './run-queries';
 import * as qsClient from './queryserver-client';
 import { upgradeDatabase } from './upgrades';
+import { importArchiveDatabase, promptImportInternetDatabase } from './databaseFetcher';

 type ThemableIconPath = { light: string; dark: string } | string;

@@ -15,8 +16,8 @@ type ThemableIconPath = { light: string; dark: string } | string;
 * Path to icons to display next to currently selected database.
 */
 const SELECTED_DATABASE_ICON: ThemableIconPath = {
-  light: 'media/check-light-mode.svg',
-  dark: 'media/check-dark-mode.svg',
+  light: 'media/light/check.svg',
+  dark: 'media/dark/check.svg',
 };

 /**
@@ -34,12 +35,21 @@ function joinThemableIconPath(base: string, iconPath: ThemableIconPath): Themabl
    return path.join(base, iconPath);
 }

+enum SortOrder {
+  NameAsc = 'NameAsc',
+  NameDesc = 'NameDesc',
+  DateAddedAsc = 'DateAddedAsc',
+  DateAddedDesc = 'DateAddedDesc'
+}
+
 /**
 * Tree data provider for the databases view.
 */
 class DatabaseTreeDataProvider extends DisposableObject
  implements TreeDataProvider<DatabaseItem> {

+  private _sortOrder = SortOrder.NameAsc;
+
  private readonly _onDidChangeTreeData = new EventEmitter<DatabaseItem | undefined>();
  private currentDatabaseItem: DatabaseItem | undefined;

@@ -84,7 +94,18 @@ class DatabaseTreeDataProvider extends DisposableObject

  public getChildren(element?: DatabaseItem): ProviderResult<DatabaseItem[]> {
    if (element === undefined) {
-      return this.databaseManager.databaseItems.slice(0);
+      return this.databaseManager.databaseItems.slice(0).sort((db1, db2) => {
+        switch (this.sortOrder) {
+          case SortOrder.NameAsc:
+            return db1.name.localeCompare(db2.name);
+          case SortOrder.NameDesc:
+            return db2.name.localeCompare(db1.name);
+          case SortOrder.DateAddedAsc:
+            return (db1.dateAdded || 0) - (db2.dateAdded || 0);
+          case SortOrder.DateAddedDesc:
+            return (db2.dateAdded || 0) - (db1.dateAdded || 0);
+        }
+      });
    }
    else {
      return [];
@@ -98,6 +119,15 @@ class DatabaseTreeDataProvider extends DisposableObject
  public getCurrent(): DatabaseItem | undefined {
    return this.currentDatabaseItem;
  }
+
+  public get sortOrder() {
+    return this._sortOrder;
+  }
+
+  public set sortOrder(newSortOrder: SortOrder) {
+    this._sortOrder = newSortOrder;
+    this._onDidChangeTreeData.fire();
+  }
 }

 /** Gets the first element in the given list, if any, or undefined if the list is empty or undefined. */
@@ -118,40 +148,88 @@ function getFirst(list: Uri[] | undefined): Uri | undefined {
 * XXX: no validation is done other than checking the directory name
 * to make sure it really is a database directory.
 */
-async function chooseDatabaseDir(): Promise<Uri | undefined> {
+async function chooseDatabaseDir(byFolder: boolean): Promise<Uri | undefined> {
  const chosen = await window.showOpenDialog({
-    openLabel: 'Choose Database',
-    canSelectFiles: true,
-    canSelectFolders: true,
-    canSelectMany: false
+    openLabel: byFolder ? 'Choose Database folder' : 'Choose Database archive',
+    canSelectFiles: !byFolder,
+    canSelectFolders: byFolder,
+    canSelectMany: false,
+    filters: byFolder ? {} : { Archives: ['zip'] }
  });
  return getFirst(chosen);
 }

 export class DatabaseUI extends DisposableObject {
-  public constructor(ctx: ExtensionContext, private cliserver: cli.CodeQLCliServer, private databaseManager: DatabaseManager,
-    private readonly queryServer: qsClient.QueryServerClient | undefined) {
+  private treeDataProvider: DatabaseTreeDataProvider;

+  public constructor(
+    ctx: ExtensionContext,
+    private cliserver: cli.CodeQLCliServer,
+    private databaseManager: DatabaseManager,
+    private readonly queryServer: qsClient.QueryServerClient | undefined,
+    private readonly storagePath: string
+  ) {
    super();

-    const treeDataProvider = this.push(new DatabaseTreeDataProvider(ctx, databaseManager));
-    this.push(window.createTreeView('codeQLDatabases', { treeDataProvider }));
+    this.treeDataProvider = this.push(new DatabaseTreeDataProvider(ctx, databaseManager));
+    this.push(window.createTreeView('codeQLDatabases', { treeDataProvider: this.treeDataProvider }));

-    ctx.subscriptions.push(commands.registerCommand('codeQL.chooseDatabase', this.handleChooseDatabase));
+    logger.log('Registering database panel commands.');
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.chooseDatabaseFolder', this.handleChooseDatabaseFolder));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.chooseDatabaseArchive', this.handleChooseDatabaseArchive));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.chooseDatabaseInternet', this.handleChooseDatabaseInternet));
    ctx.subscriptions.push(commands.registerCommand('codeQL.setCurrentDatabase', this.handleSetCurrentDatabase));
    ctx.subscriptions.push(commands.registerCommand('codeQL.upgradeCurrentDatabase', this.handleUpgradeCurrentDatabase));
    ctx.subscriptions.push(commands.registerCommand('codeQL.clearCache', this.handleClearCache));
    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.setCurrentDatabase', this.handleMakeCurrentDatabase));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.sortByName', this.handleSortByName));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.sortByDateAdded', this.handleSortByDateAdded));
    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.removeDatabase', this.handleRemoveDatabase));
    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.upgradeDatabase', this.handleUpgradeDatabase));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.renameDatabase', this.handleRenameDatabase));
+    ctx.subscriptions.push(commands.registerCommand('codeQLDatabases.openDatabaseFolder', this.handleOpenFolder));
  }

  private handleMakeCurrentDatabase = async (databaseItem: DatabaseItem): Promise<void> => {
    await this.databaseManager.setCurrentDatabaseItem(databaseItem);
  }

-  private handleChooseDatabase = async (): Promise<DatabaseItem | undefined> => {
-    return await this.chooseAndSetDatabase();
+  handleChooseDatabaseFolder = async (): Promise<DatabaseItem | undefined> => {
+    try {
+      return await this.chooseAndSetDatabase(true);
+    } catch (e) {
+      showAndLogErrorMessage(e.message);
+      return undefined;
+    }
+  }
+
+  handleChooseDatabaseArchive = async (): Promise<DatabaseItem | undefined> => {
+    try {
+      return await this.chooseAndSetDatabase(false);
+    } catch (e) {
+      showAndLogErrorMessage(e.message);
+      return undefined;
+    }
+  }
+
+  handleChooseDatabaseInternet = async (): Promise<DatabaseItem | undefined> => {
+    return await promptImportInternetDatabase(this.databaseManager, this.storagePath);
+  }
+
+  private handleSortByName = async () => {
+    if (this.treeDataProvider.sortOrder === SortOrder.NameAsc) {
+      this.treeDataProvider.sortOrder = SortOrder.NameDesc;
+    } else {
+      this.treeDataProvider.sortOrder = SortOrder.NameAsc;
+    }
+  }
+
+  private handleSortByDateAdded = async () => {
+    if (this.treeDataProvider.sortOrder === SortOrder.DateAddedAsc) {
+      this.treeDataProvider.sortOrder = SortOrder.DateAddedDesc;
+    } else {
+      this.treeDataProvider.sortOrder = SortOrder.DateAddedAsc;
+    }
  }

  private handleUpgradeCurrentDatabase = async (): Promise<void> => {
@@ -213,6 +291,11 @@ export class DatabaseUI extends DisposableObject {
  }

  private handleSetCurrentDatabase = async (uri: Uri): Promise<DatabaseItem | undefined> => {
+    // Assume user has selected an archive if the file has a .zip extension
+    if (uri.path.endsWith('.zip')) {
+      return await importArchiveDatabase(uri.toString(true), this.databaseManager, this.storagePath);
+    }
+
    return await this.setCurrentDatabase(uri);
  }

@@ -220,6 +303,29 @@ export class DatabaseUI extends DisposableObject {
    this.databaseManager.removeDatabaseItem(databaseItem);
  }

+  private handleRenameDatabase = async (databaseItem: DatabaseItem): Promise<void> => {
+    try {
+      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);
+    }
+  }
+
+  private handleOpenFolder = async (databaseItem: DatabaseItem): Promise<void> => {
+    try {
+      await env.openExternal(databaseItem.databaseUri);
+    } catch (e) {
+      showAndLogErrorMessage(e.message);
+    }
+  }
+
  /**
   * Return the current database directory. If we don't already have a
   * current database, ask the user for one, and return that, or
@@ -227,7 +333,7 @@ export class DatabaseUI extends DisposableObject {
   */
  public async getDatabaseItem(): Promise<DatabaseItem | undefined> {
    if (this.databaseManager.currentDatabaseItem === undefined) {
-      await this.chooseAndSetDatabase();
+      await this.chooseAndSetDatabase(false);
    }

    return this.databaseManager.currentDatabaseItem;
@@ -247,13 +353,21 @@ export class DatabaseUI extends DisposableObject {
   * Ask the user for a database directory. Returns the chosen database, or `undefined` if the
   * operation was canceled.
   */
-  private async chooseAndSetDatabase(): Promise<DatabaseItem | undefined> {
-    const uri = await chooseDatabaseDir();
-    if (uri !== undefined) {
+  private async chooseAndSetDatabase(byFolder: boolean): Promise<DatabaseItem | undefined> {
+    const uri = await chooseDatabaseDir(byFolder);
+
+    if (!uri) {
+      return undefined;
+    }
+
+    if (byFolder) {
+      // we are selecting a database folder
      return await this.setCurrentDatabase(uri);
    }
    else {
-      return undefined;
+      // 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);
    }
  }
 }
--- a/extensions/ql-vscode/src/databases.ts
+++ b/extensions/ql-vscode/src/databases.ts
@@ -35,10 +35,12 @@ const DB_LIST = 'databaseList';
 export interface DatabaseOptions {
  displayName?: string;
  ignoreSourceArchive?: boolean;
+  dateAdded?: number | undefined;
 }

 interface FullDatabaseOptions extends DatabaseOptions {
  ignoreSourceArchive: boolean;
+  dateAdded: number | undefined;
 }

 interface PersistedDatabaseItem {
@@ -107,10 +109,11 @@ async function findDataset(parentDirectory: string): Promise<vscode.Uri> {
  return vscode.Uri.file(dbAbsolutePath);
 }

-async function findSourceArchive(databasePath: string, silent = false):
-Promise<vscode.Uri | undefined> {
+async function findSourceArchive(
+  databasePath: string, silent = false
+): Promise<vscode.Uri | undefined> {

-  const relativePaths = ['src', 'output/src_archive']
+  const relativePaths = ['src', 'output/src_archive'];

  for (const relativePath of relativePaths) {
    const basePath = path.join(databasePath, relativePath);
@@ -201,7 +204,7 @@ export interface DatabaseItem {
  /** The URI of the database */
  readonly databaseUri: vscode.Uri;
  /** The name of the database to be displayed in the UI */
-  readonly name: string;
+  name: string;
  /** The URI of the database's source archive, or `undefined` if no source archive is to be used. */
  readonly sourceArchive: vscode.Uri | undefined;
  /**
@@ -209,6 +212,12 @@ export interface DatabaseItem {
   * Will be `undefined` if the database is invalid. Can be updated by calling `refresh()`.
   */
  readonly contents: DatabaseContents | undefined;
+
+  /**
+   * The date this database was added as a unix timestamp. Or undefined if we don't know.
+   */
+  readonly dateAdded: number | undefined;
+
  /** If the database is invalid, describes why. */
  readonly error: Error | undefined;
  /**
@@ -279,6 +288,10 @@ class DatabaseItemImpl implements DatabaseItem {
    }
  }

+  public set name(newName: string) {
+    this.options.displayName = newName;
+  }
+
  public get sourceArchive(): vscode.Uri | undefined {
    if (this.options.ignoreSourceArchive || (this._contents === undefined)) {
      return undefined;
@@ -292,6 +305,10 @@ class DatabaseItemImpl implements DatabaseItem {
    return this._contents;
  }

+  public get dateAdded(): number | undefined {
+    return this.options.dateAdded;
+  }
+
  public get error(): Error | undefined {
    return this._error;
  }
@@ -430,31 +447,28 @@ class DatabaseItemImpl implements DatabaseItem {
 */
 function eventFired<T>(event: vscode.Event<T>, timeoutMs = 1000): Promise<T | undefined> {
  return new Promise((res, _rej) => {
-    let timeout: NodeJS.Timeout | undefined;
-    let disposable: vscode.Disposable | undefined;
-    function dispose() {
-      if (timeout !== undefined) clearTimeout(timeout);
-      if (disposable !== undefined) disposable.dispose();
-    }
-    disposable = event(e => {
-      res(e);
-      dispose();
-    });
-    timeout = setTimeout(() => {
+    const timeout = setTimeout(() => {
      logger.log(`Waiting for event ${event} timed out after ${timeoutMs}ms`);
      res(undefined);
      dispose();
    }, timeoutMs);
+    const disposable = event(e => {
+      res(e);
+      dispose();
+    });
+    function dispose() {
+      clearTimeout(timeout);
+      disposable.dispose();
+    }
  });
 }

 export class DatabaseManager extends DisposableObject {
-  private readonly _onDidChangeDatabaseItem =
-  this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
+  private readonly _onDidChangeDatabaseItem = this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
+
  readonly onDidChangeDatabaseItem = this._onDidChangeDatabaseItem.event;

-  private readonly _onDidChangeCurrentDatabaseItem =
-  this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
+  private readonly _onDidChangeCurrentDatabaseItem = this.push(new vscode.EventEmitter<DatabaseItem | undefined>());
  readonly onDidChangeCurrentDatabaseItem = this._onDidChangeCurrentDatabaseItem.event;

  private readonly _databaseItems: DatabaseItemImpl[] = [];
@@ -468,8 +482,9 @@ export class DatabaseManager extends DisposableObject {
    this.loadPersistedState();  // Let this run async.
  }

-  public async openDatabase(uri: vscode.Uri, options?: DatabaseOptions):
-  Promise<DatabaseItem> {
+  public async openDatabase(
+    uri: vscode.Uri, options?: DatabaseOptions
+  ): Promise<DatabaseItem> {

    const contents = await resolveDatabaseContents(uri);
    const realOptions = options || {};
@@ -478,7 +493,8 @@ export class DatabaseManager extends DisposableObject {
    const fullOptions: FullDatabaseOptions = {
      ignoreSourceArchive: (realOptions.ignoreSourceArchive !== undefined) ?
        realOptions.ignoreSourceArchive : isQLTestDatabase,
-      displayName: realOptions.displayName
+      displayName: realOptions.displayName,
+      dateAdded: realOptions.dateAdded || Date.now()
    };
    const databaseItem = new DatabaseItemImpl(uri, contents, fullOptions, (item) => {
      this._onDidChangeDatabaseItem.fire(item);
@@ -528,11 +544,13 @@ export class DatabaseManager extends DisposableObject {
    }
  }

-  private async createDatabaseItemFromPersistedState(state: PersistedDatabaseItem):
-  Promise<DatabaseItem> {
+  private async createDatabaseItemFromPersistedState(
+    state: PersistedDatabaseItem
+  ): Promise<DatabaseItem> {

    let displayName: string | undefined = undefined;
    let ignoreSourceArchive = false;
+    let dateAdded = undefined;
    if (state.options) {
      if (typeof state.options.displayName === 'string') {
        displayName = state.options.displayName;
@@ -540,14 +558,18 @@ export class DatabaseManager extends DisposableObject {
      if (typeof state.options.ignoreSourceArchive === 'boolean') {
        ignoreSourceArchive = state.options.ignoreSourceArchive;
      }
+      if (typeof state.options.dateAdded === 'number') {
+        dateAdded = state.options.dateAdded;
+      }
    }
    const fullOptions: FullDatabaseOptions = {
-      ignoreSourceArchive: ignoreSourceArchive,
-      displayName: displayName
+      ignoreSourceArchive,
+      displayName,
+      dateAdded
    };
    const item = new DatabaseItemImpl(vscode.Uri.parse(state.uri), undefined, fullOptions,
      (item) => {
-        this._onDidChangeDatabaseItem.fire(item)
+        this._onDidChangeDatabaseItem.fire(item);
      });
    await this.addDatabaseItem(item);

@@ -613,12 +635,23 @@ export class DatabaseManager extends DisposableObject {
    return this._databaseItems.find(item => item.databaseUri.toString(true) === uriString);
  }

+  public findDatabaseItemBySourceArchive(uri: vscode.Uri): DatabaseItem | undefined {
+    const uriString = uri.toString(true);
+    return this._databaseItems.find(item => item.sourceArchive && item.sourceArchive.toString(true) === uriString);
+  }
+
  private async addDatabaseItem(item: DatabaseItemImpl) {
    this._databaseItems.push(item);
    this.updatePersistedDatabaseList();
    this._onDidChangeDatabaseItem.fire(undefined);
  }

+  public async renameDatabaseItem(item: DatabaseItem, newName: string) {
+    item.name = newName;
+    this.updatePersistedDatabaseList();
+    this._onDidChangeDatabaseItem.fire(item);
+  }
+
  public removeDatabaseItem(item: DatabaseItem) {
    if (this._currentDatabaseItem == item)
      this._currentDatabaseItem = undefined;
@@ -635,6 +668,14 @@ export class DatabaseManager extends DisposableObject {
      vscode.workspace.updateWorkspaceFolders(folderIndex, 1);
    }

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

@@ -646,6 +687,11 @@ export class DatabaseManager extends DisposableObject {
  private updatePersistedDatabaseList(): void {
    this.ctx.workspaceState.update(DB_LIST, this._databaseItems.map(item => item.getPersistedState()));
  }
+
+  private isExtensionControlledLocation(uri: vscode.Uri) {
+    const storagePath = this.ctx.storagePath || this.ctx.globalStoragePath;
+    return uri.path.startsWith(storagePath);
+  }
 }

 /**
--- a/extensions/ql-vscode/src/definitions.ts
+++ b/extensions/ql-vscode/src/definitions.ts
@@ -0,0 +1,204 @@
+import * as fs from 'fs-extra';
+import * as yaml from 'js-yaml';
+import * as tmp from 'tmp';
+import * as vscode from "vscode";
+import { decodeSourceArchiveUri, zipArchiveScheme } from "./archive-filesystem-provider";
+import { ColumnKindCode, EntityValue, getResultSetSchema, LineColumnLocation, UrlValue } from "./bqrs-cli-types";
+import { CodeQLCliServer } from "./cli";
+import { DatabaseItem, DatabaseManager } from "./databases";
+import * as helpers from './helpers';
+import { CachedOperation } from './helpers';
+import * as messages from "./messages";
+import { QueryServerClient } from "./queryserver-client";
+import { compileAndRunQueryAgainstDatabase, QueryWithResults } from "./run-queries";
+
+/**
+ * Run templated CodeQL queries to find definitions and references in
+ * source-language files. We may eventually want to find a way to
+ * generalize this to other custom queries, e.g. showing dataflow to
+ * or from a selected identifier.
+ */
+
+const TEMPLATE_NAME = "selectedSourceFile";
+const SELECT_QUERY_NAME = "#select";
+
+enum KeyType {
+  DefinitionQuery = 'DefinitionQuery',
+  ReferenceQuery = 'ReferenceQuery',
+}
+
+function tagOfKeyType(keyType: KeyType): string {
+  switch (keyType) {
+    case KeyType.DefinitionQuery: return "ide-contextual-queries/local-definitions";
+    case KeyType.ReferenceQuery: return "ide-contextual-queries/local-references";
+  }
+}
+
+async function resolveQueries(cli: CodeQLCliServer, qlpack: string, keyType: KeyType): Promise<string[]> {
+  const suiteFile = tmp.fileSync({ postfix: '.qls' }).name;
+  const suiteYaml = { qlpack, include: { kind: 'definitions', 'tags contain': tagOfKeyType(keyType) } };
+  await fs.writeFile(suiteFile, yaml.safeDump(suiteYaml), 'utf8');
+
+  const queries = await cli.resolveQueriesInSuite(suiteFile, helpers.getOnDiskWorkspaceFolders());
+  if (queries.length === 0) {
+    throw new Error("Couldn't find any queries for qlpack");
+  }
+  return queries;
+}
+
+async function qlpackOfDatabase(cli: CodeQLCliServer, db: DatabaseItem): Promise<string | undefined> {
+  if (db.contents === undefined)
+    return undefined;
+  const datasetPath = db.contents.datasetUri.fsPath;
+  const { qlpack } = await helpers.resolveDatasetFolder(cli, datasetPath);
+  return qlpack;
+}
+
+interface FullLocationLink extends vscode.LocationLink {
+  originUri: vscode.Uri;
+}
+
+export class TemplateQueryDefinitionProvider implements vscode.DefinitionProvider {
+  private cache: CachedOperation<vscode.LocationLink[]>;
+
+  constructor(
+    private cli: CodeQLCliServer,
+    private qs: QueryServerClient,
+    private dbm: DatabaseManager,
+  ) {
+    this.cache = new CachedOperation<vscode.LocationLink[]>(this.getDefinitions.bind(this));
+  }
+
+  async getDefinitions(uriString: string): Promise<vscode.LocationLink[]> {
+    return getLinksForUriString(this.cli, this.qs, this.dbm, uriString, KeyType.DefinitionQuery, (src, _dest) => src === uriString);
+  }
+
+  async provideDefinition(document: vscode.TextDocument, position: vscode.Position, _token: vscode.CancellationToken): Promise<vscode.LocationLink[]> {
+    const fileLinks = await this.cache.get(document.uri.toString());
+    const locLinks: vscode.LocationLink[] = [];
+    for (const link of fileLinks) {
+      if (link.originSelectionRange!.contains(position)) {
+        locLinks.push(link);
+      }
+    }
+    return locLinks;
+  }
+}
+
+export class TemplateQueryReferenceProvider implements vscode.ReferenceProvider {
+  private cache: CachedOperation<FullLocationLink[]>;
+
+  constructor(
+    private cli: CodeQLCliServer,
+    private qs: QueryServerClient,
+    private dbm: DatabaseManager,
+  ) {
+    this.cache = new CachedOperation<FullLocationLink[]>(this.getReferences.bind(this));
+  }
+
+  async getReferences(uriString: string): Promise<FullLocationLink[]> {
+    return getLinksForUriString(this.cli, this.qs, this.dbm, uriString, KeyType.ReferenceQuery, (_src, dest) => dest === uriString);
+  }
+
+  async provideReferences(document: vscode.TextDocument, position: vscode.Position, _context: vscode.ReferenceContext, _token: vscode.CancellationToken): Promise<vscode.Location[]> {
+    const fileLinks = await this.cache.get(document.uri.toString());
+    const locLinks: vscode.Location[] = [];
+    for (const link of fileLinks) {
+      if (link.targetRange!.contains(position)) {
+        locLinks.push({ range: link.originSelectionRange!, uri: link.originUri });
+      }
+    }
+    return locLinks;
+  }
+}
+
+interface FileRange {
+  file: vscode.Uri;
+  range: vscode.Range;
+}
+
+async function getLinksFromResults(results: QueryWithResults, cli: CodeQLCliServer, db: DatabaseItem, filter: (srcFile: string, destFile: string) => boolean): Promise<FullLocationLink[]> {
+  const localLinks: FullLocationLink[] = [];
+  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) {
+    // TODO: Page this
+    const allTuples = await cli.bqrsDecode(bqrsPath, SELECT_QUERY_NAME);
+    for (const tuple of allTuples.tuples) {
+      const src = tuple[0] as EntityValue;
+      const dest = tuple[1] as EntityValue;
+      const srcFile = src.url && fileRangeFromURI(src.url, db);
+      const destFile = dest.url && fileRangeFromURI(dest.url, db);
+      if (srcFile && destFile && filter(srcFile.file.toString(), destFile.file.toString())) {
+        localLinks.push({ targetRange: destFile.range, targetUri: destFile.file, originSelectionRange: srcFile.range, originUri: srcFile.file });
+      }
+    }
+  }
+  return localLinks;
+}
+
+async function getLinksForUriString(
+  cli: CodeQLCliServer,
+  qs: QueryServerClient,
+  dbm: DatabaseManager,
+  uriString: string,
+  keyType: KeyType,
+  filter: (src: string, dest: string) => boolean
+) {
+  const uri = decodeSourceArchiveUri(vscode.Uri.parse(uriString));
+  const sourceArchiveUri = vscode.Uri.file(uri.sourceArchiveZipPath).with({ scheme: zipArchiveScheme });
+
+  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 {
+    return [];
+  }
+}
+
+function fileRangeFromURI(uri: UrlValue, db: DatabaseItem): FileRange | undefined {
+  if (typeof uri === "string") {
+    return undefined;
+  } else if ('startOffset' in uri) {
+    return undefined;
+  } else {
+    const loc = uri as LineColumnLocation;
+    const range = new vscode.Range(Math.max(0, loc.startLine - 1),
+      Math.max(0, loc.startColumn - 1),
+      Math.max(0, loc.endLine - 1),
+      Math.max(0, loc.endColumn));
+    try {
+      const parsed = vscode.Uri.parse(uri.uri, true);
+      if (parsed.scheme === "file") {
+        return { file: db.resolveSourceFile(parsed.fsPath), range };
+      }
+      return undefined;
+    } catch (e) {
+      return undefined;
+    }
+  }
+}
--- a/extensions/ql-vscode/src/discovery.ts
+++ b/extensions/ql-vscode/src/discovery.ts
@@ -84,4 +84,4 @@ export abstract class Discovery<T> extends DisposableObject {
   * @param results The discovery results returned by the `discover` function.
   */
  protected abstract update(results: T): void;
-}
+}
--- a/extensions/ql-vscode/src/distribution.ts
+++ b/extensions/ql-vscode/src/distribution.ts
@@ -6,7 +6,7 @@ import * as unzipper from "unzipper";
 import * as url from "url";
 import { ExtensionContext, Event } from "vscode";
 import { DistributionConfig } from "./config";
-import { InvocationRateLimiter, InvocationRateLimiterResultKind, ProgressUpdate, showAndLogErrorMessage } from "./helpers";
+import { InvocationRateLimiter, InvocationRateLimiterResultKind, showAndLogErrorMessage } from "./helpers";
 import { logger } from "./logging";
 import * as helpers from "./helpers";
 import { getCodeQlCliVersion, tryParseVersionString, Version } from "./cli-version";
@@ -42,9 +42,9 @@ const DEFAULT_DISTRIBUTION_REPOSITORY_NAME = "codeql-cli-binaries";
 export const DEFAULT_DISTRIBUTION_VERSION_CONSTRAINT: VersionConstraint = {
  description: "2.*.*",
  isVersionCompatible: (v: Version) => {
-    return v.majorVersion === 2 && v.minorVersion >= 0
+    return v.majorVersion === 2 && v.minorVersion >= 0;
  }
-}
+};

 export interface DistributionProvider {
  getCodeQlPathWithoutVersionCheck(): Promise<string | undefined>;
@@ -86,7 +86,7 @@ export class DistributionManager implements DistributionProvider {
      return {
        codeQlPath,
        kind: FindDistributionResultKind.UnknownCompatibilityDistribution,
-      }
+      };
    }
    return {
      codeQlPath,
@@ -112,7 +112,13 @@ export class DistributionManager implements DistributionProvider {
          "that a CodeQL executable exists at the specified path or remove the setting.");
        return undefined;
      }
-      if (deprecatedCodeQlLauncherName() && this._config.customCodeQlPath.endsWith(deprecatedCodeQlLauncherName()!)) {
+
+      // emit a warning if using a deprecated launcher and a non-deprecated launcher exists
+      if (
+        deprecatedCodeQlLauncherName() &&
+        this._config.customCodeQlPath.endsWith(deprecatedCodeQlLauncherName()!) &&
+        await this.hasNewLauncherName()
+      ) {
        warnDeprecatedLauncher();
      }
      return this._config.customCodeQlPath;
@@ -165,7 +171,7 @@ export class DistributionManager implements DistributionProvider {
   * Returns a failed promise if an unexpected error occurs during installation.
   */
  public installExtensionManagedDistributionRelease(release: Release,
-    progressCallback?: (p: ProgressUpdate) => void): Promise<void> {
+    progressCallback?: helpers.ProgressCallback): Promise<void> {
    return this._extensionSpecificDistributionManager.installDistributionRelease(release, progressCallback);
  }

@@ -173,6 +179,21 @@ export class DistributionManager implements DistributionProvider {
    return this._onDidChangeDistribution;
  }

+  /**
+   * @return true if the non-deprecated launcher name exists on the file system
+   * in the same directory as the specified launcher only if using an external
+   * installation. False otherwise.
+   */
+  private async hasNewLauncherName(): Promise<boolean> {
+    if (!this._config.customCodeQlPath) {
+      // not managed externally
+      return false;
+    }
+    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>;
@@ -232,14 +253,14 @@ class ExtensionSpecificDistributionManager {
   * Returns a failed promise if an unexpected error occurs during installation.
   */
  public async installDistributionRelease(release: Release,
-    progressCallback?: (p: ProgressUpdate) => void): Promise<void> {
+    progressCallback?: helpers.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?: (p: ProgressUpdate) => void): Promise<void> {
+    progressCallback?: helpers.ProgressCallback): Promise<void> {
    try {
      await this.removeDistribution();
    } catch (e) {
@@ -459,7 +480,7 @@ export class ReleasesApiConsumer {
        // mechanism is provided.
        delete headers["authorization"];
      }
-      return await this.makeRawRequest(redirectUrl, headers, redirectCount + 1)
+      return await this.makeRawRequest(redirectUrl, headers, redirectCount + 1);
    }

    return response;
--- a/extensions/ql-vscode/src/extension.ts
+++ b/extensions/ql-vscode/src/extension.ts
@@ -1,25 +1,23 @@
-import { commands, Disposable, ExtensionContext, extensions, ProgressLocation, ProgressOptions, window as Window, Uri } from 'vscode';
+import { commands, Disposable, ExtensionContext, extensions, languages, ProgressLocation, ProgressOptions, Uri, window as Window } from 'vscode';
 import { LanguageClient } from 'vscode-languageclient';
+import { testExplorerExtensionId, TestHub } from 'vscode-test-adapter-api';
 import * as archiveFilesystemProvider from './archive-filesystem-provider';
-import { DistributionConfigListener, QueryServerConfigListener, QueryHistoryConfigListener } from './config';
+import { CodeQLCliServer } from './cli';
+import { DistributionConfigListener, QueryHistoryConfigListener, QueryServerConfigListener } from './config';
 import { DatabaseManager } from './databases';
 import { DatabaseUI } from './databases-ui';
-import {
-  DistributionUpdateCheckResultKind, DistributionManager, FindDistributionResult, FindDistributionResultKind, GithubApiError,
-  DEFAULT_DISTRIBUTION_VERSION_CONSTRAINT, GithubRateLimitedError
-} from './distribution';
+import { TemplateQueryDefinitionProvider, TemplateQueryReferenceProvider } from './definitions';
+import { DEFAULT_DISTRIBUTION_VERSION_CONSTRAINT, DistributionManager, DistributionUpdateCheckResultKind, FindDistributionResult, FindDistributionResultKind, GithubApiError, GithubRateLimitedError } from './distribution';
 import * as helpers from './helpers';
+import { assertNever } from './helpers-pure';
 import { spawnIdeServer } from './ide-server';
 import { InterfaceManager, WebviewReveal } from './interface';
 import { ideServerLogger, logger, queryServerLogger } from './logging';
-import { compileAndRunQueryAgainstDatabase, tmpDirDisposal, UserCancellationException } from './run-queries';
-import { CompletedQuery } from './query-results';
 import { QueryHistoryManager } from './query-history';
+import { CompletedQuery } from './query-results';
 import * as qsClient from './queryserver-client';
-import { CodeQLCliServer } from './cli';
-import { assertNever } from './helpers-pure';
 import { displayQuickQuery } from './quick-query';
-import { TestHub, testExplorerExtensionId } from 'vscode-test-adapter-api';
+import { compileAndRunQueryAgainstDatabase, tmpDirDisposal, UserCancellationException } from './run-queries';
 import { QLTestAdapterFactory } from './test-adapter';
 import { TestUIService } from './test-ui';

@@ -62,8 +60,9 @@ function registerErrorStubs(excludedCommands: string[], stubGenerator: (command:

  const extensionId = 'GitHub.vscode-codeql'; // TODO: Is there a better way of obtaining this?
  const extension = extensions.getExtension(extensionId);
-  if (extension === undefined)
+  if (extension === undefined) {
    throw new Error(`Can't find extension ${extensionId}`);
+  }

  const stubbedCommands: string[]
    = extension.packageJSON.contributes.commands.map((entry: { command: string }) => entry.command);
@@ -251,31 +250,39 @@ async function activateWithInstalledDistribution(ctx: ExtensionContext, distribu
  // of activation.
  errorStubs.forEach(stub => stub.dispose());

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

+  logger.log('Initializing CodeQL cli server...');
  const cliServer = new CodeQLCliServer(distributionManager, logger);
  ctx.subscriptions.push(cliServer);

+  logger.log('Initializing query server client.');
  const qs = new qsClient.QueryServerClient(qlConfigurationListener, cliServer, {
    logger: queryServerLogger,
  }, task => Window.withProgress({ title: 'CodeQL query server', location: ProgressLocation.Window }, task));
  ctx.subscriptions.push(qs);
  await qs.startQueryServer();

+  logger.log('Initializing database manager.');
  const dbm = new DatabaseManager(ctx, qlConfigurationListener, logger);
  ctx.subscriptions.push(dbm);
-  const databaseUI = new DatabaseUI(ctx, cliServer, dbm, qs);
+  logger.log('Initializing database panel.');
+  const databaseUI = new DatabaseUI(ctx, cliServer, dbm, qs, getContextStoragePath(ctx));
  ctx.subscriptions.push(databaseUI);

+  logger.log('Initializing query history manager.');
  const queryHistoryConfigurationListener = new QueryHistoryConfigListener();
  const qhm = new QueryHistoryManager(
    ctx,
    queryHistoryConfigurationListener,
    async item => showResultsForCompletedQuery(item, WebviewReveal.Forced)
  );
+  logger.log('Initializing results panel interface.');
  const intm = new InterfaceManager(ctx, dbm, cliServer, queryServerLogger);
  ctx.subscriptions.push(intm);
+  logger.log('Initializing source archive filesystem provider.');
  archiveFilesystemProvider.activate(ctx);

  async function showResultsForCompletedQuery(query: CompletedQuery, forceReveal: WebviewReveal): Promise<void> {
@@ -306,6 +313,7 @@ async function activateWithInstalledDistribution(ctx: ExtensionContext, distribu

  ctx.subscriptions.push(tmpDirDisposal);

+  logger.log('Initializing CodeQL language server.');
  const client = new LanguageClient('CodeQL Language Server', () => spawnIdeServer(qlConfigurationListener), {
    documentSelector: [
      { language: 'ql', scheme: 'file' },
@@ -318,6 +326,7 @@ async function activateWithInstalledDistribution(ctx: ExtensionContext, distribu
    outputChannel: ideServerLogger.outputChannel
  }, true);

+  logger.log('Initializing QLTest interface.');
  const testExplorerExtension = extensions.getExtension<TestHub>(testExplorerExtensionId);
  if (testExplorerExtension) {
    const testHub = testExplorerExtension.exports;
@@ -328,6 +337,7 @@ async function activateWithInstalledDistribution(ctx: ExtensionContext, distribu
    ctx.subscriptions.push(testUIService);
  }

+  logger.log('Registering top-level command palette commands.');
  ctx.subscriptions.push(commands.registerCommand('codeQL.runQuery', async (uri: Uri | undefined) => await compileAndRunQuery(false, uri)));
  ctx.subscriptions.push(commands.registerCommand('codeQL.quickEval', async (uri: Uri | undefined) => await compileAndRunQuery(true, uri)));
  ctx.subscriptions.push(commands.registerCommand('codeQL.quickQuery', async () => displayQuickQuery(ctx, cliServer, databaseUI)));
@@ -335,14 +345,36 @@ async function activateWithInstalledDistribution(ctx: ExtensionContext, distribu
    await qs.restartQueryServer();
    helpers.showAndLogInformationMessage('CodeQL Query Server restarted.', { outputLogger: queryServerLogger });
  }));
+  ctx.subscriptions.push(commands.registerCommand('codeQL.chooseDatabaseFolder', () => databaseUI.handleChooseDatabaseFolder()));
+  ctx.subscriptions.push(commands.registerCommand('codeQL.chooseDatabaseArchive', () => databaseUI.handleChooseDatabaseArchive()));
+  ctx.subscriptions.push(commands.registerCommand('codeQL.chooseDatabaseInternet', () => databaseUI.handleChooseDatabaseInternet()));

+  logger.log('Starting language server.');
  ctx.subscriptions.push(client.start());
+
+  // Jump-to-definition and find-references
+  logger.log('Registering jump-to-definition handlers.');
+  languages.registerDefinitionProvider(
+    { scheme: archiveFilesystemProvider.zipArchiveScheme },
+    new TemplateQueryDefinitionProvider(cliServer, qs, dbm)
+  );
+  languages.registerReferenceProvider(
+    { scheme: archiveFilesystemProvider.zipArchiveScheme },
+    new TemplateQueryReferenceProvider(cliServer, qs, dbm)
+  );
+
+  logger.log('Successfully finished extension initialization.');
+}
+
+function getContextStoragePath(ctx: ExtensionContext) {
+  return ctx.storagePath || ctx.globalStoragePath;
 }

 function initializeLogging(ctx: ExtensionContext): void {
-  logger.init(ctx);
-  queryServerLogger.init(ctx);
-  ideServerLogger.init(ctx);
+  const storagePath = getContextStoragePath(ctx);
+  logger.init(storagePath);
+  queryServerLogger.init(storagePath);
+  ideServerLogger.init(storagePath);
  ctx.subscriptions.push(logger);
  ctx.subscriptions.push(queryServerLogger);
  ctx.subscriptions.push(ideServerLogger);
--- a/extensions/ql-vscode/src/helpers.ts
+++ b/extensions/ql-vscode/src/helpers.ts
@@ -1,5 +1,9 @@
+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 { CodeQLCliServer } from './cli';
 import { logger } from './logging';
 import { QueryInfo } from './run-queries';

@@ -18,6 +22,8 @@ export interface ProgressUpdate {
  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
@@ -110,7 +116,7 @@ async function internalShowAndLog(message: string, items: string[], outputLogger
 */
 export async function showBinaryChoiceDialog(message: string): Promise<boolean> {
  const yesItem = { title: 'Yes', isCloseAffordance: false };
-  const noItem = { title: 'No', isCloseAffordance: true }
+  const noItem = { title: 'No', isCloseAffordance: true };
  const chosenItem = await Window.showInformationMessage(message, { modal: true }, yesItem, noItem);
  return chosenItem === yesItem;
 }
@@ -134,7 +140,7 @@ export function getOnDiskWorkspaceFolders() {
  const diskWorkspaceFolders: string[] = [];
  for (const workspaceFolder of workspaceFolders) {
    if (workspaceFolder.uri.scheme === "file")
-      diskWorkspaceFolders.push(workspaceFolder.uri.fsPath)
+      diskWorkspaceFolders.push(workspaceFolder.uri.fsPath);
  }
  return diskWorkspaceFolders;
 }
@@ -244,3 +250,110 @@ function createRateLimitedResult(): RateLimitedResult {
    kind: InvocationRateLimiterResultKind.RateLimited
  };
 }
+
+
+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 }[] =
+    Object.entries(qlpacks).map(([packName, dirs]) => {
+      if (dirs.length < 1) {
+        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has no directories`);
+        return { packName, packDir: undefined };
+      }
+      if (dirs.length > 1) {
+        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has more than one directory; arbitrarily choosing the first`);
+      }
+      return {
+        packName,
+        packDir: dirs[0]
+      };
+    });
+  for (const { packDir, packName } of packs) {
+    if (packDir !== undefined) {
+      const qlpack = yaml.safeLoad(await fs.readFile(path.join(packDir, 'qlpack.yml'), 'utf8'));
+      if (qlpack.dbscheme !== undefined && path.basename(qlpack.dbscheme) === path.basename(dbschemePath)) {
+        return packName;
+      }
+    }
+  }
+  throw new Error(`Could not find qlpack file for dbscheme ${dbschemePath}`);
+}
+
+export async function resolveDatasetFolder(cliServer: CodeQLCliServer, datasetFolder: string): Promise<DatasetFolderInfo> {
+  const dbschemes = await glob(path.join(datasetFolder, '*.dbscheme'));
+
+  if (dbschemes.length < 1) {
+    throw new Error(`Can't find dbscheme for current database in ${datasetFolder}`);
+  }
+
+  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 };
+}
+
+/**
+ * A cached mapping from strings to value of type U.
+ */
+export class CachedOperation<U> {
+  private readonly operation: (t: string) => 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) {
+    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> {
+    // Try and retrieve from the cache
+    const fromCache = this.cached.get(t);
+    if (fromCache !== undefined) {
+      // Move to end of lru list
+      this.lru.push(this.lru.splice(this.lru.findIndex(v => v === t), 1)[0]);
+      return fromCache;
+    }
+    // Otherwise check if in progress
+    const inProgressCallback = this.inProgressCallbacks.get(t);
+    if (inProgressCallback !== undefined) {
+      // If so wait for it to resolve
+      return await new Promise((resolve, reject) => {
+        inProgressCallback.push([resolve, reject]);
+      });
+    }
+
+    // Otherwise compute the new value, but leave a callback to allow sharing work
+    const callbacks: [(u: U) => void, (reason?: any) => void][] = [];
+    this.inProgressCallbacks.set(t, callbacks);
+    try {
+      const result = await this.operation(t);
+      callbacks.forEach(f => f[0](result));
+      this.inProgressCallbacks.delete(t);
+      if (this.lru.length > this.cacheSize) {
+        const toRemove = this.lru.shift()!;
+        this.cached.delete(toRemove);
+      }
+      this.lru.push(t);
+      this.cached.set(t, result);
+      return result;
+    } catch (e) {
+      // Rethrow error on all callbacks
+      callbacks.forEach(f => f[1](e));
+      throw e;
+    } finally {
+      this.inProgressCallbacks.delete(t);
+    }
+  }
+}
--- a/extensions/ql-vscode/src/interface-types.ts
+++ b/extensions/ql-vscode/src/interface-types.ts
@@ -1,5 +1,6 @@
 import * as sarif from 'sarif';
 import { ResolvableLocationValue } from 'semmle-bqrs';
+import { RawResultSet } from './adapt';

 /**
 * Only ever show this many results per run in interpreted results.
@@ -77,6 +78,12 @@ export interface SetStateMsg {
   * This is useful to prevent properties like scroll state being lost when rendering the sorted results after sorting a column.
   */
  shouldKeepOldResultsWhileRendering: boolean;
+
+  /**
+   * An experimental way of providing results from the extension.
+   * Should be undefined unless config.EXPERIMENTAL_BQRS_SETTING is set to true.
+   */
+  resultSets?: RawResultSet[];
 }

 /** Advance to the next or previous path no in the path viewer */
--- a/extensions/ql-vscode/src/interface.ts
+++ b/extensions/ql-vscode/src/interface.ts
@@ -16,6 +16,8 @@ import * as messages from './messages';
 import { CompletedQuery, interpretResults } from './query-results';
 import { QueryInfo, tmpDir } from './run-queries';
 import { parseSarifLocation, parseSarifPlainTextMessage } from './sarif-utils';
+import { adaptSchema, adaptBqrs, RawResultSet } from './adapt';
+import { EXPERIMENTAL_BQRS_SETTING } from './config';

 /**
 * interface.ts
@@ -136,6 +138,7 @@ export class InterfaceManager extends DisposableObject {
        this.handleSelectionChange.bind(this)
      )
    );
+    logger.log('Registering path-step navigation commands.');
    this.push(
      vscode.commands.registerCommand(
        "codeQLQueryResults.nextPathStep",
@@ -349,9 +352,7 @@ export class InterfaceManager extends DisposableObject {
      const showButton = "View Results";
      const queryName = results.queryName;
      const resultPromise = vscode.window.showInformationMessage(
-        `Finished running query ${
-          queryName.length > 0 ? ` “${queryName}”` : ""
-        }.`,
+        `Finished running query ${queryName.length > 0 ? ` "${queryName}"` : ""}.`,
        showButton
      );
      // Address this click asynchronously so we still update the
@@ -363,6 +364,19 @@ export class InterfaceManager extends DisposableObject {
      });
    }

+    let resultSets: RawResultSet[] | undefined;
+
+    if (EXPERIMENTAL_BQRS_SETTING.getValue()) {
+      resultSets = [];
+      const schemas = await this.cliServer.bqrsInfo(results.query.resultsPaths.resultsPath);
+      for (const schema of schemas["result-sets"]) {
+        const chunk = await this.cliServer.bqrsDecode(results.query.resultsPaths.resultsPath, schema.name);
+        const adaptedSchema = adaptSchema(schema);
+        const resultSet = adaptBqrs(adaptedSchema, chunk);
+        resultSets.push(resultSet);
+      }
+    }
+
    await this.postMessage({
      t: "setState",
      interpretation,
@@ -370,6 +384,7 @@ export class InterfaceManager extends DisposableObject {
      resultsPath: this.convertPathToWebviewUri(
        results.query.resultsPaths.resultsPath
      ),
+      resultSets,
      sortedResultsMap,
      database: results.database,
      shouldKeepOldResultsWhileRendering,
--- a/extensions/ql-vscode/src/logging.ts
+++ b/extensions/ql-vscode/src/logging.ts
@@ -1,4 +1,4 @@
-import { window as Window, OutputChannel, Progress, ExtensionContext, Disposable } from 'vscode';
+import { window as Window, OutputChannel, Progress, Disposable } from 'vscode';
 import { DisposableObject } from 'semmle-vscode-utils';
 import * as fs from 'fs-extra';
 import * as path from 'path';
@@ -47,8 +47,8 @@ export class OutputChannelLogger extends DisposableObject implements Logger {
    this.push(this.outputChannel);
  }

-  init(ctx: ExtensionContext): void {
-    this.additionalLogLocationPath = path.join(ctx.storagePath || ctx.globalStoragePath, this.title);
+  init(storagePath: string): void {
+    this.additionalLogLocationPath = path.join(storagePath, this.title);

    // clear out any old state from previous runs
    fs.remove(this.additionalLogLocationPath);
@@ -60,7 +60,7 @@ export class OutputChannelLogger extends DisposableObject implements Logger {
   * function if you don't need to guarantee that the log writing is complete before
   * continuing.
   */
-  async log(message: string, options = { } as LogOptions): Promise<void> {
+  async log(message: string, options = {} as LogOptions): Promise<void> {
    if (options.trailingNewline === undefined) {
      options.trailingNewline = true;
    }
@@ -116,7 +116,7 @@ class AdditionalLogLocation extends Disposable {
    super(() => { /**/ });
  }

-  async log(message: string, options = { } as LogOptions): Promise<void> {
+  async log(message: string, options = {} as LogOptions): Promise<void> {
    if (options.trailingNewline === undefined) {
      options.trailingNewline = true;
    }
--- a/extensions/ql-vscode/src/qltest-discovery.ts
+++ b/extensions/ql-vscode/src/qltest-discovery.ts
@@ -64,7 +64,7 @@ export class QLTestDirectory extends QLTestNode {
  private createChildDirectory(name: string): QLTestDirectory {
    const existingChild = this._children.find((child) => child.name === name);
    if (existingChild !== undefined) {
-      return <QLTestDirectory>existingChild;
+      return existingChild as QLTestDirectory;
    }
    else {
      const newChild = new QLTestDirectory(path.join(this.path, name), name);
@@ -87,6 +87,7 @@ export class QLTestFile extends QLTestNode {
  }

  public finish(): void {
+    /**/
  }
 }

--- a/extensions/ql-vscode/src/query-history.ts
+++ b/extensions/ql-vscode/src/query-history.ts
@@ -6,6 +6,7 @@ import { QueryHistoryConfig } from './config';
 import { QueryWithResults } from './run-queries';
 import * as helpers from './helpers';
 import { logger } from './logging';
+import { URLSearchParams } from 'url';

 /**
 * query-history.ts
@@ -18,9 +19,32 @@ import { logger } from './logging';

 export type QueryHistoryItemOptions = {
  label?: string; // user-settable label
-  queryText?: string; // stored query for quick query
+  queryText?: string; // text of the selected file
+  isQuickQuery?: boolean;
 }

+const SHOW_QUERY_TEXT_MSG = `\
+////////////////////////////////////////////////////////////////////////////////////
+// This is the text of the entire query file when it was executed for this query  //
+// run. The text or dependent libraries may have changed since then.              //
+//                                                                                //
+// This buffer is readonly. To re-execute this query, you must open the original  //
+// query file.                                                                    //
+////////////////////////////////////////////////////////////////////////////////////
+
+`;
+
+const SHOW_QUERY_TEXT_QUICK_EVAL_MSG = `\
+////////////////////////////////////////////////////////////////////////////////////
+// This is the Quick Eval selection of the query file when it was executed for    //
+// this query run. The text or dependent libraries may have changed since then.   //
+//                                                                                //
+// This buffer is readonly. To re-execute this query, you must open the original  //
+// query file.                                                                    //
+////////////////////////////////////////////////////////////////////////////////////
+
+`;
+
 /**
 * Path to icon to display next to a failed query history item.
 */
@@ -137,7 +161,7 @@ export class QueryHistoryManager {
    const textDocument = await vscode.workspace.openTextDocument(vscode.Uri.file(queryHistoryItem.query.program.queryPath));
    const editor = await vscode.window.showTextDocument(textDocument, vscode.ViewColumn.One);
    const queryText = queryHistoryItem.options.queryText;
-    if (queryText !== undefined) {
+    if (queryText !== undefined && queryHistoryItem.options.isQuickQuery) {
      await editor.edit(edit => edit.replace(textDocument.validateRange(
        new vscode.Range(0, 0, textDocument.lineCount, 0)), queryText)
      );
@@ -192,13 +216,13 @@ export class QueryHistoryManager {

  async handleShowQueryLog(queryHistoryItem: CompletedQuery) {
    if (queryHistoryItem.logFileLocation) {
-      const uri = vscode.Uri.parse(queryHistoryItem.logFileLocation);
+      const uri = vscode.Uri.file(queryHistoryItem.logFileLocation);
      try {
        await vscode.window.showTextDocument(uri, {
        });
      } catch (e) {
        if (e.message.includes('Files above 50MB cannot be synchronized with extensions')) {
-          const res = await helpers.showBinaryChoiceDialog('File is too large to open in the editor, do you want to open exterally?');
+          const res = await helpers.showBinaryChoiceDialog('File is too large to open in the editor, do you want to open it externally?');
          if (res) {
            try {
              await vscode.commands.executeCommand('revealFileInOS', uri);
@@ -218,6 +242,36 @@ export class QueryHistoryManager {
    }
  }

+  async handleShowQueryText(queryHistoryItem: CompletedQuery) {
+    try {
+      const queryName = queryHistoryItem.queryName.endsWith('.ql') ? queryHistoryItem.queryName : queryHistoryItem.queryName + '.ql';
+      const params = new URLSearchParams({
+        isQuickEval: String(!!queryHistoryItem.query.quickEvalPosition),
+        queryText: await this.getQueryText(queryHistoryItem)
+      });
+      const uri = vscode.Uri.parse(`codeql:${queryHistoryItem.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);
+    }
+  }
+
+  async getQueryText(queryHistoryItem: CompletedQuery): Promise<string> {
+    if (queryHistoryItem.options.queryText) {
+      return queryHistoryItem.options.queryText;
+    } else if (queryHistoryItem.query.quickEvalPosition) {
+      // capture all selected lines
+      const startLine = queryHistoryItem.query.quickEvalPosition.line;
+      const endLine = queryHistoryItem.query.quickEvalPosition.endLine;
+      const textDocument =
+        await vscode.workspace.openTextDocument(queryHistoryItem.query.quickEvalPosition.fileName);
+      return textDocument.getText(new vscode.Range(startLine - 1, 0, endLine, 0));
+    } else {
+      return '';
+    }
+  }
+
  constructor(
    ctx: ExtensionContext,
    private queryHistoryConfigListener: QueryHistoryConfig,
@@ -236,16 +290,29 @@ export class QueryHistoryManager {
        this.updateTreeViewSelectionIfVisible();
      }
    });
+    logger.log('Registering query history panel commands.');
    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.openQuery', this.handleOpenQuery));
    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.removeHistoryItem', this.handleRemoveHistoryItem.bind(this)));
    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.setLabel', this.handleSetLabel.bind(this)));
    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.showQueryLog', this.handleShowQueryLog.bind(this)));
+    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.showQueryText', this.handleShowQueryText.bind(this)));
    ctx.subscriptions.push(vscode.commands.registerCommand('codeQLQueryHistory.itemClicked', async (item) => {
      return this.handleItemClicked(item);
    }));
    queryHistoryConfigListener.onDidChangeQueryHistoryConfiguration(() => {
      this.treeDataProvider.refresh();
    });
+
+    // displays query text in a read-only document
+    vscode.workspace.registerTextDocumentContentProvider('codeql', {
+      provideTextDocumentContent(uri: vscode.Uri): vscode.ProviderResult<string> {
+        const params = new URLSearchParams(uri.query);
+
+        return (
+          JSON.parse(params.get('isQuickEval') || '') ? SHOW_QUERY_TEXT_QUICK_EVAL_MSG : SHOW_QUERY_TEXT_MSG
+        ) + params.get('queryText');
+      }
+    });
  }

  addQuery(info: QueryWithResults): CompletedQuery {
--- a/extensions/ql-vscode/src/query-results.ts
+++ b/extensions/ql-vscode/src/query-results.ts
@@ -14,7 +14,7 @@ export class CompletedQuery implements QueryWithResults {
  readonly query: QueryInfo;
  readonly result: messages.EvaluationResult;
  readonly database: DatabaseInfo;
-  readonly logFileLocation?: string
+  readonly logFileLocation?: string;
  options: QueryHistoryItemOptions;
  dispose: () => void;

@@ -131,7 +131,7 @@ export class CompletedQuery implements QueryWithResults {
 * Call cli command to interpret results.
 */
 export async function interpretResults(server: cli.CodeQLCliServer, metadata: QueryMetadata | undefined, resultsPath: string, sourceInfo?: cli.SourceInfo): Promise<sarif.Log> {
-  const interpretedResultsPath = resultsPath + ".interpreted.sarif"
+  const interpretedResultsPath = resultsPath + ".interpreted.sarif";

  if (await fs.pathExists(interpretedResultsPath)) {
    return JSON.parse(await fs.readFile(interpretedResultsPath, 'utf8'));
--- a/extensions/ql-vscode/src/queryserver-client.ts
+++ b/extensions/ql-vscode/src/queryserver-client.ts
@@ -82,7 +82,7 @@ export class QueryServerClient extends DisposableObject {
    if (this.serverProcess !== undefined) {
      this.disposeAndStopTracking(this.serverProcess);
    } else {
-      this.logger.log('No server process to be stopped.')
+      this.logger.log('No server process to be stopped.');
    }
  }

@@ -136,13 +136,13 @@ export class QueryServerClient extends DisposableObject {
        this.evaluationResultCallbacks[res.runId](res);
      }
      return {};
-    })
+    });
    connection.onNotification(progress, res => {
      const callback = this.progressCallbacks[res.id];
      if (callback) {
        callback(res);
      }
-    })
+    });
    this.serverProcess = new ServerProcess(child, connection, this.opts.logger);
    // Ensure the server process is disposed together with this client.
    this.track(this.serverProcess);
--- a/extensions/ql-vscode/src/quick-query.ts
+++ b/extensions/ql-vscode/src/quick-query.ts
@@ -1,5 +1,4 @@
 import * as fs from 'fs-extra';
-import * as glob from 'glob-promise';
 import * as yaml from 'js-yaml';
 import * as path from 'path';
 import { ExtensionContext, window as Window, workspace, Uri } from 'vscode';
@@ -18,33 +17,6 @@ export function isQuickQueryPath(queryPath: string): boolean {
  return path.basename(queryPath) === QUICK_QUERY_QUERY_NAME;
 }

-async function getQlPackFor(cliServer: CodeQLCliServer, dbschemePath: string): Promise<string> {
-  const qlpacks = await cliServer.resolveQlpacks(helpers.getOnDiskWorkspaceFolders());
-  const packs: { packDir: string | undefined; packName: string }[] =
-    Object.entries(qlpacks).map(([packName, dirs]) => {
-      if (dirs.length < 1) {
-        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has no directories`);
-        return { packName, packDir: undefined };
-      }
-      if (dirs.length > 1) {
-        logger.log(`In getQlPackFor ${dbschemePath}, qlpack ${packName} has more than one directory; arbitrarily choosing the first`);
-      }
-      return {
-        packName,
-        packDir: dirs[0]
-      }
-    });
-  for (const { packDir, packName } of packs) {
-    if (packDir !== undefined) {
-      const qlpack = yaml.safeLoad(await fs.readFile(path.join(packDir, 'qlpack.yml'), 'utf8'));
-      if (qlpack.dbscheme !== undefined && path.basename(qlpack.dbscheme) === path.basename(dbschemePath)) {
-        return packName;
-      }
-    }
-  }
-  throw new Error(`Could not find qlpack file for dbscheme ${dbschemePath}`);
-}
-
 /**
 * `getBaseText` heuristically returns an appropriate import statement
 * prelude based on the filename of the dbscheme file given. TODO: add
@@ -70,23 +42,26 @@ function getQuickQueriesDir(ctx: ExtensionContext): string {
  return queriesPath;
 }

+
+
+
 /**
 * Show a buffer the user can enter a simple query into.
 */
 export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQLCliServer, databaseUI: DatabaseUI) {
-  try {

+  function updateQuickQueryDir(queriesDir: string, index: number, len: number) {
+    workspace.updateWorkspaceFolders(
+      index,
+      len,
+      { uri: Uri.file(queriesDir), name: QUICK_QUERY_WORKSPACE_FOLDER_NAME }
+    );
+  }
+
+  try {
    const workspaceFolders = workspace.workspaceFolders || [];
    const queriesDir = await getQuickQueriesDir(ctx);

-    function updateQuickQueryDir(index: number, len: number) {
-      workspace.updateWorkspaceFolders(
-        index,
-        len,
-        { uri: Uri.file(queriesDir), name: QUICK_QUERY_WORKSPACE_FOLDER_NAME }
-      );
-    }
-
    // 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);
@@ -107,16 +82,16 @@ export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQL
    if (workspace.workspaceFile === undefined) {
      const makeMultiRoot = await helpers.showBinaryChoiceDialog('Quick query requires multiple folders in the workspace. Reload workspace as multi-folder workspace?');
      if (makeMultiRoot) {
-        updateQuickQueryDir(workspaceFolders.length, 0);
+        updateQuickQueryDir(queriesDir, workspaceFolders.length, 0);
      }
      return;
    }

-    const index = workspaceFolders.findIndex(folder => folder.name === QUICK_QUERY_WORKSPACE_FOLDER_NAME)
+    const index = workspaceFolders.findIndex(folder => folder.name === QUICK_QUERY_WORKSPACE_FOLDER_NAME);
    if (index === -1)
-      updateQuickQueryDir(workspaceFolders.length, 0);
+      updateQuickQueryDir(queriesDir, workspaceFolders.length, 0);
    else
-      updateQuickQueryDir(index, 1);
+      updateQuickQueryDir(queriesDir, index, 1);

    // We're going to infer which qlpack to use from the current database
    const dbItem = await databaseUI.getDatabaseItem();
@@ -125,19 +100,7 @@ export async function displayQuickQuery(ctx: ExtensionContext, cliServer: CodeQL
    }

    const datasetFolder = await dbItem.getDatasetFolder(cliServer);
-    const dbschemes = await glob(path.join(datasetFolder, '*.dbscheme'))
-
-    if (dbschemes.length < 1) {
-      throw new Error(`Can't find dbscheme for current database in ${datasetFolder}`);
-    }
-
-    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 getQlPackFor(cliServer, dbscheme);
+    const { qlpack, dbscheme } = await helpers.resolveDatasetFolder(cliServer, datasetFolder);
    const quickQueryQlpackYaml: any = {
      name: "quick-query",
      version: "1.0.0",
--- a/extensions/ql-vscode/src/run-queries.ts
+++ b/extensions/ql-vscode/src/run-queries.ts
@@ -7,6 +7,7 @@ import * as vscode 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';
@@ -75,7 +76,7 @@ export class QueryInfo {
  ): Promise<messages.EvaluationResult> {
    let result: messages.EvaluationResult | null = null;

-    const callbackId = qs.registerCallback(res => { result = res });
+    const callbackId = qs.registerCallback(res => { result = res; });

    const queryToRun: messages.QueryToRun = {
      resultsPath: this.resultsPaths.resultsPath,
@@ -84,25 +85,25 @@ export class QueryInfo {
      templateValues: this.templates,
      id: callbackId,
      timeoutSecs: qs.config.timeoutSecs,
-    }
+    };
    const dataset: messages.Dataset = {
      dbDir: this.dataset.fsPath,
      workingSet: 'default'
-    }
+    };
    const params: messages.EvaluateQueriesParams = {
      db: dataset,
      evaluateId: callbackId,
      queries: [queryToRun],
      stopOnError: false,
      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)
+        return qs.sendRequest(messages.runQueries, params, token, progress);
      });
    } finally {
      qs.unRegisterCallback(callbackId);
@@ -121,6 +122,9 @@ export class QueryInfo {
  ): Promise<messages.CompilationMessage[]> {
    let compiled: messages.CheckQueryResult | undefined;
    try {
+      const target = this.quickEvalPosition ? {
+        quickEval: { quickEvalPos: this.quickEvalPosition }
+      } : { query: {} };
      const params: messages.CompileQueryParams = {
        compilationOptions: {
          computeNoLocationUrls: true,
@@ -136,11 +140,7 @@ export class QueryInfo {
        },
        queryToCheck: this.program,
        resultPath: this.compiledQueryPath,
-        target: this.quickEvalPosition ? {
-          quickEval: { quickEvalPos: this.quickEvalPosition }
-        } : {
-          query: {}
-        }
+        target,
      };

      compiled = await helpers.withProgress({
@@ -239,8 +239,10 @@ async function getSelectedPosition(editor: vscode.TextEditor): Promise<messages.
  // Convert from 0-based to 1-based line and column numbers.
  return {
    fileName: await convertToQlPath(editor.document.fileName),
-    line: pos.line + 1, column: pos.character + 1,
-    endLine: posEnd.line + 1, endColumn: posEnd.character + 1
+    line: pos.line + 1,
+    column: pos.character + 1,
+    endLine: posEnd.line + 1,
+    endColumn: posEnd.character + 1
  };
 }

@@ -259,9 +261,9 @@ async function checkDbschemeCompatibility(

  if (query.dbItem.contents !== undefined && query.dbItem.contents.dbSchemeUri !== undefined) {
    const { scripts, finalDbscheme } = await cliServer.resolveUpgrades(query.dbItem.contents.dbSchemeUri.fsPath, searchPath);
-    const hash = async function (filename: string): Promise<string> {
+    const hash = async function(filename: string): Promise<string> {
      return crypto.createHash('sha256').update(await fs.readFile(filename)).digest('hex');
-    }
+    };

    // At this point, we have learned about three dbschemes:

@@ -294,19 +296,39 @@ async function checkDbschemeCompatibility(
  }
 }

-/** Prompts the user to save `document` if it has unsaved changes. */
-async function promptUserToSaveChanges(document: vscode.TextDocument): Promise<void> {
+/**
+ * Prompts the user to save `document` if it has unsaved changes.
+ * Returns true if we should save changes.
+ */
+async function promptUserToSaveChanges(document: vscode.TextDocument): Promise<boolean> {
  if (document.isDirty) {
-    // TODO: add 'always save' button which records preference in configuration
-    if (await helpers.showBinaryChoiceDialog('Query file has unsaved changes. Save now?')) {
-      await document.save();
+    if (config.AUTOSAVE_SETTING.getValue()) {
+      return true;
+    }
+    else {
+      const yesItem = { title: 'Yes', isCloseAffordance: false };
+      const alwaysItem = { title: 'Always Save', isCloseAffordance: false };
+      const noItem = { title: 'No', isCloseAffordance: true };
+      const message = 'Query file has unsaved changes. Save now?';
+      const chosenItem = await vscode.window.showInformationMessage(message, { modal: true }, yesItem, alwaysItem, noItem);
+
+      if (chosenItem === alwaysItem) {
+        await config.AUTOSAVE_SETTING.updateValue(true, vscode.ConfigurationTarget.Workspace);
+        return true;
+      }
+
+      if (chosenItem === yesItem) {
+        return true;
+      }
    }
  }
+  return false;
 }

 type SelectedQuery = {
  queryPath: string;
  quickEvalPosition?: messages.Position;
+  quickEvalText?: string;
 };

 /**
@@ -357,10 +379,13 @@ export async function determineSelectedQuery(selectedResourceUri: vscode.Uri | u
  // if the same file is open with unsaved changes in the active editor,
  // then prompt the user to save it first.
  if (editor !== undefined && editor.document.uri.fsPath === queryPath) {
-    await promptUserToSaveChanges(editor.document);
+    if (await promptUserToSaveChanges(editor.document)) {
+      editor.document.save();
+    }
  }

  let quickEvalPosition: messages.Position | undefined = undefined;
+  let quickEvalText: string | undefined = undefined;
  if (quickEval) {
    if (editor == undefined) {
      throw new Error('Can\'t run quick evaluation without an active editor.');
@@ -371,9 +396,10 @@ export async function determineSelectedQuery(selectedResourceUri: vscode.Uri | u
      throw new Error('The selected resource for quick evaluation should match the active editor.');
    }
    quickEvalPosition = await getSelectedPosition(editor);
+    quickEvalText = editor.document.getText(editor.selection);
  }

-  return { queryPath, quickEvalPosition };
+  return { queryPath, quickEvalPosition, quickEvalText };
 }

 export async function compileAndRunQueryAgainstDatabase(
@@ -390,12 +416,14 @@ export async function compileAndRunQueryAgainstDatabase(
  }

  // Determine which query to run, based on the selection and the active editor.
-  const { queryPath, quickEvalPosition } = await determineSelectedQuery(selectedQueryUri, quickEval);
+  const { queryPath, quickEvalPosition, quickEvalText } = await determineSelectedQuery(selectedQueryUri, quickEval);

  // If this is quick query, store the query text
  const historyItemOptions: QueryHistoryItemOptions = {};
-  if (isQuickQueryPath(queryPath)) {
-    historyItemOptions.queryText = await fs.readFile(queryPath, 'utf8');
+  historyItemOptions.queryText = await fs.readFile(queryPath, 'utf8');
+  historyItemOptions.isQuickQuery === isQuickQueryPath(queryPath);
+  if (quickEval) {
+    historyItemOptions.queryText = quickEvalText;
  }

  // Get the workspace folder paths.
--- a/extensions/ql-vscode/src/sarif-utils.ts
+++ b/extensions/ql-vscode/src/sarif-utils.ts
@@ -1,5 +1,5 @@
-import * as Sarif from "sarif"
-import * as path from "path"
+import * as Sarif from "sarif";
+import * as path from "path";
 import { LocationStyle, ResolvableLocationValue } from "semmle-bqrs";

 export interface SarifLink {
--- a/extensions/ql-vscode/src/test-adapter.ts
+++ b/extensions/ql-vscode/src/test-adapter.ts
@@ -87,8 +87,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
  private readonly _tests = this.push(
    new EventEmitter<TestLoadStartedEvent | TestLoadFinishedEvent>());
  private readonly _testStates = this.push(
-    new EventEmitter<TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent |
-    TestEvent>());
+    new EventEmitter<TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent | TestEvent>());
  private readonly _autorun = this.push(new EventEmitter<void>());
  private runningTask?: vscode.CancellationTokenSource = undefined;

@@ -108,9 +107,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
    return this._tests.event;
  }

-  public get testStates(): Event<TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent |
-  TestEvent> {
-
+  public get testStates(): Event<TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent | TestEvent> {
    return this._testStates.event;
  }

@@ -118,9 +115,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
    return this._autorun.event;
  }

-  private static createTestOrSuiteInfos(testNodes: readonly QLTestNode[]):
-  (TestSuiteInfo | TestInfo)[] {
-
+  private static createTestOrSuiteInfos(testNodes: readonly QLTestNode[]): (TestSuiteInfo | TestInfo)[] {
    return testNodes.map((childNode) => {
      return QLTestAdapter.createTestOrSuiteInfo(childNode);
    });
@@ -129,11 +124,9 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
  private static createTestOrSuiteInfo(testNode: QLTestNode): TestSuiteInfo | TestInfo {
    if (testNode instanceof QLTestFile) {
      return QLTestAdapter.createTestInfo(testNode);
-    }
-    else if (testNode instanceof QLTestDirectory) {
+    } else if (testNode instanceof QLTestDirectory) {
      return QLTestAdapter.createTestSuiteInfo(testNode, testNode.name);
-    }
-    else {
+    } else {
      throw new Error('Unexpected test type.');
    }
  }
@@ -148,9 +141,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
    };
  }

-  private static createTestSuiteInfo(testDirectory: QLTestDirectory, label: string):
-  TestSuiteInfo {
-
+  private static createTestSuiteInfo(testDirectory: QLTestDirectory, label: string): TestSuiteInfo {
    return {
      type: 'suite',
      id: testDirectory.path,
@@ -165,7 +156,7 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
  }

  private discoverTests(): void {
-    this._tests.fire(<TestLoadStartedEvent>{ type: 'started' });
+    this._tests.fire({ type: 'started' } as TestLoadStartedEvent);

    const testDirectories = this.qlTestDiscovery.testDirectories;
    const children = testDirectories.map(
@@ -178,10 +169,10 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {
      children
    };

-    this._tests.fire(<TestLoadFinishedEvent>{
+    this._tests.fire({
      type: 'finished',
      suite: children.length > 0 ? testSuite : undefined
-    });
+    } as TestLoadFinishedEvent);
  }

  public async run(tests: string[]): Promise<void> {
@@ -194,17 +185,16 @@ export class QLTestAdapter extends DisposableObject implements TestAdapter {

    this.runningTask = this.track(new CancellationTokenSource());

-    this._testStates.fire(<TestRunStartedEvent>{ type: 'started', tests: tests });
-
-    const testAdapter = this;
+    this._testStates.fire({ type: 'started', tests: tests } as TestRunStartedEvent);

    try {
      await this.runTests(tests, this.runningTask.token);
    }
    catch (e) {
+      /**/
    }
-    testAdapter._testStates.fire(<TestRunFinishedEvent>{ type: 'finished' });
-    testAdapter.clearTask();
+    this._testStates.fire({ type: 'finished' } as TestRunFinishedEvent);
+    this.clearTask();
  }

  private clearTask(): void {
--- a/extensions/ql-vscode/src/test-ui.ts
+++ b/extensions/ql-vscode/src/test-ui.ts
@@ -5,6 +5,9 @@ import { TestTreeNode } from './test-tree-node';
 import { DisposableObject, UIService } from 'semmle-vscode-utils';
 import { TestHub, TestController, TestAdapter, TestRunStartedEvent, TestRunFinishedEvent, TestEvent, TestSuiteEvent } from 'vscode-test-adapter-api';
 import { QLTestAdapter, getExpectedFile, getActualFile } from './test-adapter';
+import { logger } from './logging';
+
+type VSCodeTestEvent = TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent | TestEvent;

 /**
 * Test event listener. Currently unused, but left in to keep the plumbing hooked up for future use.
@@ -16,7 +19,8 @@ class QLTestListener extends DisposableObject {
    this.push(adapter.testStates(this.onTestStatesEvent, this));
  }

-  private onTestStatesEvent(_e: TestRunStartedEvent | TestRunFinishedEvent | TestSuiteEvent | TestEvent): void {
+  private onTestStatesEvent(_e: VSCodeTestEvent): void {
+    /**/
  }
 }

@@ -29,6 +33,7 @@ export class TestUIService extends UIService implements TestController {
  constructor(private readonly testHub: TestHub) {
    super();

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

--- a/extensions/ql-vscode/src/upgrades.ts
+++ b/extensions/ql-vscode/src/upgrades.ts
@@ -80,7 +80,7 @@ async function checkAndConfirmDatabaseUpgrade(

  const showLogItem: vscode.MessageItem = { title: 'No, Show Changes', isCloseAffordance: true };
  const yesItem = { title: 'Yes', isCloseAffordance: false };
-  const noItem = { title: 'No', isCloseAffordance: true }
+  const noItem = { title: 'No', isCloseAffordance: true };
  const dialogOptions: vscode.MessageItem[] = [yesItem, noItem];

  let messageLines = descriptionMessage.split('\n');
@@ -129,7 +129,7 @@ export async function upgradeDatabase(
    return;
  }
  finally {
-    qs.logger.log('Done compiling database upgrade.')
+    qs.logger.log('Done compiling database upgrade.');
  }

  if (compileUpgradeResult.compiledUpgrades === undefined) {
@@ -148,7 +148,7 @@ export async function upgradeDatabase(
    return;
  }
  finally {
-    qs.logger.log('Done running database upgrade.')
+    qs.logger.log('Done running database upgrade.');
  }
 }

@@ -168,7 +168,7 @@ async function compileDatabaseUpgrade(
  const params: messages.CompileUpgradeParams = {
    upgrade: upgradeParams,
    upgradeTempDir: upgradesTmpDir.name
-  }
+  };

  return helpers.withProgress({
    location: vscode.ProgressLocation.Notification,
--- a/extensions/ql-vscode/src/view/.eslintrc.js
+++ b/extensions/ql-vscode/src/view/.eslintrc.js
@@ -1,8 +1,13 @@
 module.exports = {
-  ecmaFeatures: {
-    jsx: true,
-  },
  env: {
    browser: true
+  },
+  extends: [
+    "plugin:react/recommended"
+  ],
+  settings: {
+    react: {
+      version: 'detect'
+    }
  }
 }
--- a/extensions/ql-vscode/src/view/alert-table.tsx
+++ b/extensions/ql-vscode/src/view/alert-table.tsx
@@ -69,6 +69,14 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
    });
  }

+  renderNoResults(): JSX.Element {
+    if (this.props.nonemptyRawResults) {
+      return <span>No Alerts. See <a href='#' onClick={this.props.showRawResults}>raw results</a>.</span>;
+    } else {
+      return <span>No Alerts</span>;
+    }
+  }
+
  render(): JSX.Element {
    const { databaseUri, resultSet } = this.props;

@@ -116,7 +124,7 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
          ...previousState,
          selectedPathNode: pathNodeKey
        }));
-      }
+      };
    };

    function renderSarifLocationWithText(text: string | undefined, loc: Sarif.Location, pathNodeKey: Keys.PathNode | undefined): JSX.Element | undefined {
@@ -156,18 +164,19 @@ export class PathTable extends React.Component<PathTableProps, PathTableState> {
      return (e) => this.toggle(e, indices);
    };

-    const noResults = <span>No Results</span>; // TODO: Maybe make this look nicer
+    if (resultSet.sarif.runs.length === 0 ||
+      resultSet.sarif.runs[0].results === undefined ||
+      resultSet.sarif.runs[0].results.length === 0) {
+      return this.renderNoResults();
+    }

    let expansionIndex = 0;

-    if (resultSet.sarif.runs.length === 0) return noResults;
-    if (resultSet.sarif.runs[0].results === undefined) return noResults;
-
    resultSet.sarif.runs[0].results.forEach((result, resultIndex) => {
      const text = result.message.text || '[no text]';
      const msg: JSX.Element[] =
        result.relatedLocations === undefined ?
-          [<span>{text}</span>] :
+          [<span key="0">{text}</span>] :
          renderRelatedLocations(text, result.relatedLocations);

      const currentResultExpanded = this.state.expanded[expansionIndex];
--- a/extensions/ql-vscode/src/view/raw-results-table.tsx
+++ b/extensions/ql-vscode/src/view/raw-results-table.tsx
@@ -1,6 +1,7 @@
 import * as React from "react";
 import { renderLocation, ResultTableProps, zebraStripe, className, nextSortDirection } from "./result-table-utils";
-import { RawTableResultSet, ResultValue, vscode } from "./results";
+import { RawTableResultSet, vscode } from "./results";
+import { ResultValue } from "../adapt";
 import { SortDirection, RAW_RESULTS_LIMIT, RawResultsSortState } from "../interface-types";

 export type RawTableProps = ResultTableProps & {
@@ -88,7 +89,7 @@ export class RawTable extends React.Component<RawTableProps, {}> {
 */
 function renderTupleValue(v: ResultValue, databaseUri: string): JSX.Element {
  if (typeof v === 'string') {
-    return <span>{v}</span>
+    return <span>{v}</span>;
  }
  else if ('uri' in v) {
    return <a href={v.uri}>{v.uri}</a>;
--- a/extensions/ql-vscode/src/view/result-table-utils.tsx
+++ b/extensions/ql-vscode/src/view/result-table-utils.tsx
@@ -10,6 +10,18 @@ export interface ResultTableProps {
  metadata?: QueryMetadata;
  resultsPath: string | undefined;
  sortState?: RawResultsSortState;
+
+  /**
+   * Holds if there are any raw results. When that is the case, we
+   * want to direct users to pay attention to raw results if
+   * interpreted results are empty.
+   */
+  nonemptyRawResults: boolean;
+
+  /**
+   * Callback to show raw results.
+   */
+  showRawResults: () => void;
 }

 export const className = 'vscode-codeql__result-table';
@@ -66,7 +78,7 @@ export function renderLocation(loc: LocationValue | undefined, label: string | u
      return <span title={title}>{displayLabel}</span>;
    }
  }
-  return <span />
+  return <span />;
 }

 /**
@@ -83,7 +95,7 @@ export function zebraStripe(index: number, ...otherClasses: string[]): { classNa
 export function selectableZebraStripe(isSelected: boolean, index: number, ...otherClasses: string[]): { className: string } {
  return isSelected
    ? { className: [selectedRowClassName, ...otherClasses].join(' ') }
-    : zebraStripe(index, ...otherClasses)
+    : zebraStripe(index, ...otherClasses);
 }

 /**
--- a/extensions/ql-vscode/src/view/result-tables.tsx
+++ b/extensions/ql-vscode/src/view/result-tables.tsx
@@ -85,7 +85,7 @@ export class ResultTables
  }

  private static getDefaultResultSet(resultSets: readonly ResultSet[]): string {
-    const resultSetNames = resultSets.map(resultSet => resultSet.schema.name)
+    const resultSetNames = resultSets.map(resultSet => resultSet.schema.name);
    // Choose first available result set from the array
    return [ALERTS_TABLE_NAME, SELECT_TABLE_NAME, resultSets[0].schema.name].filter(resultSetName => resultSetNames.includes(resultSetName))[0];
  }
@@ -115,7 +115,7 @@ export class ResultTables

    return <div className={alertExtrasClassName}>
      {displayProblemsAsAlertsToggle}
-    </div>
+    </div>;
  }

  render(): React.ReactNode {
@@ -123,6 +123,7 @@ export class ResultTables
    const resultSets = this.getResultSets();

    const resultSet = resultSets.find(resultSet => resultSet.schema.name == selectedTable);
+    const nonemptyRawResults = resultSets.some(resultSet => resultSet.t == 'RawResultSet' && resultSet.rows.length > 0);
    const numberOfResults = resultSet && renderResultCountString(resultSet);

    return <div>
@@ -149,7 +150,9 @@ export class ResultTables
        <ResultTable key={resultSet.schema.name} resultSet={resultSet}
          databaseUri={this.props.database.databaseUri}
          resultsPath={this.props.resultsPath}
-          sortState={this.props.sortStates.get(resultSet.schema.name)} />
+          sortState={this.props.sortStates.get(resultSet.schema.name)}
+          nonemptyRawResults={nonemptyRawResults}
+          showRawResults={() => { this.setState({ selectedTable: SELECT_TABLE_NAME }); }} />
      }
    </div>;
  }
--- a/extensions/ql-vscode/src/view/results.tsx
+++ b/extensions/ql-vscode/src/view/results.tsx
@@ -1,11 +1,12 @@
 import * as React from 'react';
 import * as Rdom from 'react-dom';
 import * as bqrs from 'semmle-bqrs';
-import { ElementBase, LocationValue, PrimitiveColumnValue, PrimitiveTypeKind, ResultSetSchema, tryGetResolvableLocation } from 'semmle-bqrs';
+import { ElementBase, PrimitiveColumnValue, PrimitiveTypeKind, ResultSetSchema, tryGetResolvableLocation } from 'semmle-bqrs';
 import { assertNever } from '../helpers-pure';
 import { DatabaseInfo, FromResultsViewMsg, Interpretation, IntoResultsViewMsg, SortedResultSetInfo, RawResultsSortState, NavigatePathMsg, QueryMetadata, ResultsPaths } from '../interface-types';
 import { EventHandlers as EventHandlerList } from './event-handler-list';
 import { ResultTables } from './result-tables';
+import { RawResultSet, ResultValue, ResultRow } from '../adapt';

 /**
 * results.tsx
@@ -23,19 +24,6 @@ interface VsCodeApi {
 declare const acquireVsCodeApi: () => VsCodeApi;
 export const vscode = acquireVsCodeApi();

-export interface ResultElement {
-  label: string;
-  location?: LocationValue;
-}
-
-export interface ResultUri {
-  uri: string;
-}
-
-export type ResultValue = ResultElement | ResultUri | string;
-
-export type ResultRow = ResultValue[];
-
 export type RawTableResultSet = { t: 'RawResultSet' } & RawResultSet;
 export type PathTableResultSet = { t: 'SarifResultSet'; readonly schema: ResultSetSchema; name: string } & Interpretation;

@@ -43,11 +31,6 @@ export type ResultSet =
  | RawTableResultSet
  | PathTableResultSet;

-export interface RawResultSet {
-  readonly schema: ResultSetSchema;
-  readonly rows: readonly ResultRow[];
-}
-
 async function* getChunkIterator(response: Response): AsyncIterableIterator<Uint8Array> {
  if (!response.ok) {
    throw new Error(`Failed to load results: (${response.status}) ${response.statusText}`);
@@ -62,9 +45,7 @@ async function* getChunkIterator(response: Response): AsyncIterableIterator<Uint
  }
 }

-function translatePrimitiveValue(value: PrimitiveColumnValue, type: PrimitiveTypeKind):
-ResultValue {
-
+function translatePrimitiveValue(value: PrimitiveColumnValue, type: PrimitiveTypeKind): ResultValue {
  switch (type) {
    case 'i':
    case 'f':
@@ -127,6 +108,7 @@ async function parseResultSets(response: Response): Promise<readonly ResultSet[]

 interface ResultsInfo {
  resultsPath: string;
+  resultSets: ResultSet[] | undefined;
  origResultsPaths: ResultsPaths;
  database: DatabaseInfo;
  interpretation: Interpretation | undefined;
@@ -187,6 +169,7 @@ class App extends React.Component<{}, ResultsViewState> {
      case 'setState':
        this.updateStateWithNewResultsInfo({
          resultsPath: msg.resultsPath,
+          resultSets: msg.resultSets?.map(x => ({ t: 'RawResultSet', ...x })),
          origResultsPaths: msg.origResultsPaths,
          sortedResultsMap: new Map(Object.entries(msg.sortedResultsMap)),
          database: msg.database,
@@ -247,8 +230,9 @@ class App extends React.Component<{}, ResultsViewState> {
    let results: Results | null = null;
    let statusText = '';
    try {
+      const resultSets = resultsInfo.resultSets || await this.getResultSets(resultsInfo);
      results = {
-        resultSets: await this.getResultSets(resultsInfo),
+        resultSets,
        database: resultsInfo.database,
        sortStates: this.getSortStates(resultsInfo)
      };
@@ -277,7 +261,7 @@ class App extends React.Component<{}, ResultsViewState> {
        },
        nextResultsInfo: null,
        isExpectingResultsUpdate: false
-      }
+      };
    });
  }

@@ -341,4 +325,4 @@ Rdom.render(
  document.getElementById('root')
 );

-vscode.postMessage({ t: "resultViewLoaded" })
+vscode.postMessage({ t: "resultViewLoaded" });
--- a/extensions/ql-vscode/src/view/resultsView.css
+++ b/extensions/ql-vscode/src/view/resultsView.css
@@ -75,7 +75,7 @@
 }

 .vscode-codeql__result-table-location-link {
-  font-family: SFMono-Regular, Consolas, "Liberation Mono", Menlo, Courier, monospace;
+  text-decoration: none;
 }

 select {
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/distribution.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/distribution.test.ts
@@ -188,8 +188,12 @@ describe("Release version ordering", () => {
 });

 describe('Launcher path', () => {
+  const pathToCmd = `abc${path.sep}codeql.cmd`;
+  const pathToExe = `abc${path.sep}codeql.exe`;
+
  let sandbox: sinon.SinonSandbox;
  let warnSpy: sinon.SinonSpy;
+  let errorSpy: sinon.SinonSpy;
  let logSpy: sinon.SinonSpy;
  let fsSpy: sinon.SinonSpy;
  let platformSpy: sinon.SinonSpy;
@@ -209,37 +213,37 @@ describe('Launcher path', () => {
  it('should not warn with proper launcher name', async () => {
    launcherThatExists = 'codeql.exe';
    const result = await getExecutableFromDirectory('abc');
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.exe`);
+    expect(fsSpy).to.have.been.calledWith(pathToExe);

    // correct launcher has been found, so alternate one not looked for
-    expect(fsSpy).not.to.have.been.calledWith(`abc${path.sep}codeql.cmd`);
+    expect(fsSpy).not.to.have.been.calledWith(pathToCmd);

    // no warning message
    expect(warnSpy).not.to.have.been.calledWith(sinon.match.string);
    // No log message
    expect(logSpy).not.to.have.been.calledWith(sinon.match.string);
-    expect(result).to.equal(`abc${path.sep}codeql.exe`);
+    expect(result).to.equal(pathToExe);
  });

  it('should warn when using a hard-coded deprecated launcher name', async () => {
    launcherThatExists = 'codeql.cmd';
    path.sep;
    const result = await getExecutableFromDirectory('abc');
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.exe`);
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.cmd`);
+    expect(fsSpy).to.have.been.calledWith(pathToExe);
+    expect(fsSpy).to.have.been.calledWith(pathToCmd);

    // Should have opened a warning message
    expect(warnSpy).to.have.been.calledWith(sinon.match.string);
    // No log message
    expect(logSpy).not.to.have.been.calledWith(sinon.match.string);
-    expect(result).to.equal(`abc${path.sep}codeql.cmd`);
+    expect(result).to.equal(pathToCmd);
  });

  it('should avoid warn when no launcher is found', async () => {
    launcherThatExists = 'xxx';
    const result = await getExecutableFromDirectory('abc', false);
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.exe`);
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.cmd`);
+    expect(fsSpy).to.have.been.calledWith(pathToExe);
+    expect(fsSpy).to.have.been.calledWith(pathToCmd);

    // no warning message
    expect(warnSpy).not.to.have.been.calledWith(sinon.match.string);
@@ -251,8 +255,8 @@ describe('Launcher path', () => {
  it('should warn when no launcher is found', async () => {
    launcherThatExists = 'xxx';
    const result = await getExecutableFromDirectory('abc', true);
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.exe`);
-    expect(fsSpy).to.have.been.calledWith(`abc${path.sep}codeql.cmd`);
+    expect(fsSpy).to.have.been.calledWith(pathToExe);
+    expect(fsSpy).to.have.been.calledWith(pathToCmd);

    // no warning message
    expect(warnSpy).not.to.have.been.calledWith(sinon.match.string);
@@ -261,9 +265,46 @@ describe('Launcher path', () => {
    expect(result).to.equal(undefined);
  });

+  it('should not warn when deprecated launcher is used, but no new launcher is available', async () => {
+    const manager = new (createModule().DistributionManager)(undefined as any, { customCodeQlPath: pathToCmd } as any, undefined as any);
+    launcherThatExists = 'codeql.cmd';
+
+    const result = await manager.getCodeQlPathWithoutVersionCheck();
+    expect(result).to.equal(pathToCmd);
+
+    // no warning or error message
+    expect(warnSpy).to.have.callCount(0);
+    expect(errorSpy).to.have.callCount(0);
+  });
+
+  it('should warn when deprecated launcher is used, and new launcher is available', async () => {
+    const manager = new (createModule().DistributionManager)(undefined as any, { customCodeQlPath: pathToCmd } as any, undefined as any);
+    launcherThatExists = ''; // pretend both launchers exist
+
+    const result = await manager.getCodeQlPathWithoutVersionCheck();
+    expect(result).to.equal(pathToCmd);
+
+    // has warning message
+    expect(warnSpy).to.have.callCount(1);
+    expect(errorSpy).to.have.callCount(0);
+  });
+
+  it('should warn when launcher path is incorrect', async () => {
+    const manager = new (createModule().DistributionManager)(undefined as any, { customCodeQlPath: pathToCmd } as any, undefined as any);
+    launcherThatExists = 'xxx'; // pretend neither launcher exists
+
+    const result = await manager.getCodeQlPathWithoutVersionCheck();
+    expect(result).to.equal(undefined);
+
+    // no error message
+    expect(warnSpy).to.have.callCount(0);
+    expect(errorSpy).to.have.callCount(1);
+  });
+
  function createModule() {
    sandbox = sinon.createSandbox();
    warnSpy = sandbox.spy();
+    errorSpy = sandbox.spy();
    logSpy = sandbox.spy();
    // pretend that only the .cmd file exists
    fsSpy = sandbox.stub().callsFake(arg => arg.endsWith(launcherThatExists) ? true : false);
@@ -271,7 +312,8 @@ describe('Launcher path', () => {

    return proxyquire('../../distribution', {
      './helpers': {
-        showAndLogWarningMessage: warnSpy
+        showAndLogWarningMessage: warnSpy,
+        showAndLogErrorMessage: errorSpy
      },
      './logging': {
        'logger': {
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/sarifMessageParsingTest.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/sarifMessageParsingTest.test.ts
@@ -6,7 +6,7 @@ import { parseSarifPlainTextMessage } from '../../sarif-utils';

 describe('parsing sarif', () => {
  it('should be able to parse a simple message from the spec', async function() {
-    const message = "Tainted data was used. The data came from [here](3)."
+    const message = "Tainted data was used. The data came from [here](3).";
    const results = parseSarifPlainTextMessage(message);
    expect(results).to.deep.equal([
      "Tainted data was used. The data came from ",
@@ -15,7 +15,7 @@ describe('parsing sarif', () => {
  });

  it('should be able to parse a complex message from the spec', async function() {
-    const message = "Prohibited term used in [para\\[0\\]\\\\spans\\[2\\]](1)."
+    const message = "Prohibited term used in [para\\[0\\]\\\\spans\\[2\\]](1).";
    const results = parseSarifPlainTextMessage(message);
    expect(results).to.deep.equal([
      "Prohibited term used in ",
@@ -23,14 +23,14 @@ describe('parsing sarif', () => {
    ]);
  });
  it('should be able to parse a broken complex message from the spec', async function() {
-    const message = "Prohibited term used in [para\\[0\\]\\\\spans\\[2\\](1)."
+    const message = "Prohibited term used in [para\\[0\\]\\\\spans\\[2\\](1).";
    const results = parseSarifPlainTextMessage(message);
    expect(results).to.deep.equal([
      "Prohibited term used in [para[0]\\spans[2](1)."
    ]);
  });
  it('should be able to parse a message with extra escaping the spec', async function() {
-    const message = "Tainted data was used. The data came from \\[here](3)."
+    const message = "Tainted data was used. The data came from \\[here](3).";
    const results = parseSarifPlainTextMessage(message);
    expect(results).to.deep.equal([
      "Tainted data was used. The data came from [here](3)."
--- a/extensions/ql-vscode/src/vscode-tests/no-workspace/webview-uri.test.ts
+++ b/extensions/ql-vscode/src/vscode-tests/no-workspace/webview-uri.test.ts
@@ -32,7 +32,7 @@ describe('webview uri conversion', function() {
    return {
      fileUriOnDisk,
      panel
-    }
+    };
  }

  it('should correctly round trip from filesystem to webview and back', function() {
--- a/extensions/ql-vscode/syntaxes/ql.tmLanguage.yml
+++ b/extensions/ql-vscode/syntaxes/ql.tmLanguage.yml
@@ -422,6 +422,11 @@ repository:
      keyword: 'true'
    name: constant.language.boolean.true.ql

+  unique:
+    match:
+      keyword: 'unique'
+    name: keyword.aggregate.unique.ql
+
  where:
    match:
      keyword: 'where'
@@ -478,6 +483,8 @@ repository:
    - include: '#then'
    - include: '#this'
    - include: '#true'
+    # `unique` is not really a keyword, but we'll highlight it as if it is.
+    - include: '#unique'
    - include: '#where'

  # A keyword that can be the first token of a predicate declaration.
--- a/extensions/ql-vscode/test/.eslintrc.js
+++ b/extensions/ql-vscode/test/.eslintrc.js
@@ -3,6 +3,6 @@ module.exports = {
    mocha: true
  },
  parserOptions: {
-    project: 'tsconfig.json',
+    project: './test/tsconfig.json',
  },
 }
--- a/extensions/ql-vscode/test/pure-tests/command-lint.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/command-lint.test.ts
@@ -0,0 +1,101 @@
+import { expect } from 'chai';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+type CmdDecl = {
+  command: string;
+  when?: string;
+  title?: string;
+}
+
+describe('commands declared in package.json', function() {
+  const manifest = fs.readJsonSync(path.join(__dirname, '../../package.json'));
+  const commands = manifest.contributes.commands;
+  const menus = manifest.contributes.menus;
+
+  const disabledInPalette: Set<string> = new Set<string>();
+
+  // These commands should appear in the command palette, and so
+  // should be prefixed with 'CodeQL: '.
+  const paletteCmds: Set<string> = new Set<string>();
+
+  // These commands arising on context menus in non-CodeQL controlled
+  // panels, (e.g. file browser) and so should be prefixed with 'CodeQL: '.
+  const contribContextMenuCmds: Set<string> = new Set<string>();
+
+  // These are commands used in CodeQL controlled panels, and so don't need any prefixing in their title.
+  const scopedCmds: Set<string> = new Set<string>();
+  const commandTitles: { [cmd: string]: string } = {};
+
+  commands.forEach((commandDecl: CmdDecl) => {
+    const { command, title } = commandDecl;
+    if (command.match(/^codeQL\./)
+      || command.match(/^codeQLQueryResults\./)
+      || command.match(/^codeQLTests\./)) {
+      paletteCmds.add(command);
+      expect(title).not.to.be.undefined;
+      commandTitles[command] = title!;
+    }
+    else if (command.match(/^codeQLDatabases\./)
+      || command.match(/^codeQLQueryHistory\./)) {
+      scopedCmds.add(command);
+      expect(title).not.to.be.undefined;
+      commandTitles[command] = title!;
+    }
+    else {
+      expect.fail(`Unexpected command name ${command}`);
+    }
+  });
+
+  menus['explorer/context'].forEach((commandDecl: CmdDecl) => {
+    const { command } = commandDecl;
+    paletteCmds.delete(command);
+    contribContextMenuCmds.add(command);
+  });
+
+  menus['editor/context'].forEach((commandDecl: CmdDecl) => {
+    const { command } = commandDecl;
+    paletteCmds.delete(command);
+    contribContextMenuCmds.add(command);
+  });
+
+  menus.commandPalette.forEach((commandDecl: CmdDecl) => {
+    if (commandDecl.when === 'false')
+      disabledInPalette.add(commandDecl.command);
+  });
+
+
+
+  it('should have commands appropriately prefixed', function() {
+    paletteCmds.forEach(command => {
+      expect(commandTitles[command], `command ${command} should be prefixed with 'CodeQL: ', since it is accessible from the command palette`).to.match(/^CodeQL: /);
+    });
+
+    contribContextMenuCmds.forEach(command => {
+      expect(commandTitles[command], `command ${command} should be prefixed with 'CodeQL: ', since it is accessible from a context menu in a non-extension-controlled context`).to.match(/^CodeQL: /);
+    });
+
+    scopedCmds.forEach(command => {
+      expect(commandTitles[command], `command ${command} should not be prefixed with 'CodeQL: ', since it is accessible from an extension-controlled context`).not.to.match(/^CodeQL: /);
+    });
+  });
+
+  it('should have the right commands accessible from the command palette', function() {
+    paletteCmds.forEach(command => {
+      expect(disabledInPalette.has(command), `command ${command} should be enabled in the command palette`).to.be.false;
+    });
+
+    // Commands in contribContextMenuCmds may reasonbly be enabled or
+    // disabled in the command palette; for example, codeQL.runQuery
+    // is available there, since we heuristically figure out which
+    // query to run, but codeQL.setCurrentDatabase is not.
+
+    scopedCmds.forEach(command => {
+      expect(disabledInPalette.has(command), `command ${command} should be disabled in the command palette`).to.be.true;
+    });
+  });
+
+
+});
+
+
--- a/extensions/ql-vscode/test/pure-tests/location.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/location.test.ts
@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 import 'mocha';
-import { LocationStyle, StringLocation, tryGetWholeFileLocation } from 'semmle-bqrs';
+import { LocationStyle, StringLocation, tryGetResolvableLocation } from 'semmle-bqrs';

 describe('processing string locations', function () {
  it('should detect Windows whole-file locations', function () {
@@ -8,7 +8,7 @@ describe('processing string locations', function () {
      t: LocationStyle.String,
      loc: 'file://C:/path/to/file.ext:0:0:0:0'
    };
-    const wholeFileLoc = tryGetWholeFileLocation(loc);
+    const wholeFileLoc = tryGetResolvableLocation(loc);
    expect(wholeFileLoc).to.eql({t: LocationStyle.WholeFile, file: 'C:/path/to/file.ext'});
  });
  it('should detect Unix whole-file locations', function () {
@@ -16,12 +16,27 @@ describe('processing string locations', function () {
      t: LocationStyle.String,
      loc: 'file:///path/to/file.ext:0:0:0:0'
    };
-    const wholeFileLoc = tryGetWholeFileLocation(loc);
+    const wholeFileLoc = tryGetResolvableLocation(loc);
    expect(wholeFileLoc).to.eql({t: LocationStyle.WholeFile, file: '/path/to/file.ext'});
  });
+  it('should detect Unix 5-part locations', function () {
+    const loc: StringLocation = {
+      t: LocationStyle.String,
+      loc: 'file:///path/to/file.ext:1:2:3:4'
+    };
+    const wholeFileLoc = tryGetResolvableLocation(loc);
+    expect(wholeFileLoc).to.eql({
+      t: LocationStyle.FivePart,
+      file: '/path/to/file.ext',
+      lineStart: 1,
+      colStart: 2,
+      lineEnd: 3,
+      colEnd: 4
+    });
+  });
  it('should ignore other string locations', function () {
    for (const loc of ['file:///path/to/file.ext', 'I am not a location']) {
-      const wholeFileLoc = tryGetWholeFileLocation({
+      const wholeFileLoc = tryGetResolvableLocation({
        t: LocationStyle.String,
        loc: loc
      });
--- a/extensions/ql-vscode/test/pure-tests/logging.test.ts
+++ b/extensions/ql-vscode/test/pure-tests/logging.test.ts
@@ -48,18 +48,7 @@ describe('OutputChannelLogger tests', () => {
  });

  it('should create a side log in the workspace area', async () => {
-    await sideLogTest('storagePath', 'globalStoragePath');
-  });
-
-  it('should create a side log in the global area', async () => {
-    await sideLogTest('globalStoragePath', 'storagePath');
-  });
-
-  async function sideLogTest(expectedArea: string, otherArea: string): Promise<void> {
-    logger.init({
-      [expectedArea]: tempFolders[expectedArea].name,
-      [otherArea]: undefined
-    });
+    logger.init(tempFolders.storagePath.name);

    await logger.log('xxx', { additionalLogLocation: 'first' });
    await logger.log('yyy', { additionalLogLocation: 'second' });
@@ -67,19 +56,16 @@ describe('OutputChannelLogger tests', () => {
    await logger.log('aaa');

    // expect 2 side logs
-    const testLoggerFolder = path.join(tempFolders[expectedArea].name, 'test-logger');
+    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
    expect(fs.readdirSync(testLoggerFolder).length).to.equal(2);
-    expect(fs.readdirSync(tempFolders[otherArea].name).length).to.equal(0);

    // contents
    expect(fs.readFileSync(path.join(testLoggerFolder, 'first'), 'utf8')).to.equal('xxx\nzzz');
    expect(fs.readFileSync(path.join(testLoggerFolder, 'second'), 'utf8')).to.equal('yyy\n');
-  }
+  });

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

@@ -94,9 +80,7 @@ describe('OutputChannelLogger tests', () => {
  });

  it('should remove an additional log location', async () => {
-    logger.init({
-      storagePath: tempFolders.storagePath.name
-    });
+    logger.init(tempFolders.storagePath.name);
    await logger.log('xxx', { additionalLogLocation: 'first' });
    await logger.log('yyy', { additionalLogLocation: 'second' });

@@ -112,9 +96,7 @@ describe('OutputChannelLogger tests', () => {

  it('should delete an existing folder on init', async () => {
    fs.createFileSync(path.join(tempFolders.storagePath.name, 'test-logger', 'xxx'));
-    logger.init({
-      storagePath: tempFolders.storagePath.name
-    });
+    logger.init(tempFolders.storagePath.name);
    // should be empty dir

    const testLoggerFolder = path.join(tempFolders.storagePath.name, 'test-logger');
--- a/extensions/ql-vscode/test/pure-tests/query-test.ts
+++ b/extensions/ql-vscode/test/pure-tests/query-test.ts
@@ -33,7 +33,7 @@ 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; this.rej = rej; });
  }

  async done(): Promise<T> {
@@ -114,7 +114,7 @@ describe('using the query server', function() {
      async getCodeQlPathWithoutVersionCheck(): Promise<string | undefined> {
        return codeQlPath;
      },
-    }, logger)
+    }, logger);
    qs = new qsClient.QueryServerClient(
      {
        codeQlPath,
@@ -187,7 +187,7 @@ describe('using the query server', function() {
        const db: messages.Dataset = {
          dbDir: path.join(__dirname, '../test-db'),
          workingSet: 'default',
-        }
+        };
        const params: messages.EvaluateQueriesParams = {
          db,
          evaluateId: callbackId,
--- a/extensions/ql-vscode/test/tsconfig.json
+++ b/extensions/ql-vscode/test/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "include": [
+    "**/*.ts"
+  ],
+  "compilerOptions": {
+    "noEmit": true
+  }
+}
--- a/lib/semmle-bqrs/src/bqrs-results.ts
+++ b/lib/semmle-bqrs/src/bqrs-results.ts
@@ -1,4 +1,4 @@
-import { LocationStyle } from './bqrs-schema';
+import { LocationStyle } from "./bqrs-schema";

 // See https://help.semmle.com/QL/learn-ql/ql/locations.html for how these are used.
 export interface FivePartLocation {
@@ -31,54 +31,69 @@ export type LocationValue = RawLocationValue | WholeFileLocation;
 /** A location that may be resolved to a source code element. */
 export type ResolvableLocationValue = FivePartLocation | WholeFileLocation;

-
 /**
 * 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 WHOLE_FILE_LOCATION_REGEX = /file:\/\/(.+):0:0:0:0/;
-
+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 {
+export function tryGetResolvableLocation(
+  loc: LocationValue | undefined
+): ResolvableLocationValue | undefined {
  if (loc === undefined) {
    return undefined;
-  }
-  else if ((loc.t === LocationStyle.FivePart) && loc.file) {
+  } else if (loc.t === LocationStyle.FivePart && loc.file) {
    return loc;
-  }
-  else if ((loc.t === LocationStyle.WholeFile) && loc.file) {
+  } else if (loc.t === LocationStyle.WholeFile && loc.file) {
    return loc;
-  }
-  else if ((loc.t === LocationStyle.String) && loc.loc) {
-    return tryGetWholeFileLocation(loc);
-  }
-  else {
+  } else if (loc.t === LocationStyle.String && loc.loc) {
+    return tryGetLocationFromString(loc);
+  } else {
    return undefined;
  }
 }

-export function tryGetWholeFileLocation(loc: StringLocation): WholeFileLocation | undefined {
-  const matches = WHOLE_FILE_LOCATION_REGEX.exec(loc.loc);
+export function tryGetLocationFromString(
+  loc: StringLocation
+): ResolvableLocationValue | undefined {
+  const matches = FILE_LOCATION_REGEX.exec(loc.loc);
  if (matches && matches.length > 1 && matches[1]) {
-    // Whole-file location.
-    // We could represent this as a FivePartLocation with all numeric fields set to zero,
-    // but that would be a deliberate misuse as those fields are intended to be 1-based.
-    return {
-      t: LocationStyle.WholeFile,
-      file: 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"
+  );
+}
+
 export interface ElementBase {
  id: PrimitiveColumnValue;
  label?: string;
@@ -93,8 +108,7 @@ export interface ElementWithLocation extends ElementBase {
  location: LocationValue;
 }

-export interface Element extends Required<ElementBase> {
-}
+export interface Element extends Required<ElementBase> {}

 export type PrimitiveColumnValue = string | boolean | number | Date;
 export type ColumnValue = PrimitiveColumnValue | ElementBase;
--- a/tsfmt.json
+++ b/tsfmt.json
@@ -1,5 +1,6 @@
 {
  "newLineCharacter": "\n",
+  "convertTabsToSpaces": true,
  "indentStyle": 2,
  "insertSpaceAfterCommaDelimiter": true,
  "insertSpaceAfterSemicolonInForStatements": true,
Author	SHA1	Message	Date
jcreedcmu	f6f2b99c67	Merge pull request #379 from jcreedcmu/jcreed/v1.2.0-take-2 Some checks failed Build Extension / Build (ubuntu-latest) (push) Has been cancelled Details Build Extension / Build (windows-latest) (push) Has been cancelled Details Build Extension / Test (ubuntu-latest) (push) Has been cancelled Details Build Extension / Test (windows-latest) (push) Has been cancelled Details Release / Release (push) Has been cancelled Details Increment version for minor release	2020-05-19 14:28:49 -04:00
Jason Reed	b2c82029f6	Increment version for minor release	2020-05-19 14:26:16 -04:00
jcreedcmu	d18b524c81	Merge pull request #378 from jcreedcmu/jcreed/v1.2.0 Update CHANGELOG.md for release.	2020-05-19 14:25:07 -04:00
Jason Reed	6be2c8bb95	Update CHANGELOG.md for release.	2020-05-19 14:22:12 -04:00
jcreedcmu	c289f1f66f	Merge pull request #368 from jcreedcmu/jcreed/jump-to-def-release Remove feature flag guard around source archive jump-to-definition	2020-05-19 14:17:33 -04:00
jcreedcmu	c2717d7725	Merge branch 'master' into jcreed/jump-to-def-release	2020-05-19 14:14:59 -04:00
jcreedcmu	74e42b86a6	Merge pull request #375 from jcreedcmu/jcreed/more-logging Logging: More chatty logging during extension initialization.	2020-05-19 14:14:00 -04:00
jcreedcmu	6db514843b	Merge branch 'master' into jcreed/jump-to-def-release	2020-05-19 13:57:20 -04:00
jcreedcmu	c8d64e4c35	Merge branch 'master' into jcreed/more-logging	2020-05-19 13:56:10 -04:00
jcreedcmu	0e4c3be404	Merge pull request #377 from jcreedcmu/jcreed/prefix Fix naming and availability in command palette of various commands	2020-05-19 13:54:10 -04:00
Jason Reed	dd1bdf54bb	Add integrity check for commands in package.json Attempt to enforce some regularity in how we name commands, and fix one command that was showing up improperly in the command palette.	2020-05-19 12:20:45 -04:00
Jason Reed	c01772848c	Add all db-getting commands (dl, folder, zip) to command palette	2020-05-19 11:32:54 -04:00
Jason Reed	ab09cdb66d	Make capitalization consistent	2020-05-19 11:02:32 -04:00
Jason Reed	d92edfb058	Remove database panel icon commands from command palette This corrects what is an unfortunately common accidental antipattern, where creating a command meant just to be the handler of a user interface button ends up in the command palette unless you explicitly set `"when": "false"` in the command palette section of the configuration. Also enforce the naming convention that commands prefixed with `codeQLDatabases.` are those meant for the databases panel only, while prefixing `codeQL.` means that it's meant to be directly accessible through the command palette.	2020-05-19 10:59:35 -04:00
jcreedcmu	1e86e08851	Merge pull request #376 from shati-patel/choose-db Update README with new command for adding database	2020-05-19 09:14:38 -04:00
Shati Patel	c505996ca0	Update README with new command for adding database	2020-05-19 13:19:58 +01:00
Jason Reed	0796893017	Logging: More chatty logging during extension initialization. Mainly intentded to make it easier to debug the cause of command-palette commands being undefined.	2020-05-18 13:24:00 -04:00
jcreedcmu	6fdfade1ed	Merge pull request #374 from aeisenberg/path-fix Fix paths on windows when opening archive databases	2020-05-15 19:35:04 -04:00
Andrew Eisenberg	e31f8b73ac	Fix paths on windows when opening archive databases	2020-05-15 16:30:50 -07:00
jcreedcmu	f38d0fd08e	Merge pull request #372 from github/version/bump-to-v1.1.6 Bump version to v1.1.6	2020-05-15 15:39:14 -04:00
github-actions[bot]	579aba5abb	Bump version to v1.1.6	2020-05-15 19:00:31 +00:00
jcreedcmu	31066be29e	Merge pull request #371 from aeisenberg/aeisenberg/release Some checks failed Build Extension / Build (ubuntu-latest) (push) Has been cancelled Details Build Extension / Build (windows-latest) (push) Has been cancelled Details Build Extension / Test (ubuntu-latest) (push) Has been cancelled Details Build Extension / Test (windows-latest) (push) Has been cancelled Details Release / Release (push) Has been cancelled Details Update changelog for release	2020-05-15 14:55:47 -04:00
Andrew Eisenberg	3bbecb248b	Update changelog for release	2020-05-15 11:53:58 -07:00
jcreedcmu	691c9af1f7	Merge pull request #370 from aeisenberg/aeisenberg/import-notify Refactor how we import database archives	2020-05-15 13:43:10 -04:00
Andrew Eisenberg	a137a72e02	Refactor how we import database archives Now, importing an archive includes a progress monitor and will also display a message when complete. Error handling is also more uniform.	2020-05-15 10:39:40 -07:00
Jason Reed	a98e3bc9ae	Fix docs, comments.	2020-05-15 12:42:46 -04:00
Jason Reed	4ffab3c16d	Remove feature flag guard around source archive jump-to-definition	2020-05-15 12:42:46 -04:00
Andrew Eisenberg	bb3aa79dad	Update changelog	2020-05-15 08:27:51 -07:00
Andrew Eisenberg	7f34fcaa1c	Update commands for importing databases 1. Add commands for importing an archive, folder, or from internet 2. Add new icons for all of them 3. Ensure that each command can only retrieve databases through a single mechanism	2020-05-15 08:27:51 -07:00
Andrew Eisenberg	e42a39e5ec	Look for either .dbinfo or codeql-database.yml	2020-05-15 08:27:51 -07:00
Andrew Eisenberg	bd22878ec8	Update changelog	2020-05-15 08:27:51 -07:00
Andrew Eisenberg	8dd1b9f44e	Augments the add database command to handle zip files The add database command can now add databases by zip file. When a file is selected, the zip file is attempted to be extracted into a directory managed by the extension. Once extracted, a database is searched for, by looking for a .dbinfo file. Crucially, we are using the same infrastructure to download a database as we are to add a database by zip file.	2020-05-15 08:27:51 -07:00
jcreedcmu	2da70d774d	Merge pull request #367 from jbj/link-style Make links variable-width without underline	2020-05-14 12:58:51 -04:00
Jonas Jensen	2fddc9cff1	Make links variable-width without underline These are two independent changes. - The monospace font used in links made the text larger so that less text could fit on the screen. It also suggested that all link text was an code snippet, which it isn't. The advantage of a fixed-width font, vertical alignment, was not put to any use. - Underlining of links made it almost impossible to distinguish a space from an underscore.	2020-05-14 09:59:44 +02:00
jcreedcmu	11d9bdc8e1	Merge pull request #365 from aeisenberg/lint-semi Add semi-colon linting	2020-05-13 15:40:47 -04:00
Andrew Eisenberg	7d23a833b1	Add semi-colon linting	2020-05-13 12:06:53 -07:00
Andrew Eisenberg	258322057f	Ensure the extension dir exists before writing to it	2020-05-13 11:47:43 -07:00
jcreedcmu	6ded193891	Merge pull request #362 from github/version/bump-to-v1.1.5 Bump version to v1.1.5	2020-05-13 14:44:41 -04:00
jcreedcmu	bb6b90646f	Merge pull request #363 from aeisenberg/lint-fixes Fixes to how we lint automatically	2020-05-13 14:42:57 -04:00
Andrew Eisenberg	fece068800	Rename npm script for clarity	2020-05-13 11:36:05 -07:00
Andrew Eisenberg	de8b7d44cd	Avoid linting indentation rules This is already handled by tsfmt and eslint has some slight differences.	2020-05-13 11:29:32 -07:00
Andrew Eisenberg	432c5c9ae7	Move linting from precommit to prepush It's a longer action, so we don't want to run it on each commit.	2020-05-13 11:27:34 -07:00
github-actions[bot]	59433af8be	Bump version to v1.1.5	2020-05-13 17:30:08 +00:00
Andrew Eisenberg	c6928d3159	Update changelog Some checks failed Build Extension / Build (ubuntu-latest) (push) Has been cancelled Details Build Extension / Build (windows-latest) (push) Has been cancelled Details Build Extension / Test (ubuntu-latest) (push) Has been cancelled Details Build Extension / Test (windows-latest) (push) Has been cancelled Details Release / Release (push) Has been cancelled Details	2020-05-13 10:25:06 -07:00
Andrew Eisenberg	fd26e02ed3	Update changelog	2020-05-13 08:10:38 -07:00
Andrew Eisenberg	de381804f6	Fix lint	2020-05-13 08:10:38 -07:00
Andrew Eisenberg	2f92477bd9	Move storagePath calculation to extension.ts	2020-05-13 08:10:38 -07:00
Andrew Eisenberg	926ab92dfe	Add command to download, unzip, and open databases New command that requests a URL and allows a user to install a database from that url. Closes #357	2020-05-13 08:10:38 -07:00
Andrew Eisenberg	36484fcea6	Formatting	2020-05-13 08:10:38 -07:00
Andrew Eisenberg	89e7b03d4a	Add format and lint on commit	2020-05-12 10:15:48 -07:00
Andrew Eisenberg	c3e3390647	Extract BQRS locations from string results	2020-05-08 11:49:46 -07:00
Andrew Eisenberg	010ae64da3	Use inline-source-map This gets a better debugging experience for webview.	2020-05-08 11:49:46 -07:00
Andrew Eisenberg	bd3702121f	Never run format on save This can lead to lots of non-semantic whitespace changes.	2020-05-08 11:49:46 -07:00
jcreedcmu	043d17d454	Merge pull request #356 from github/version/bump-to-v1.1.4 Bump version to v1.1.4	2020-05-08 12:49:35 -04:00
github-actions[bot]	1c7cad0151	Bump version to v1.1.4	2020-05-08 16:43:45 +00:00
jcreedcmu	e0383b3f9a	Merge pull request #355 from jcreedcmu/jcreed/1.1.3 Some checks failed Build Extension / Build (ubuntu-latest) (push) Has been cancelled Details Build Extension / Build (windows-latest) (push) Has been cancelled Details Build Extension / Test (ubuntu-latest) (push) Has been cancelled Details Build Extension / Test (windows-latest) (push) Has been cancelled Details Release / Release (push) Has been cancelled Details Update CHANGELOG for release.	2020-05-08 12:41:15 -04:00
Jason Reed	0d972d7916	Update CHANGELOG for release.	2020-05-08 12:34:37 -04:00
jcreedcmu	ab020f24ae	Merge pull request #354 from aeisenberg/aesienberg/database-commands Rename database and open database directory	2020-05-08 12:30:57 -04:00
jcreedcmu	81cbf26910	Merge branch 'master' into aesienberg/database-commands	2020-05-08 12:08:59 -04:00
Andrew Eisenberg	2e2f101131	Update changelog	2020-05-07 21:58:16 -07:00
Andrew Eisenberg	610d40c99c	Add a command to open a database directory externally	2020-05-07 15:51:00 -07:00
Andrew Eisenberg	adf6f66517	Add ability to rename database in database tree	2020-05-07 15:50:59 -07:00
Dave Bartolomeo	8f84989d98	Merge pull request #352 from jcreedcmu/jcreed/update-lsp Update versions of json-rpc dependencies.	2020-05-07 12:02:30 -04:00
Jason Reed	22c9386123	Use ^versions not ~versions.	2020-05-07 11:32:17 -04:00
jcreedcmu	53e1794b50	Merge pull request #351 from jcreedcmu/jcreed/no-paginate Don't paginate at all in experimental bqrs parsing codepath	2020-05-07 09:46:31 -04:00
Jason Reed	307d6d7c7f	Update versions of json-rpc dependencies.	2020-05-07 09:45:23 -04:00
Jason Reed	a0e60fb154	Don't paginate at all in experimental bqrs parsing codepath	2020-05-06 12:07:47 -04:00
jcreedcmu	8b5bdbb6ef	Merge pull request #350 from jcreedcmu/jcreed/cli-bqrs-parsing Experimental: Enable parsing bqrs with the cli instead of in the webview	2020-05-06 11:34:35 -04:00
Jason Reed	0ad9cdd5ac	Address review comments and fix formatting.	2020-05-06 10:39:27 -04:00
Jason Reed	c3b2e9d478	Add experimental use of cli bqrs parsing. When `codeQL.experimentalBqrsParsing` is set to true, parse raw results from the bqrs file using the cli, rather than doing it in the webview.	2020-05-05 17:00:20 -04:00
Jason Reed	c20bbd9606	Fix formatting. This is simultaneously compatible with eslint and tsfmt.	2020-05-05 16:21:58 -04:00
jcreedcmu	6080a0d585	Merge pull request #347 from jcreedcmu/jcreed/launch-config internal: Revert specifying workspace in launch config	2020-05-05 13:08:28 -04:00
jcreedcmu	9fda320589	Merge pull request #340 from jcreedcmu/jcreed/no-qhelp-alias Remove 'qhelp' as global alias for 'xml' filetype	2020-05-05 11:01:12 -04:00
Jason Reed	143b51ef82	Revert specifying workspace in launch config The behavior without this line is to use whichever workspace was opened last when testing. I find this more convenient, since I have several (non-vscode-codeql-starter-workspace) local workspaces I use for manual testing, and it's nice to have them persist from one run to the next.	2020-05-05 10:58:54 -04:00
Alexander Eyers-Taylor	51d4c87af4	Merge pull request #346 from jcreedcmu/jcreed/fix-jump-to-def-bug Jump-to-definition: Fix mistakenly always using the references query	2020-05-01 18:41:02 +01:00
Jason Reed	be5efc01ee	Jump-to-definition: Fix mistakenly always using the references query	2020-05-01 13:17:17 -04:00
jcreedcmu	08a30c454a	Merge pull request #345 from jcreedcmu/jcreed/better-empty-message Add suggestive message to alerts view when 0 alerts, >0 raw results.	2020-05-01 09:01:25 -04:00
Jason Reed	1377969213	Add suggestive message to alerts view when 0 alerts, >0 raw results. Fixes https://github.com/github/codeql-coreql-team/issues/383.	2020-05-01 08:17:51 -04:00
jcreedcmu	41f1aae71d	Merge pull request #344 from github/shati/changelog-date Changelog: Add release date	2020-04-28 13:49:41 -04:00
Shati Patel	62cae6ead1	Changelog: Add release date	2020-04-28 18:30:45 +01:00
jcreedcmu	39e3627e06	Merge pull request #343 from github/version/bump-to-v1.1.3 Bump version to v1.1.3	2020-04-28 11:40:48 -04:00
github-actions[bot]	43586c91d9	Bump version to v1.1.3	2020-04-28 15:34:08 +00:00
jcreedcmu	8efb060031	Merge pull request #337 from jcreedcmu/jcreed/jump-to-def Some checks failed Build Extension / Build (ubuntu-latest) (push) Has been cancelled Details Build Extension / Build (windows-latest) (push) Has been cancelled Details Build Extension / Test (ubuntu-latest) (push) Has been cancelled Details Build Extension / Test (windows-latest) (push) Has been cancelled Details Release / Release (push) Has been cancelled Details Add experimental support for Jump-to-def and Find-references	2020-04-28 11:24:55 -04:00
Jason Reed	31414b7506	Remove 'qhelp' as global alias for 'xml' filetype	2020-04-23 10:06:27 -04:00
Jason Reed	e242a8fbeb	Review comments	2020-04-22 14:09:20 -04:00
Jason Reed	ee591e802f	Fix lint violations	2020-04-21 13:19:07 -04:00
Jason Reed	7df8905aa0	Scope tags for ide queries	2020-04-21 13:14:19 -04:00
Shati Patel	23b1c00179	Update changelog	2020-04-21 08:27:29 -07:00
Jason Reed	701804b6a4	Guard find-references with experimental setting	2020-04-21 11:15:12 -04:00
Jason Reed	66665bf25e	Refactor definitions/references finding	2020-04-21 11:15:12 -04:00
Jason Reed	1c6b4a6d1e	Put CachedOperation in helpers.	2020-04-21 11:15:12 -04:00
Jason Reed	28be98411d	Add constants for bqrs column kinds	2020-04-21 11:15:12 -04:00
Jason Reed	5592a77963	Can autodetect language	2020-04-21 11:15:12 -04:00
Jason Reed	a6cd08fb0b	Add wrapper for 'resolve queries' cli command	2020-04-21 11:15:12 -04:00
Jason Reed	881c909540	Make rudimentary jump-to-definition work	2020-04-21 11:15:12 -04:00
Henry Mercer	f5e3af02e4	Merge pull request #336 from github/pr-template Update link in PR template	2020-04-21 12:11:30 +01:00
Shati Patel	3eca4f6734	Update link in PR template	2020-04-20 23:22:25 +01:00
Andrew Eisenberg	596ccdb722	Update change log	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	2aeda002fa	Add sort by date added for databases This uses the dateAdded field on databases. It will only work for databases added after that field was added. Otherwise, the dateAdded property will be undefined.	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	27623f3325	Add dateAdded field for databases Existing databases will have this value as `undefined`. Newly added databases will have this value as the Unix timestamp when added. Stuffing this value into the `options` field of the database. The name is not quite right, but it seems like this is the right place. Should I rename?	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	f3df3b9f3e	Rename svg for sorting dates add svg for sorting names	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	5850ed3288	refactor: Move icons into light/dark folders This follows the vscode styles where all icons for dark mode are in the `dark` folder and all for light mode in the `light` folder. They always have the same name.	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	a2f8c85359	Add command to sort databases by name This assumes that we will be adding other sorting mechanisms in the future, like sort by data added. Not happy with the icon I chose, but I didn't want to spend too much time creating a new one.	2020-04-20 08:50:54 -07:00
Andrew Eisenberg	62d9efc4ee	Update changelog	2020-04-20 07:55:59 -07:00
Andrew Eisenberg	00026a7727	feat: User can see query text at time of execution Add new command to view the query text in a synthetic, read-only document. Quick eval queries will show the text selected when initially running the query. Quick eval queries where the user has a single caret selection will show the entire line of text.	2020-04-20 07:55:59 -07:00
Jason Reed	c292f58e20	Factor out database qlpack inference.	2020-04-20 09:59:41 -04:00
jcreedcmu	6f935ae6e4	Merge pull request #331 from aeisenberg/aeisenberg/changelog Update changelog	2020-04-16 12:58:57 -04:00
Andrew Eisenberg	1fb65cd7e9	Update changelog	2020-04-16 09:51:01 -07:00
jcreedcmu	21500f0a5b	Merge pull request #330 from dbartol/dbartol/unique-highlighting Highlight `unique` as a keyword	2020-04-15 09:49:24 -04:00
Dave Bartolomeo	efcf9815f0	Update CHANGELOG.md for `unique` highlighting	2020-04-14 12:53:33 -04:00
Dave Bartolomeo	f8635f41a5	Highlight `unique` as a keyword `unique` is really a context-sensitive keyword, but that's even more of a hassle in a TextMate grammars than it is in the compiler itself. We'll just highlight it as a real keyword. The worst that will happen is that existing variables and predicates named "unique" will be highlighted like keywords, which will hopefully just encourage QL developers to rename those anyway.	2020-04-14 12:48:18 -04:00
jcreedcmu	e4df717d2b	Merge pull request #324 from jcreedcmu/jcreed/always-save Add 'Always Save' to running unsaved query dialog	2020-04-07 12:49:07 -04:00
jcreedcmu	9ea4b3936a	Merge pull request #326 from p-/qhelp-syntax-highlighting feat: XML syntax highlighting for qhelp files	2020-04-07 12:10:09 -04:00
Jason Reed	e5305ab4b5	Fix lint compatibly with tsfmt	2020-04-07 12:02:50 -04:00
Jason Reed	c2c86aed0a	Add 'Always Save' to running unsaved query dialog	2020-04-07 12:02:50 -04:00
Dave Bartolomeo	2df512f018	Merge pull request #327 from jcreedcmu/jcreed/fix-windows-ci chore: Fix codeql.cmd overwriting codeql.exe in CI	2020-04-07 11:48:04 -04:00
Jason Reed	ba3381fbf9	Fix codeql.cmd overwriting codeql.exe in CI	2020-04-07 10:06:29 -04:00
Peter Stöckli	869029b856	feat: XML syntax highlighting for .qhelp files	2020-04-04 16:59:02 +02:00
Andrew Eisenberg	b3ad1d6814	fix: Avoid warning user if no new launcher exists Allow extension to remain on the deprecated launcher.	2020-03-27 08:46:45 -07:00
Andrew Eisenberg	130d3c09e3	build: Enable linting in the build	2020-03-25 12:02:12 -07:00
Andrew Eisenberg	bb28dafc43	lint: Add proper linting for react	2020-03-25 12:02:12 -07:00
Andrew Eisenberg	db6aadbf93	fix: Use a proper 'file' schema for uris	2020-03-25 11:16:32 -07:00
Henry Mercer	d97c8e864d	Merge pull request #313 from shati-patel/error-typo Fix typo in error message	2020-03-25 10:25:54 +00:00
Shati Patel	d8a6368e60	Fix typo in error message Spotted a small typo ("exterally") and updated the error message.	2020-03-25 08:59:04 +00:00
jcreedcmu	76d6ab4e81	Merge pull request #305 from github/version/bump-to-v1.1.2 Bump version to v1.1.2	2020-03-23 13:01:36 -04:00
github-actions[bot]	bdcabae60e	Bump version to v1.1.2	2020-03-23 16:56:34 +00:00