Merge 9361263373 into 3997bd4db0

docs/manual/release-notes/rl-0.9.md

@@ -39,6 +39,9 @@
   `setupOpts.strategies.chat.adapter`, rename them to
   `setupOpts.interactions.chat.adapter`.
 
+- Haskell LSP now defaults to haskell-language-server, haskell-tools based LSP
+  support is moved to `vim.languages.haskell.extensions.haskell-tools`
+
 [Snoweuph](https://github.com/snoweuph)
 
 - Remove `mind.nvim`. This plugin doesn't exist anymore. The original author
@@ -201,6 +204,13 @@
 - Updated nix language plugin to use pkgs.nixfmt instead of
   pkgs.nixfmt-rfc-style
 
+[dathegreat](https://github.com/dathegreat):
+
+- Fixed invalid keys in the haskell-tools configuration
+- Split haskell configuration into `lsp/presets/haskell-language-server.nix` and
+  `languages/haskell.nix`
+- Made the haskell LSP and formatter configurable
+
 [alfarel](https://github.com/alfarelcynthesis):
 
 [obsidian.nvim]: https://github.com/obsidian-nvim/obsidian.nvim

modules/plugins/languages/haskell.nix

@@ -1,66 +1,41 @@
 {
   config,
   lib,
+  options,
   pkgs,
   ...
 }: let
-  inherit (builtins) isList attrNames;
+  inherit (builtins) attrNames;
-  inherit (lib.types) either package enum listOf str;
+  inherit (lib) genAttrs optional;
+  inherit (lib.types) either package enum listOf str nullOr attrsOf anything;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
-  inherit (lib.strings) optionalString;
+  inherit (lib.modules) mkIf mkMerge mkDefault;
-  inherit (lib.modules) mkIf mkMerge;
+  inherit (config.vim.lib) mkMappingOption;
-  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.meta) getExe';
+  inherit (lib.nvim.binds) addDescriptionsToMappings;
+  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption luaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
   inherit (pkgs) haskellPackages;
 
   cfg = config.vim.languages.haskell;
 
-  defaultServers = ["hls"];
+  defaultServers = ["haskell-language-server"];
-  servers = {
+  servers = ["haskell-language-server"];
-    hls = {
+
-      enable = false;
+  defaultFormat = ["ormolu"];
-      cmd = [(getExe' pkgs.haskellPackages.haskell-language-server "haskell-language-server-wrapper") "--lsp"];
+  formats = {
-      filetypes = ["haskell" "lhaskell"];
+    ormolu = {command = getExe haskellPackages.ormolu;};
-      on_attach =
+    fourmolu = {command = getExe haskellPackages.fourmolu;};
-        mkLuaInline
+    stylish-haskell = {command = getExe haskellPackages.stylish-haskell;};
-        /*
+    floskell = {command = getExe haskellPackages.floskell;};
-        lua
+  };
-        */
+
-        ''
+  defaultCabalFormat = "cabal-fmt";
-          function(client, bufnr)
+  cabalFormats = {
-              local ht = require("haskell-tools")
+    cabal-fmt = haskellPackages.cabal-fmt;
-              local opts = { noremap = true, silent = true, buffer = bufnr }
+    cabal-gild = haskellPackages.cabal-gild;
-              vim.keymap.set('n', '<localleader>cl', vim.lsp.codelens.run, opts)
-              vim.keymap.set('n', '<localleader>hs', ht.hoogle.hoogle_signature, opts)
-              vim.keymap.set('n', '<localleader>ea', ht.lsp.buf_eval_all, opts)
-              vim.keymap.set('n', '<localleader>rr', ht.repl.toggle, opts)
-              vim.keymap.set('n', '<localleader>rf', function()
-                ht.repl.toggle(vim.api.nvim_buf_get_name(0))
-              end, opts)
-              vim.keymap.set('n', '<localleader>rq', ht.repl.quit, opts)
-            end
-        '';
-      root_dir =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(bufnr, on_dir)
-            local fname = vim.api.nvim_buf_get_name(bufnr)
-            on_dir(util.root_pattern('hie.yaml', 'stack.yaml', 'cabal.project', '*.cabal', 'package.yaml')(fname))
-          end
-        '';
-      settings = {
-        haskell = {
-          formattingProvider = "ormolu";
-          cabalFormattingProvider = "cabal-fmt";
-        };
-      };
-    };
   };
 in {
   options.vim.languages.haskell = {
@@ -84,12 +59,40 @@ in {
           defaultText = literalExpression "config.vim.lsp.enable";
         };
       servers = mkOption {
-        type = listOf (enum (attrNames servers));
+        type = listOf (enum servers);
         default = defaultServers;
         description = "Haskell LSP server to use";
       };
     };
 
+    format = {
+      enable =
+        mkEnableOption "Haskell formatting"
+        // {
+          default = config.vim.languages.enableFormat;
+          defaultText = literalExpression "config.vim.languages.enableFormat";
+        };
+      type = mkOption {
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+        description = "Haskell formatter to use";
+      };
+    };
+
+    cabalFormat = {
+      enable =
+        mkEnableOption "Haskell cabal file formatting via HLS"
+        // {
+          default = config.vim.languages.enableFormat;
+          defaultText = literalExpression "config.vim.languages.enableFormat";
+        };
+      type = mkOption {
+        type = enum (attrNames cabalFormats);
+        default = defaultCabalFormat;
+        description = "Haskell cabal file formatter to use via HLS";
+      };
+    };
+
     dap = {
       enable =
         mkEnableOption "DAP support for Haskell"
@@ -103,9 +106,88 @@ in {
         description = "Haskell DAP package or command to run the Haskell DAP";
       };
     };
+
+    extensions = {
+      haskell-tools = {
+        enable = mkEnableOption "haskell-tools.nvim";
+
+        mappings = {
+          codeLensRun = mkMappingOption "Run code lens [haskell-tools.nvim]" "<localleader>cl";
+          hoogleSignature = mkMappingOption "Hoogle signature [haskell-tools.nvim]" "<localleader>hs";
+          evalAll = mkMappingOption "Evaluate all [haskell-tools.nvim]" "<localleader>ea";
+          replToggle = mkMappingOption "Toggle REPL [haskell-tools.nvim]" "<localleader>rr";
+          replToggleFile = mkMappingOption "Toggle REPL for current file [haskell-tools.nvim]" "<localleader>rf";
+          replQuit = mkMappingOption "Quit REPL [haskell-tools.nvim]" "<localleader>rq";
+        };
+
+        setupOpts = mkPluginSetupOption "haskell-tools.nvim" {
+          hls = {
+            cmd = mkOption {
+              type = nullOr (listOf str);
+              default = [
+                "${pkgs.haskellPackages.haskell-language-server}/bin/haskell-language-server-wrapper"
+                "--lsp"
+              ];
+              description = ''
+                Command for haskell-language-server.
+
+                > [!NOTE]
+                >
+                > Since HLS is very sensitive about the GHC version, there's a
+                > very high chance that the default HLS we use is not
+                > compatible with your project. It is highly recommended to set
+                > this option to `null` and install HLS separately in a
+                > `devShell`.
+              '';
+            };
+            on_attach = mkOption {
+              type = nullOr luaInline;
+              description = "Function to run when HLS is attached. When null, mappings from the mappings option are used.";
+              default = null;
+              defaultText = literalExpression "Generated from vim.languages.haskell.extensions.haskell-tools.mappings";
+            };
+
+            settings = mkOption {
+              type = nullOr (attrsOf anything);
+              default = null;
+              description = "Settings passed to HLS. When null, generated from vim.languages.haskell.cabalFormat.";
+            };
+          };
+
+          dap = {
+            cmd = mkOption {
+              type = nullOr (listOf str);
+              default = null;
+              description = "Debug adapter command";
+            };
+          };
+        };
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
+    {
+      assertions = [
+        {
+          assertion = !(cfg.lsp.enable && cfg.extensions.haskell-tools.enable);
+          message = ''
+            vim.languages.haskell: haskell-tools.nvim manages the LSP directly and
+            is incompatible with vim.languages.haskell.lsp.enable. Disable one or
+            the other. See https://github.com/mrcjkb/haskell-tools.nvim/blob/fe9ed6e6adfa6311e06c84569d8536190f172030/doc/haskell-tools.txt#L22
+          '';
+        }
+        {
+          assertion = !(cfg.dap.enable && !cfg.extensions.haskell-tools.enable);
+          message = ''
+            vim.languages.haskell: DAP support requires haskell-tools.nvim, which
+            handles adapter registration and launch configuration discovery.
+            Enable vim.languages.haskell.extensions.haskell-tools to use DAP.
+          '';
+        }
+      ];
+    }
+
     (mkIf cfg.treesitter.enable {
       vim.treesitter = {
         enable = true;
@@ -113,34 +195,68 @@ in {
       };
     })
 
-    (mkIf (cfg.dap.enable || cfg.lsp.enable) {
+    (mkIf cfg.lsp.enable {
+      vim.lsp = {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
+        servers = genAttrs cfg.lsp.servers (_: {
+          filetypes = ["haskell" "lhaskell"];
+        });
+      };
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft = {
+            haskell = cfg.format.type;
+            lhaskell = cfg.format.type;
+          };
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
+
+    (mkIf cfg.extensions.haskell-tools.enable {
       vim = {
+        extraPackages = optional cfg.cabalFormat.enable cabalFormats.${cfg.cabalFormat.type};
         startPlugins = ["haskell-tools-nvim"];
-        luaConfigRC.haskell-tools-nvim =
+        globals.haskell_tools = cfg.extensions.haskell-tools.setupOpts;
-          entryAfter
+        languages.haskell.extensions.haskell-tools.setupOpts = {
-          ["lsp-servers"]
+          hls = {
-          ''
+            on_attach = let
-            vim.g.haskell_tools = {
+              htCfg = cfg.extensions.haskell-tools;
-            ${optionalString cfg.lsp.enable ''
+              keymapDefinitions = options.vim.languages.haskell.extensions.haskell-tools.mappings;
-              -- LSP
+              mappings = addDescriptionsToMappings htCfg.mappings keymapDefinitions;
-              tools = {
+              mkBinding = binding: action:
-                hover = {
+                if binding.value != null
-                  enable = true,
+                then "vim.keymap.set('n', ${toLuaObject binding.value}, ${action}, {buffer=bufnr, noremap=true, silent=true, desc=${toLuaObject binding.description}})"
-                },
+                else "";
-              },
+            in
-              hls = ${toLuaObject servers.hls},
+              mkLuaInline ''
-            ''}
+                function(client, bufnr)
-            ${optionalString cfg.dap.enable ''
+                  local ht = require("haskell-tools")
-              dap = {
+                  ${mkBinding mappings.codeLensRun "vim.lsp.codelens.run"}
-                cmd = ${
+                  ${mkBinding mappings.hoogleSignature "ht.hoogle.hoogle_signature"}
-                if isList cfg.dap.package
+                  ${mkBinding mappings.evalAll "ht.lsp.buf_eval_all"}
-                then toLuaObject cfg.dap.package
+                  ${mkBinding mappings.replToggle "function() vim.cmd('Haskell repl toggle') end"}
-                else ''{"${cfg.dap.package}/bin/haskell-debug-adapter"}''
+                  ${mkBinding mappings.replToggleFile "function() vim.cmd('Haskell repl toggle ' .. vim.api.nvim_buf_get_name(0)) end"}
-              },
+                  ${mkBinding mappings.replQuit "function() vim.cmd('Haskell repl quit') end"}
-              },
+                end
-            ''}
+              '';
-            }
+            settings = mkIf cfg.cabalFormat.enable (mkDefault {
-          '';
+              haskell = {
+                cabalFormattingProvider = cfg.cabalFormat.type;
+                plugin.${cfg.cabalFormat.type}.config.path = getExe cabalFormats.${cfg.cabalFormat.type};
+              };
+            });
+          };
+        };
       };
     })
   ]);

modules/plugins/lsp/presets/default.nix

@@ -24,6 +24,7 @@
     ./gopls.nix
     ./harper.nix
     ./helm-ls.nix
+    ./haskell-language-server.nix
     ./intelephense.nix
     ./jdt-language-server.nix
     ./jinja-lsp.nix

modules/plugins/lsp/presets/haskell-language-server.nix

@@ -0,0 +1,45 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe getExe';
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.haskell-language-server;
+  cabalFmtCfg = config.vim.languages.haskell.cabalFormat;
+  cabalFormats = {
+    cabal-fmt = pkgs.haskellPackages.cabal-fmt;
+    cabal-gild = pkgs.haskellPackages.cabal-gild;
+  };
+in {
+  options.vim.lsp.presets.haskell-language-server = {
+    enable = mkLspPresetEnableOption "haskell-language-server" "Haskell" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.haskell-language-server = {
+      enable = true;
+      cmd = [
+        (getExe' (pkgs.symlinkJoin {
+          name = "haskell-language-server-wrapper";
+          paths = [pkgs.haskellPackages.haskell-language-server];
+          meta.mainProgram = "haskell-language-server-wrapper";
+          buildInputs = [pkgs.makeBinaryWrapper];
+        }) "haskell-language-server-wrapper")
+        "--lsp"
+      ];
+      root_markers = ["hie.yaml" "stack.yaml" "cabal.project" "*.cabal" "package.yaml"];
+      settings = mkIf cabalFmtCfg.enable {
+        haskell = {
+          cabalFormattingProvider = cabalFmtCfg.type;
+          # This option is undocumented in the haskell-language-server docs, but it does exist in the plugin API
+          # https://github.com/haskell/haskell-language-server/blob/f158128ec034bec1667c440262641086bbb4d359/plugins/hls-cabal-fmt-plugin/src/Ide/Plugin/CabalFmt.hs#L51
+          plugin.${cabalFmtCfg.type}.config.path = getExe cabalFormats.${cabalFmtCfg.type};
+        };
+      };
+    };
+  };
+}