Consider user installed HLSes (e.g. via ghcup compile)

README.md

@@ -71,25 +71,26 @@ The environment _only will be visible for the lsp server_, not for other extensi
 
 ### Downloaded binaries
 
-This extension will download `haskell-language-server` binaries via an (internal) ghcup to a specific location depending
-on your system, unless you set the config option `haskell.manageHLS` to `false` (the default is `true`).
+This extension will download `haskell-language-server` binaries either via an internal ghcup (it will download it automaticlaly)
+or via a system ghcup (which must be present), unless you set the config option `haskell.manageHLS` to `PATH` (the extension
+will ask you on first start).
 
-It will download the newest version of haskell-language-server which has support for the required ghc.
+It will then download the newest version of haskell-language-server which has support for the required ghc.
 That means it could use an older version than the latest one, without the last features and bug fixes.
 For example, if a project needs ghc-8.10.4 the extension will download and use haskell-language-server-1.4.0, the lastest version which supported ghc-8.10.4. Even if the lastest global haskell language-server version is 1.5.1.
 
-If you find yourself running out of disk space, you can try deleting old versions of language servers in this directory. The extension will redownload them, no strings attached.
+If you have disk space issues and use system ghcup, check `ghcup gc --help`.
+If you have disk space issues and use the internal ghcup, check the following directories, depending on your platform
+and possible delete them:
 
 | Platform | Path                                                                            |
 | -------- | ------------------------------------------------------------------------------- |
 | macOS    | `~/Library/Application\ Support/Code/User/globalStorage/haskell.haskell/.ghcup` |
 | Windows  | `%APPDATA%\Code\User\globalStorage\haskell.haskell\ghcup`                       |
 | Linux    | `$HOME/.config/Code/User/globalStorage/haskell.haskell/.ghcup`                  |
 
-If you want to manage HLS yourself, set `haskell.manageHLS` to `false` and make sure HLS is in your PATH
-or set `haskell.serverExecutablePath` to a valid executable.
-
-You can also tell HLS to use your system provided ghcup by setting `haskell.useSystemGHCup` to `true` (default is `false`).
+If you want to manage HLS yourself, set `haskell.manageHLS` to `PATH` and make sure HLS is in your PATH
+or set `haskell.serverExecutablePath` (overrides all other settings) to a valid executable.
 
 If you need to set mirrors for ghcup download info, check the settings `haskell.metadataURL` and `haskell.releasesURL`.
 

package.json

