Merge branch 'main' into feat/rustaceanvim

2026-06-10 15:10:04 +00:00 · 2026-06-05 04:08:05 +01:00 · 2026-06-05 04:08:05 +01:00 · 72d36ba94e
commit 72d36ba94e
parent ad13549beb ab4b268efc
9 changed files with 311 additions and 103 deletions
--- a/docs/manual/release-notes/rl-0.9.md
+++ b/docs/manual/release-notes/rl-0.9.md
@ -122,6 +122,11 @@
  module provides jsx/tsx support. This is a step of cleaning up the Typescript
  module for the future.

+[dathegreat](https://github.com/dathegreat):
+
+- Haskell LSP now defaults to haskell-language-server, haskell-tools based LSP
+  support is moved to `vim.languages.haskell.extensions.haskell-tools`
+
 [CaueAnjos](https://github.com/caueanjos)

 - Renamed `roslyn_ls` to `roslyn-ls`
@ -135,6 +140,11 @@

 ## Changelog {#sec-release-0-9-changelog}

+[bovf](https://github.com/bovf):
+
+- Removed the deprecated `system_open` setup option from `nvim-tree.lua` to
+  avoid startup warnings now that upstream uses `vim.ui.open()`.
+
 [ErinaYip](https://github.com/ErinaYip):

 - Fixed and updated `lualine` options:
@ -218,6 +228,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
@ -317,6 +334,8 @@

 - Add `emmet-ls` to the supported LSPs for all languages it supports.

+- Added `phpantom` LSP preset and into `languages.php`.
+
 - Added {option}`vim.treesitter.queries` to support adding custom queries.

 - Added injections for `query = '' ... ''` as `query` and `mkLualine '' ... ''`,
@ -505,6 +524,7 @@ https://github.com/gorbit99/codewindow.nvim
 [horriblename](https://github.com/horriblename):

 - Ignore terminals by default in spell-checking
+- Add default error filter to lsp-signature that prevents error spam.

 [poz](https://poz.pet):

--- a/modules/extra/deprecations.nix
+++ b/modules/extra/deprecations.nix
@ -379,6 +379,16 @@ in {
      (mkRenamedOptionModule ["vim" "languages" "typescript" "treesitter" "tsxPackage"] ["vim" "languages" "tsx" "treesitter" "package"])
    ]

+    # 2026-06-02
+    [
+      (mkRemovedOptionModule ["vim" "filetree" "nvimTree" "systemOpen" "args"] ''
+        nvim-tree.lua removed system_open and now uses Neovim's vim.ui.open().
+      '')
+      (mkRemovedOptionModule ["vim" "filetree" "nvimTree" "systemOpen" "cmd"] ''
+        nvim-tree.lua removed system_open and now uses Neovim's vim.ui.open().
+      '')
+    ]
+    
    # 2026-06-05
    [
      (mkRemovedLspPackage "rust")
--- a/modules/plugins/filetree/nvimtree/nvimtree.nix
+++ b/modules/plugins/filetree/nvimtree/nvimtree.nix
@ -28,10 +28,6 @@
    reloadOnBufEnter = "reload_on_buf_enter";
    respectBufCwd = "respect_buf_cwd";
    hijackDirectories = "hijack_directories";
-    systemOpen = {
-      args = "args";
-      cmd = "cmd";
-    };
    diagnostics = "diagnostics";
    git = {
      enable = "enable";
@ -228,25 +224,6 @@ in {
        };
      };

-      system_open = {
-        args = mkOption {
-          default = [];
-          description = "Optional argument list.";
-          type = listOf str;
-        };
-
-        cmd = mkOption {
-          default =
-            if pkgs.stdenv.isDarwin
-            then "open"
-            else if pkgs.stdenv.isLinux
-            then "${pkgs.xdg-utils}/bin/xdg-open"
-            else throw "NvimTree: No default system open command for this platform, please set `vim.filetree.nvimTree.systemOpen.cmd`";
-          description = "The open command itself";
-          type = str;
-        };
-      };
-
      diagnostics = mkOption {
        description = ''
          Show LSP and COC diagnostics in the signcolumn
--- a/modules/plugins/languages/haskell.nix
+++ b/modules/plugins/languages/haskell.nix
@ -1,66 +1,40 @@
 {
  config,
  lib,
+  options,
  pkgs,
  ...
 }: let
-  inherit (builtins) isList attrNames;
-  inherit (lib.types) either package enum listOf str;
+  inherit (builtins) attrNames;
+  inherit (lib) genAttrs;
+  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;
-  inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAfter;
+  inherit (config.vim.lib) mkMappingOption;
  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"];
-  servers = {
-    hls = {
-      enable = false;
-      cmd = [(getExe' pkgs.haskellPackages.haskell-language-server "haskell-language-server-wrapper") "--lsp"];
-      filetypes = ["haskell" "lhaskell"];
-      on_attach =
-        mkLuaInline
-        /*
-        lua
-        */
-        ''
-          function(client, bufnr)
-              local ht = require("haskell-tools")
-              local opts = { noremap = true, silent = true, buffer = bufnr }
-              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";
-        };
-      };
-    };
+  defaultServers = ["haskell-language-server"];
+  servers = ["haskell-language-server"];
+
+  defaultFormat = ["ormolu"];
+  formats = {
+    ormolu = {command = getExe haskellPackages.ormolu;};
+    fourmolu = {command = getExe haskellPackages.fourmolu;};
+    stylish-haskell = {command = getExe haskellPackages.stylish-haskell;};
+    floskell = {command = getExe haskellPackages.floskell;};
+  };
+
+  defaultCabalFormat = ["cabal-fmt"];
+  cabalFormats = {
+    cabal-fmt = {command = getExe haskellPackages.cabal-fmt;};
  };
 in {
  options.vim.languages.haskell = {
@ -84,12 +58,32 @@ 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";
+      };
+
+      cabalFormatters = mkOption {
+        type = listOf (enum (attrNames cabalFormats));
+        default = defaultCabalFormat;
+        description = "Cabal file formatter to use";
+      };
+    };
+
    dap = {
      enable =
        mkEnableOption "DAP support for Haskell"
@ -103,9 +97,108 @@ 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 = [
+                (getExe (pkgs.symlinkJoin {
+                  name = "haskell-language-server-wrapper";
+                  paths = [pkgs.haskellPackages.haskell-language-server];
+                  meta.mainProgram = "haskell-language-server-wrapper";
+                  buildInputs = [pkgs.makeBinaryWrapper];
+                  # wrap HLS-wrapper so it can find the actual binary
+                  postBuild = ''
+                    wrapProgram $out/bin/haskell-language-server-wrapper \
+                      --prefix PATH : ${haskellPackages.haskell-language-server}/bin
+                  '';
+                }))
+                "--lsp"
+              ];
+              description = "Command for haskell-language-server.";
+            };
+
+            on_attach = mkOption {
+              type = nullOr luaInline;
+              description = "Function to run when HLS is attached. When null, mappings from the mappings option are used.";
+              default = let
+                htCfg = cfg.extensions.haskell-tools;
+                keymapDefinitions = options.vim.languages.haskell.extensions.haskell-tools.mappings;
+                mappings = addDescriptionsToMappings htCfg.mappings keymapDefinitions;
+                mkBinding = binding: action:
+                  if binding.value != null
+                  then "vim.keymap.set('n', ${toLuaObject binding.value}, ${action}, {buffer=bufnr, noremap=true, silent=true, desc=${toLuaObject binding.description}})"
+                  else "";
+              in
+                mkLuaInline ''
+                  function(client, bufnr)
+                    local ht = require("haskell-tools")
+                    ${mkBinding mappings.codeLensRun "vim.lsp.codelens.run"}
+                    ${mkBinding mappings.hoogleSignature "ht.hoogle.hoogle_signature"}
+                    ${mkBinding mappings.evalAll "ht.lsp.buf_eval_all"}
+                    ${mkBinding mappings.replToggle "function() vim.cmd('Haskell repl toggle') end"}
+                    ${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
+                '';
+              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 +206,50 @@ 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;
+            cabal = cfg.format.cabalFormatters;
+          };
+          formatters = mkMerge [
+            (
+              mapListToAttrs
+              (name: {
+                inherit name;
+                value = formats.${name};
+              })
+              cfg.format.type
+            )
+            (
+              mapListToAttrs
+              (name: {
+                inherit name;
+                value = cabalFormats.${name};
+              })
+              cfg.format.cabalFormatters
+            )
+          ];
+        };
+      };
+    })
+
+    (mkIf cfg.extensions.haskell-tools.enable {
      vim = {
        startPlugins = ["haskell-tools-nvim"];
-        luaConfigRC.haskell-tools-nvim =
-          entryAfter
-          ["lsp-servers"]
-          ''
-            vim.g.haskell_tools = {
-            ${optionalString cfg.lsp.enable ''
-              -- LSP
-              tools = {
-                hover = {
-                  enable = true,
-                },
-              },
-              hls = ${toLuaObject servers.hls},
-            ''}
-            ${optionalString cfg.dap.enable ''
-              dap = {
-                cmd = ${
-                if isList cfg.dap.package
-                then toLuaObject cfg.dap.package
-                else ''{"${cfg.dap.package}/bin/haskell-debug-adapter"}''
-              },
-              },
-            ''}
-            }
-          '';
+        globals.haskell_tools = cfg.extensions.haskell-tools.setupOpts;
      };
    })
  ]);
--- a/modules/plugins/languages/php.nix
+++ b/modules/plugins/languages/php.nix
@ -17,7 +17,7 @@
  cfg = config.vim.languages.php;

  defaultServers = ["phpactor"];
-  servers = ["phpactor" "phan" "intelephense"];
+  servers = ["phpactor" "phan" "intelephense" "phpantom"];

  defaultFormat = ["php_cs_fixer"];
  formats = {
--- a/modules/plugins/lsp/lsp-signature/lsp-signature.nix
+++ b/modules/plugins/lsp/lsp-signature/lsp-signature.nix
@ -1,11 +1,40 @@
 {lib, ...}: let
-  inherit (lib.options) mkEnableOption;
-  inherit (lib.nvim.types) mkPluginSetupOption;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.nvim.types) mkPluginSetupOption luaInline;
+  inherit (lib.generators) mkLuaInline;
 in {
  options.vim.lsp = {
    lspSignature = {
      enable = mkEnableOption "lsp signature viewer";
-      setupOpts = mkPluginSetupOption "lsp-signature" {};
+      setupOpts = mkPluginSetupOption "lsp-signature" {
+        ignore_error = mkOption {
+          type = luaInline;
+          description = "Custom error filter.";
+          # https://github.com/NotAShelf/nvf/pull/1545#discussion_r3253920092
+          defaultText = "Filters out errors that occur more than once, per client";
+          default = mkLuaInline ''
+            function(err, ctx, config)
+              if ctx and ctx.client_id then
+                -- upstream default
+                local client = vim.lsp.get_client_by_id(ctx.client_id)
+                if client and vim.tbl_contains({"rust-analyzer", "clangd"}, client.name) then
+                  return true
+                end
+
+                -- prevents error spam
+                _LSP_SIG_IGNORE_ERR = _LSP_SIG_IGNORE_ERR or {}
+                _LSP_SIG_IGNORE_ERR[ctx.client_id] = _LSP_SIG_IGNORE_ERR[ctx.client_id]
+                  or {}
+                if _LSP_SIG_IGNORE_ERR[ctx.client_id][err.code] then
+                  return true
+                end
+
+                _LSP_SIG_IGNORE_ERR[ctx.client_id][err.code] = true
+              end
+            end
+          '';
+        };
+      };
    };
  };
 }
--- a/modules/plugins/lsp/presets/default.nix
+++ b/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
@ -47,6 +48,7 @@
    ./openscad-lsp.nix
    ./phan.nix
    ./phpactor.nix
+    ./phpantom.nix
    ./pyrefly.nix
    ./pyright.nix
    ./python-lsp-server.nix
--- a/modules/plugins/lsp/presets/haskell-language-server.nix
+++ b/modules/plugins/lsp/presets/haskell-language-server.nix
@ -0,0 +1,37 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe';
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.haskell-language-server;
+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];
+          # wrap HLS-wrapper so it can find the actual binary
+          postBuild = ''
+            wrapProgram $out/bin/haskell-language-server-wrapper \
+              --prefix PATH : ${pkgs.haskellPackages.haskell-language-server}/bin
+          '';
+        }) "haskell-language-server-wrapper")
+        "--lsp"
+      ];
+      root_markers = ["hie.yaml" "stack.yaml" "cabal.project" "*.cabal" "package.yaml"];
+    };
+  };
+}
--- a/modules/plugins/lsp/presets/phpantom.nix
+++ b/modules/plugins/lsp/presets/phpantom.nix
@ -0,0 +1,24 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf;
+  inherit (lib.nvim.types) mkLspPresetEnableOption;
+
+  cfg = config.vim.lsp.presets.phpantom;
+in {
+  options.vim.lsp.presets.phpantom = {
+    enable = mkLspPresetEnableOption "phpantom" "PHPantom" [];
+  };
+
+  config = mkIf cfg.enable {
+    vim.lsp.servers.phpantom = {
+      enable = true;
+      cmd = [(getExe pkgs.phpantom)];
+      root_markers = [".phpantom.toml" "composer.json" ".php-version" ".git"];
+    };
+  };
+}