@@ -159,9 +159,19 @@
         },
         "haskell.manageHLS": {
           "scope": "resource",
-          "type": "boolean",
-          "default": true,
-          "description": "Let this extension manage required HLS versions via ghcup."
+          "type": "string",
+          "default": null,
+          "description": "How to manage/find HLS installations.",
+          "enum": [
+            "system-ghcup",
+            "internal-ghcup",
+            "PATH"
+          ],
+          "enumDescriptions": [
+            "Will use a user-wide installation of ghcup (usually in '~/.ghcup') to manage HLS automatically",
+            "Will use an internal installation of ghcup to manage HLS automatically, to avoid interfering with system ghcup",
+            "Discovers HLS executables in system PATH"
+          ]
         },
         "haskell.useSystemGHCup": {
           "scope": "resource",

src/commands/importIdentifier.ts

@@ -9,25 +9,27 @@ import { CommandNames } from './constants';
 const askHoogle = async (variable: string): Promise<any> => {
   return await request({
     url: `https://hoogle.haskell.org/?hoogle=${variable}&scope=set%3Astackage&mode=json`,
-    json: true
+    json: true,
   }).promise();
 };
 
-const withCache = <T, U>(theCache: LRU.Cache<T, U>, f: (a: T) => U) => (a: T) => {
-  const maybeB = theCache.get(a);
-  if (maybeB) {
-    return maybeB;
-  } else {
-    const b = f(a);
-    theCache.set(a, b);
-    return b;
-  }
-};
+const withCache =
+  <T, U>(theCache: LRU.Cache<T, U>, f: (a: T) => U) =>
+  (a: T) => {
+    const maybeB = theCache.get(a);
+    if (maybeB) {
+      return maybeB;
+    } else {
+      const b = f(a);
+      theCache.set(a, b);
+      return b;
+    }
+  };
 
 const cache: LRU.Cache<string, Promise<any>> = LRU({
   // 1 MB
   max: 1000 * 1000,
-  length: (r: any) => JSON.stringify(r).length
+  length: (r: any) => JSON.stringify(r).length,
 });
 
 const askHoogleCached = withCache(cache, askHoogle);
@@ -42,14 +44,14 @@ const doImport = async (arg: { mod: string; package: string }): Promise<void> =>
   const edit = new vscode.WorkspaceEdit();
 
   const lines = document.getText().split('\n');
-  const moduleLine = lines.findIndex(line => {
+  const moduleLine = lines.findIndex((line) => {
     const lineTrimmed = line.trim();
     return lineTrimmed === 'where' || lineTrimmed.endsWith(' where') || lineTrimmed.endsWith(')where');
   });
-  const revInputLine = lines.reverse().findIndex(l => l.startsWith('import'));
+  const revInputLine = lines.reverse().findIndex((l) => l.startsWith('import'));
   const nextInputLine = revInputLine !== -1 ? lines.length - 1 - revInputLine : moduleLine === -1 ? 0 : moduleLine + 1;
 
-  if (!lines.some(line => new RegExp('^import.*' + escapeRegExp(arg.mod)).test(line))) {
+  if (!lines.some((line) => new RegExp('^import.*' + escapeRegExp(arg.mod)).test(line))) {
     edit.insert(document.uri, new vscode.Position(nextInputLine, 0), 'import ' + arg.mod + '\n');
   }
 
@@ -99,11 +101,13 @@ export namespace ImportIdentifier {
       const response: any[] = await askHoogleCached(editor.document.getText(identifierRange));
 
       const choice = await vscode.window.showQuickPick(
-        response.filter(result => result.module.name).map(result => ({
-          result,
-          label: result.package.name,
-          description: result.module.name + ' -- ' + (cheerio.load as any)(result.item, { xml: {} }).text()
-        }))
+        response
+          .filter((result) => result.module.name)
+          .map((result) => ({
+            result,
+            label: result.package.name,
+            description: result.module.name + ' -- ' + (cheerio.load as any)(result.item, { xml: {} }).text(),
+          }))
       );
 
       if (!choice) {

src/extension.ts

@@ -1,6 +1,7 @@
 'use strict';
 import * as path from 'path';
 import {
+  env,
   commands,
   ExtensionContext,
   OutputChannel,
@@ -22,7 +23,7 @@ import {
 import { CommandNames } from './commands/constants';
 import { ImportIdentifier } from './commands/importIdentifier';
 import { DocsBrowser } from './docsBrowser';
-import { addPathToProcessPath, findHaskellLanguageServer, IEnvVars } from './hlsBinaries';
+import { MissingToolError, addPathToProcessPath, findHaskellLanguageServer, IEnvVars } from './hlsBinaries';
 import { expandHomeDir, ExtensionLogger } from './utils';
 
 // The current map of documents & folders to language servers.
@@ -153,7 +154,16 @@ async function activateServerForFolder(context: ExtensionContext, uri: Uri, fold
       return;
     }
   } catch (e) {
-    if (e instanceof Error) {
+    if (e instanceof MissingToolError) {
+      const link = e.installLink();
+      if (link) {
+        if (await window.showErrorMessage(e.message, `Install ${e.tool}`)) {
+          env.openExternal(link);
+        }
+      } else {
+        await window.showErrorMessage(e.message);
+      }
+    } else if (e instanceof Error) {
       logger.error(`Error getting the server executable: ${e.message}`);
       window.showErrorMessage(e.message);
     }
@@ -188,11 +198,11 @@ async function activateServerForFolder(context: ExtensionContext, uri: Uri, fold
 
   let serverEnvironment: IEnvVars = workspace.getConfiguration('haskell', uri).serverEnvironment;
   if (addInternalServerPath !== undefined) {
-      const newPath = addPathToProcessPath(addInternalServerPath);
-      serverEnvironment = {
-        PATH: newPath,
-        ... serverEnvironment
-      };
+    const newPath = addPathToProcessPath(addInternalServerPath);
+    serverEnvironment = {
+      PATH: newPath,
+      ...serverEnvironment,
+    };
   }
   const exeOptions: ExecutableOptions = {
     cwd: folder ? undefined : path.dirname(uri.fsPath),