Merge pull request #913 from sjcobb2022/language-overhaul

languages: overhaul

configuration.nix

@@ -84,6 +84,7 @@ isMaximal: {
       ocaml.enable = false;
       elixir.enable = false;
       haskell.enable = false;
+      hcl.enable = false;
       ruby.enable = false;
       fsharp.enable = false;
 

lib/languages.nix

@@ -1,7 +1,7 @@
 {lib}: let
   inherit (builtins) isString getAttr;
   inherit (lib.options) mkOption;
-  inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr;
+  inherit (lib.types) listOf bool str submodule attrsOf anything either nullOr oneOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) luaInline;
 in {
@@ -62,7 +62,7 @@ in {
       };
 
       cmd = mkOption {
-        type = nullOr (listOf str);
+        type = nullOr (either luaInline (listOf str));
         default = null;
         description = "Command used to start the LSP server";
       };

modules/neovim/init/default.nix

@@ -8,5 +8,6 @@
     ./highlight.nix
     ./lsp.nix
     ./spellcheck.nix
+    ./util.nix
   ];
 }

modules/neovim/init/lsp.nix

@@ -16,6 +16,7 @@
 
   cfg = config.vim.lsp;
 
+  # TODO: lspConfigurations filter on enabledServers instead of cfg.servers?
   lspConfigurations =
     mapAttrsToList (
       name: value: ''

modules/neovim/init/util.nix

@@ -0,0 +1,178 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (builtins) filter;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.dag) entryBefore;
+
+  cfg = config.vim.lsp;
+in {
+  config = mkMerge [
+    (mkIf (cfg.servers != {}) {
+      vim.luaConfigRC.lsp-util =
+        entryBefore ["lsp-servers"]
+        /*
+        lua
+        */
+        ''
+          -- Port of nvim-lspconfig util
+          local util = { path = {} }
+
+          util.default_config = {
+            log_level = vim.lsp.protocol.MessageType.Warning,
+            message_level = vim.lsp.protocol.MessageType.Warning,
+            settings = vim.empty_dict(),
+            init_options = vim.empty_dict(),
+            handlers = {},
+            autostart = true,
+            capabilities = vim.lsp.protocol.make_client_capabilities(),
+          }
+
+          -- global on_setup hook
+          util.on_setup = nil
+
+          do
+            local validate = vim.validate
+            local api = vim.api
+            local lsp = vim.lsp
+            local nvim_eleven = vim.fn.has 'nvim-0.11' == 1
+
+            local iswin = vim.uv.os_uname().version:match 'Windows'
+
+            local function escape_wildcards(path)
+              return path:gsub('([%[%]%?%*])', '\\%1')
+            end
+
+            local function is_fs_root(path)
+              if iswin then
+                return path:match '^%a:$'
+              else
+                return path == '/'
+              end
+            end
+
+            local function traverse_parents(path, cb)
+              path = vim.uv.fs_realpath(path)
+              local dir = path
+              -- Just in case our algo is buggy, don't infinite loop.
+              for _ = 1, 100 do
+                dir = vim.fs.dirname(dir)
+                if not dir then
+                  return
+                end
+                -- If we can't ascend further, then stop looking.
+                if cb(dir, path) then
+                  return dir, path
+                end
+                if is_fs_root(dir) then
+                  break
+                end
+              end
+            end
+
+            util.root_pattern = function(...)
+              local patterns = util.tbl_flatten { ... }
+              return function(startpath)
+                startpath = util.strip_archive_subpath(startpath)
+                for _, pattern in ipairs(patterns) do
+                  local match = util.search_ancestors(startpath, function(path)
+                    for _, p in ipairs(vim.fn.glob(table.concat({ escape_wildcards(path), pattern }, '/'), true, true)) do
+                      if vim.uv.fs_stat(p) then
+                        return path
+                      end
+                    end
+                  end)
+
+                  if match ~= nil then
+                    return match
+                  end
+                end
+              end
+            end
+
+            util.root_markers_with_field = function(root_files, new_names, field, fname)
+              local path = vim.fn.fnamemodify(fname, ':h')
+              local found = vim.fs.find(new_names, { path = path, upward = true })
+
+              for _, f in ipairs(found or {}) do
+                -- Match the given `field`.
+                for line in io.lines(f) do
+                  if line:find(field) then
+                    root_files[#root_files + 1] = vim.fs.basename(f)
+                    break
+                  end
+                end
+              end
+
+              return root_files
+            end
+
+            util.insert_package_json = function(root_files, field, fname)
+              return util.root_markers_with_field(root_files, { 'package.json', 'package.json5' }, field, fname)
+            end
+
+            util.strip_archive_subpath = function(path)
+              -- Matches regex from zip.vim / tar.vim
+              path = vim.fn.substitute(path, 'zipfile://\\(.\\{-}\\)::[^\\\\].*$', '\\1', ''')
+              path = vim.fn.substitute(path, 'tarfile:\\(.\\{-}\\)::.*$', '\\1', ''')
+              return path
+            end
+
+            util.get_typescript_server_path = function(root_dir)
+              local project_roots = vim.fs.find('node_modules', { path = root_dir, upward = true, limit = math.huge })
+              for _, project_root in ipairs(project_roots) do
+                local typescript_path = project_root .. '/typescript'
+                local stat = vim.loop.fs_stat(typescript_path)
+                if stat and stat.type == 'directory' then
+                  return typescript_path .. '/lib'
+                end
+              end
+              return '''
+            end
+
+            util.search_ancestors = function(startpath, func)
+              if nvim_eleven then
+                validate('func', func, 'function')
+              end
+              if func(startpath) then
+                return startpath
+              end
+              local guard = 100
+              for path in vim.fs.parents(startpath) do
+                -- Prevent infinite recursion if our algorithm breaks
+                guard = guard - 1
+                if guard == 0 then
+                  return
+                end
+
+                if func(path) then
+                  return path
+                end
+              end
+            end
+
+            util.path.is_descendant = function(root, path)
+              if not path then
+                return false
+              end
+
+              local function cb(dir, _)
+                return dir == root
+              end
+
+              local dir, _ = traverse_parents(path, cb)
+
+              return dir == root
+            end
+
+            util.tbl_flatten = function(t)
+              --- @diagnostic disable-next-line:deprecated
+              return nvim_eleven and vim.iter(t):flatten(math.huge):totable() or vim.tbl_flatten(t)
+            end
+          end
+        '';
+    })
+  ];
+}

modules/plugins/languages/asm.nix

@@ -4,12 +4,24 @@
   lib,
   ...
 }: let
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) package;
+  inherit (lib.types) package enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.assembly;
+  defaultServers = ["asm-lsp"];
+  servers = {
+    asm-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.asm-lsp)];
+      filetypes = ["asm" "vmasm"];
+      root_markers = [".asm-lsp.toml" ".git"];
+    };
+  };
 in {
   options.vim.languages.assembly = {
     enable = mkEnableOption "Assembly support";
@@ -20,12 +32,11 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Assembly LSP support (asm-lsp)" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Assembly LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      package = mkOption {
+        type = listOf (enum (attrNames servers));
-        type = package;
+        default = defaultServers;
-        default = pkgs.asm-lsp;
+        description = "Assembly LSP server to use";
-        description = "asm-lsp package";
       };
     };
   };
@@ -36,14 +47,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.asm-lsp = ''
+        mapListToAttrs (n: {
-        lspconfig.asm_lsp.setup {
+          name = n;
-          capabilities = capabilities,
+          value = servers.${n};
-          on_attach = default_on_attach,
+        })
-          cmd = {"${cfg.lsp.package}/bin/asm-lsp"},
+        cfg.lsp.servers;
-        }
-      '';
     })
   ]);
 }

modules/plugins/languages/astro.nix

@@ -11,25 +11,34 @@
   inherit (lib.meta) getExe;
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.astro;
 
-  defaultServer = "astro";
+  defaultServers = ["astro"];
   servers = {
     astro = {
-      package = pkgs.astro-language-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.astro-language-server) "--stdio"];
-        lspconfig.astro.setup {
+      filetypes = ["astro"];
-          capabilities = capabilities,
+      root_markers = ["package.json" "tsconfig.json" "jsconfig.json" ".git"];
-          on_attach = attach_keymaps,
+      init_options = {
-          cmd = ${
+        typescript = {};
-          if isList cfg.lsp.package
+      };
-          then expToLua cfg.lsp.package
+      before_init =
-          else ''{"${cfg.lsp.package}/bin/astro-ls", "--stdio"}''
+        mkLuaInline
-        }
+        /*
-        }
+        lua
-      '';
+        */
+        ''
+          function(_, config)
+            if config.init_options and config.init_options.typescript and not config.init_options.typescript.tsdk then
+              config.init_options.typescript.tsdk = util.get_typescript_server_path(config.root_dir)
+            end
+          end
+        '';
     };
   };
 
@@ -81,34 +90,26 @@ in {
 
     lsp = {
       enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
+        default = defaultServers;
-        default = defaultServer;
         description = "Astro LSP server to use";
       };
-
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        example = ''[lib.getExe pkgs.astro-language-server "--minify" "--stdio"]'';
-        description = "Astro LSP server package, or the command to run as a list of strings";
-      };
     };
 
     format = {
       enable = mkEnableOption "Astro formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "Astro formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Astro formatter to use";
       };
 
       package = mkOption {
-        description = "Astro formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Astro formatter package";
       };
     };
 
@@ -130,8 +131,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.astro-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/bash.nix

@@ -10,26 +10,25 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
   inherit (lib.types) enum either package listOf str bool;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.types) diagnostics mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.bash;
 
-  defaultServer = "bash-ls";
+  defaultServers = ["bash-ls"];
   servers = {
     bash-ls = {
-      package = pkgs.bash-language-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.bash-language-server) "start"];
-        lspconfig.bashls.setup{
+      filetypes = ["bash" "sh"];
-          capabilities = capabilities;
+      root_markers = [".git"];
-          on_attach = default_on_attach;
+      settings = {
-          cmd = ${
+        basheIde = {
-          if isList cfg.lsp.package
+          globPattern = mkLuaInline "vim.env.GLOB_PATTERN or '*@(.sh|.inc|.bash|.command)'";
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/bash-language-server",  "start"}''
         };
-        }
+      };
-      '';
     };
   };
 
@@ -56,38 +55,30 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Bash LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Bash LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Bash LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "bash-language-server package, or the command to run as a list of strings";
-        example = literalExpression ''[lib.getExe pkgs.bash-language-server "start"]'';
-        type = either package (listOf str);
-        default = pkgs.bash-language-server;
       };
     };
 
     format = {
       enable = mkOption {
-        description = "Enable Bash formatting";
         type = bool;
         default = config.vim.languages.enableFormat;
+        description = "Enable Bash formatting";
       };
       type = mkOption {
-        description = "Bash formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Bash formatter to use";
       };
 
       package = mkOption {
-        description = "Bash formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Bash formatter package";
       };
     };
 
@@ -108,8 +99,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.bash-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/clojure.nix

@@ -4,15 +4,27 @@
   lib,
   ...
 }: let
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.lists) isList;
-  inherit (lib.types) either listOf package str;
+  inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.clojure;
+
+  defaultServers = ["clojure-lsp"];
+  servers = {
+    clojure-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.clojure-lsp)];
+      filetypes = ["clojure" "edn"];
+      root_markers = ["project.clj" "deps.edn" "build.boot" "shadow-cljs.edn" ".git" "bb.edn"];
+    };
+  };
 in {
   options.vim.languages.clojure = {
     enable = mkEnableOption "Clojure language support";
@@ -24,28 +36,22 @@ in {
 
     lsp = {
       enable = mkEnableOption "Clojure LSP support" // {default = config.vim.lsp.enable;};
-      package = mkOption {
+      servers = mkOption {
-        type = either package (listOf str);
+        type = listOf (enum (attrNames servers));
-        default = pkgs.clojure-lsp;
+        default = defaultServers;
-        description = "Clojure LSP";
+        description = "Clojure LSP server to use";
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.clojure-lsp = ''
+        mapListToAttrs (n: {
-        lspconfig.clojure_lsp.setup {
+          name = n;
-          capabilities = capabilities;
+          value = servers.${n};
-          on_attach = default_on_attach;
+        })
-          cmd = ${
+        cfg.lsp.servers;
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${getExe cfg.lsp.package}"}''
-        };
-        }
-      '';
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/dart.nix

@@ -6,6 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
   inherit (lib.trivial) boolToString;
   inherit (lib.lists) isList;
   inherit (lib.options) mkEnableOption mkOption;
@@ -14,26 +15,31 @@
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.dart;
   ftcfg = cfg.flutter-tools;
 
-  defaultServer = "dart";
+  defaultServers = ["dart"];
   servers = {
     dart = {
-      package = pkgs.dart;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.dart) "language-server" "--protocol=lsp"];
-        lspconfig.dartls.setup{
+      filetypes = ["dart"];
-          capabilities = capabilities;
+      root_markers = ["pubspec.yaml"];
-          on_attach=default_on_attach;
+      init_options = {
-          cmd = ${
+        onlyAnalyzeProjectsWithOpenFiles = true;
-          if isList cfg.lsp.package
+        suggestFromUnimportedLibraries = true;
-          then expToLua cfg.lsp.package
+        closingLabels = true;
-          else ''{"${cfg.lsp.package}/bin/dart", "language-server", "--protocol=lsp"}''
+        outline = true;
+        flutterOutline = true;
+      };
+      settings = {
+        dart = {
+          completeFunctionCalls = true;
+          showTodos = true;
         };
-          ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.dartOpts}"}
+      };
-        }
-      '';
     };
   };
 in {
@@ -46,23 +52,11 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Dart LSP support";
+      enable = mkEnableOption "Dart LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
+      servers = mkOption {
-        description = "The Dart LSP server to use";
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
+        default = defaultServers;
-        default = defaultServer;
+        description = "Dart LSP server to use";
-      };
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        description = "Dart LSP server package, or the command to run as a list of strings";
-      };
-
-      opts = mkOption {
-        type = nullOr str;
-        default = null;
-        description = "Options to pass to Dart LSP server";
       };
     };
 
@@ -131,19 +125,23 @@ in {
     };
   };
 
-  config.vim = mkIf cfg.enable (mkMerge [
+  config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.treesitter.enable {
-      treesitter.enable = true;
+      vim.treesitter.enable = true;
-      treesitter.grammars = [cfg.treesitter.package];
+      vim.treesitter.grammars = [cfg.treesitter.package];
     })
 
     (mkIf cfg.lsp.enable {
-      lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      lsp.lspconfig.sources.dart-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf ftcfg.enable {
-      startPlugins = [
+      vim.startPlugins = [
         (
           if ftcfg.enableNoResolvePatch
           then "flutter-tools-patched"
@@ -152,7 +150,7 @@ in {
         "plenary-nvim"
       ];
 
-      pluginRC.flutter-tools = entryAfter ["lsp-setup"] ''
+      vim.pluginRC.flutter-tools = entryAfter ["lsp-servers"] ''
         require('flutter-tools').setup {
           ${optionalString (ftcfg.flutterPackage != null) "flutter_path = \"${ftcfg.flutterPackage}/bin/flutter\","}
           lsp = {

modules/plugins/languages/elixir.nix

@@ -8,29 +8,37 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
   inherit (lib.types) enum either listOf package str;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.types) mkGrammarOption;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.elixir;
 
-  defaultServer = "elixirls";
+  defaultServers = ["elixirls"];
   servers = {
     elixirls = {
-      package = pkgs.elixir-ls;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.elixir-ls)];
-        -- elixirls setup
+      filetypes = ["elixir" "eelixir" "heex" "surface"];
-        lspconfig.elixirls.setup {
+      root_dir =
-          capabilities = capabilities,
+        mkLuaInline
-          on_attach = default_on_attach,
+        /*
-          cmd = ${
+        lua
-          if isList cfg.lsp.package
+        */
-          then expToLua cfg.lsp.package
+        ''
-          else ''{"${cfg.lsp.package}/bin/elixir-ls"}''
+          function(bufnr, on_dir)
-        }
+            local fname = vim.api.nvim_buf_get_name(bufnr)
-        }
+            local matches = vim.fs.find({ 'mix.exs' }, { upward = true, limit = 2, path = fname })
-      '';
+            local child_or_root_path, maybe_umbrella_path = unpack(matches)
+            local root_dir = vim.fs.dirname(maybe_umbrella_path or child_or_root_path)
+
+            on_dir(root_dir)
+          end
+        '';
     };
   };
 
@@ -54,18 +62,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Elixir LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Elixir LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -73,15 +73,15 @@ in {
       enable = mkEnableOption "Elixir formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "Elixir formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Elixir formatter to use";
       };
 
       package = mkOption {
-        description = "Elixir formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Elixir formatter package";
       };
     };
 
@@ -97,8 +97,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.elixir-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/gleam.nix

@@ -8,27 +8,21 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
   inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.gleam;
 
-  defaultServer = "gleam";
+  defaultServers = ["gleam"];
   servers = {
     gleam = {
-      package = pkgs.gleam;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.gleam) "lsp"];
-        lspconfig.gleam.setup{
+      filetypes = ["gleam"];
-          capabilities = capabilities,
+      root_markers = ["gleam.toml" ".git"];
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/gleam", "lsp"}''
-        }
-        }
-      '';
     };
   };
 in {
@@ -42,18 +36,11 @@ in {
 
     lsp = {
       enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
+        default = defaultServers;
-        default = defaultServer;
         description = "Gleam LSP server to use";
       };
-
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        description = "Gleam LSP server package, or the command to run as a list of strings";
-      };
     };
   };
 
@@ -64,8 +51,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.gleam-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/haskell.nix

@@ -4,17 +4,67 @@
   pkgs,
   ...
 }: let
-  inherit (builtins) isList;
+  inherit (builtins) isList attrNames;
-  inherit (lib.types) either package listOf str;
+  inherit (lib.types) either package enum listOf str;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.strings) optionalString;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.dag) entryAfter entryBefore;
   inherit (lib.nvim.lua) expToLua;
+  inherit (lib.meta) getExe';
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (pkgs) haskellPackages;
+  inherit (lib.nvim.lua) toLuaObject;
 
   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")
+              default_on_attach(client, bufnr, ht)
+              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 = "cabalfmt";
+        };
+      };
+    };
+  };
 in {
   options.vim.languages.haskell = {
     enable = mkEnableOption "Haskell support";
@@ -25,21 +75,20 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "LSP support for Haskell" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Haskell LSP support" // {default = config.vim.lsp.enable;};
-      package = mkOption {
+      servers = mkOption {
-        description = "Haskell LSP package or command to run the Haskell LSP";
+        type = listOf (enum (attrNames servers));
-        example = ''[ (lib.getExe pkgs.haskellPackages.haskell-language-server) "--debug" ]'';
+        default = defaultServers;
-        default = haskellPackages.haskell-language-server;
+        description = "Haskell LSP server to use";
-        type = either package (listOf str);
       };
     };
 
     dap = {
       enable = mkEnableOption "DAP support for Haskell" // {default = config.vim.languages.enableDAP;};
       package = mkOption {
-        description = "Haskell DAP package or command to run the Haskell DAP";
         default = haskellPackages.haskell-debug-adapter;
         type = either package (listOf str);
+        description = "Haskell DAP package or command to run the Haskell DAP";
       };
     };
   };
@@ -57,7 +106,7 @@ in {
         startPlugins = ["haskell-tools-nvim"];
         luaConfigRC.haskell-tools-nvim =
           entryAfter
-          ["lsp-setup"]
+          ["lsp-servers"]
           ''
             vim.g.haskell_tools = {
             ${optionalString cfg.lsp.enable ''
@@ -67,25 +116,7 @@ in {
                   enable = true,
                 },
               },
-              hls = {
+              hls = ${toLuaObject servers.hls}
-                cmd = ${
-                if isList cfg.lsp.package
-                then expToLua cfg.lsp.package
-                else ''{"${cfg.lsp.package}/bin/haskell-language-server-wrapper", "--lsp"}''
-              },
-                on_attach = function(client, bufnr, ht)
-                  default_on_attach(client, bufnr, ht)
-                  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,
-              },
             ''}
             ${optionalString cfg.dap.enable ''
               dap = {

modules/plugins/languages/hcl.nix

@@ -8,22 +8,19 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) package bool enum;
+  inherit (lib.types) package bool enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.hcl;
 
-  defaultServer = "terraform-ls";
+  defaultServers = ["terraform-ls"];
   servers = {
     terraform-ls = {
-      package = pkgs.terraform-ls;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.terraform-ls) "serve"];
-        lspconfig.terraformls.setup {
+      filetypes = ["terraform" "terraform-vars"];
-          capabilities = capabilities,
+      root_markers = [".terraform" ".git"];
-          on_attach=default_on_attach,
-          cmd = {"${lib.getExe cfg.lsp.package}", "serve"},
-        }
-      '';
     };
   };
 
@@ -43,12 +40,11 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "HCL LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "HCL LSP support" // {default = config.vim.lsp.enable;};
-      # TODO: (maybe, is it better?) it would be cooler to use vscode-extensions.hashicorp.hcl probably, shouldn't be too hard
+      servers = mkOption {
-      package = mkOption {
+        type = listOf (enum (attrNames servers));
-        type = package;
+        default = defaultServers;
-        default = servers.${defaultServer}.package;
+        description = "HCL LSP server to use";
-        description = "HCL language server package (terraform-ls)";
       };
     };
 
@@ -96,10 +92,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources = lib.optionalAttrs (! config.vim.languages.terraform.lsp.enable) {
+        mapListToAttrs (n: {
-        terraform-ls = servers.${cfg.lsp.server}.lspConfig;
+          name = n;
-      };
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/helm.nix

@@ -4,44 +4,37 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames head;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.helm;
   yamlCfg = config.vim.languages.yaml;
 
-  helmCmd =
+  defaultServers = ["helm-ls"];
-    if isList cfg.lsp.package
-    then cfg.lsp.package
-    else ["${cfg.lsp.package}/bin/helm_ls" "serve"];
-  yamlCmd =
-    if isList yamlCfg.lsp.package
-    then builtins.elemAt yamlCfg.lsp.package 0
-    else "${yamlCfg.lsp.package}/bin/yaml-language-server";
-
-  defaultServer = "helm-ls";
   servers = {
     helm-ls = {
-      package = pkgs.helm-ls;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.helm-ls) "serve"];
-        lspconfig.helm_ls.setup {
+      filetypes = ["helm" "yaml.helm-values"];
-          capabilities = capabilities,
+      root_markers = ["Chart.yaml"];
-          on_attach = default_on_attach,
+      capabilities = {
-          cmd = ${expToLua helmCmd},
+        didChangeWatchedFiles = {
-          settings = {
+          dynamicRegistration = true;
-            ['helm-ls'] = {
+        };
-              yamlls = {
+      };
-                  path = "${yamlCmd}"
+      settings = {
-              }
+        helm-ls = {
-            }
+          yamlls = {
-          }
+            # TODO: Determine if this is a good enough solution
-        }
+            path = (head yamlCfg.lsp.servers).cmd;
-      '';
+          };
+        };
+      };
     };
   };
 in {
@@ -55,17 +48,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Helm LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Helm LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Helm LSP server package";
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
@@ -77,8 +63,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.helm-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     {

modules/plugins/languages/java.nix

@@ -7,12 +7,59 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.lists) isList;
+  inherit (builtins) attrNames;
-  inherit (lib.types) either listOf package str;
+  inherit (lib.types) listOf enum;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.java;
+
+  defaultServers = ["jdtls"];
+  servers = {
+    jdtls = {
+      enable = true;
+      cmd =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          {
+            '${getExe pkgs.jdt-language-server}',
+            '-configuration',
+            get_jdtls_config_dir(),
+            '-data',
+            get_jdtls_workspace_dir(),
+            get_jdtls_jvm_args(),
+          }
+        '';
+      filetypes = ["java"];
+      root_markers = [
+        # Multi-module projects
+        ".git"
+        "build.gradle"
+        "build.gradle.kts"
+        # Single-module projects
+        "build.xml" # Ant
+        "pom.xml" # Maven
+        "settings.gradle" # Gradle
+        "settings.gradle.kts" # Gradle
+      ];
+      init_options = {
+        workspace = mkLuaInline "get_jdtls_workspace_dir()";
+        jvm_args = {};
+        os_config = mkLuaInline "nil";
+      };
+      handlers = {
+        "textDocument/codeAction" = mkLuaInline "jdtls_on_textdocument_codeaction";
+        "textDocument/rename" = mkLuaInline "jdtls_on_textdocument_rename";
+        "workspace/applyEdit" = mkLuaInline "jdtls_on_workspace_applyedit";
+        "language/status" = mkLuaInline "vim.schedule_wrap(jdtls_on_language_status)";
+      };
+    };
+  };
 in {
   options.vim.languages.java = {
     enable = mkEnableOption "Java language support";
@@ -23,30 +70,107 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Java LSP support (java-language-server)" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
-      package = mkOption {
+      servers = mkOption {
-        description = "java language server package, or the command to run as a list of strings";
+        type = listOf (enum (attrNames servers));
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
+        default = defaultServers;
-        type = either package (listOf str);
+        description = "Java LSP server to use";
-        default = pkgs.jdt-language-server;
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.luaConfigRC.jdtls-util =
-      vim.lsp.lspconfig.sources.jdtls = ''
+        entryBefore ["lsp-servers"]
-        lspconfig.jdtls.setup {
+        /*
-          capabilities = capabilities,
+        lua
-          on_attach = default_on_attach,
+        */
-          cmd = ${
+        ''
-          if isList cfg.lsp.package
+          local jdtls_handlers = require 'vim.lsp.handlers'
-          then expToLua cfg.lsp.package
+
-          else ''{"${getExe cfg.lsp.package}", "-data", vim.fn.stdpath("cache").."/jdtls/workspace"}''
+          local jdtls_env = {
-        },
+            HOME = vim.uv.os_homedir(),
-        }
+            XDG_CACHE_HOME = os.getenv 'XDG_CACHE_HOME',
-      '';
+            JDTLS_JVM_ARGS = os.getenv 'JDTLS_JVM_ARGS',
+          }
+
+          local function get_cache_dir()
+            return jdtls_env.XDG_CACHE_HOME and jdtls_env.XDG_CACHE_HOME or jdtls_env.HOME .. '/.cache'
+          end
+
+          local function get_jdtls_cache_dir()
+            return get_cache_dir() .. '/jdtls'
+          end
+
+          local function get_jdtls_config_dir()
+            return get_jdtls_cache_dir() .. '/config'
+          end
+
+          local function get_jdtls_workspace_dir()
+            return get_jdtls_cache_dir() .. '/workspace'
+          end
+
+          local function get_jdtls_jvm_args()
+            local args = {}
+            for a in string.gmatch((jdtls_env.JDTLS_JVM_ARGS or '''), '%S+') do
+              local arg = string.format('--jvm-arg=%s', a)
+              table.insert(args, arg)
+            end
+            return unpack(args)
+          end
+
+          -- TextDocument version is reported as 0, override with nil so that
+          -- the client doesn't think the document is newer and refuses to update
+          -- See: https://github.com/eclipse/eclipse.jdt.ls/issues/1695
+          local function jdtls_fix_zero_version(workspace_edit)
+            if workspace_edit and workspace_edit.documentChanges then
+              for _, change in pairs(workspace_edit.documentChanges) do
+                local text_document = change.textDocument
+                if text_document and text_document.version and text_document.version == 0 then
+                  text_document.version = nil
+                end
+              end
+            end
+            return workspace_edit
+          end
+
+          local function jdtls_on_textdocument_codeaction(err, actions, ctx)
+            for _, action in ipairs(actions) do
+              -- TODO: (steelsojka) Handle more than one edit?
+              if action.command == 'java.apply.workspaceEdit' then -- 'action' is Command in java format
+                action.edit = jdtls_fix_zero_version(action.edit or action.arguments[1])
+              elseif type(action.command) == 'table' and action.command.command == 'java.apply.workspaceEdit' then -- 'action' is CodeAction in java format
+                action.edit = jdtls_fix_zero_version(action.edit or action.command.arguments[1])
+              end
+            end
+
+            jdtls_handlers[ctx.method](err, actions, ctx)
+          end
+
+          local function jdtls_on_textdocument_rename(err, workspace_edit, ctx)
+            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+          end
+
+          local function jdtls_on_workspace_applyedit(err, workspace_edit, ctx)
+            jdtls_handlers[ctx.method](err, jdtls_fix_zero_version(workspace_edit), ctx)
+          end
+
+          -- Non-standard notification that can be used to display progress
+          local function jdtls_on_language_status(_, result)
+            local command = vim.api.nvim_command
+            command 'echohl ModeMsg'
+            command(string.format('echo "%s"', result.message))
+            command 'echohl None'
+          end
+        '';
+
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/julia.nix

@@ -4,63 +4,82 @@
   config,
   ...
 }: let
-  inherit (builtins) attrNames isList;
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) either listOf package str enum bool nullOr;
+  inherit (lib.types) listOf enum;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.strings) optionalString;
+  inherit (lib.meta) getExe;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.dag) entryBefore;
 
-  defaultServer = "julials";
+  defaultServers = ["jdtls"];
   servers = {
-    julials = {
+    jdtls = {
-      package = pkgs.julia.withPackages ["LanguageServer"];
+      enable = true;
-      internalFormatter = true;
+      cmd =
-      lspConfig = ''
+        mkLuaInline
-        lspconfig.julials.setup {
+        /*
-          capabilities = capabilities,
+        lua
-          on_attach = default_on_attach,
+        */
-          cmd = ${
+        ''
-          if isList cfg.lsp.package
+          {
-          then expToLua cfg.lsp.package
+            '${getExe (pkgs.julia.withPackages ["LanguageServer"])}',
-          else ''
+            '--startup-file=no',
-            {
+            '--history-file=no',
-              "${optionalString (cfg.lsp.package != null) "${cfg.lsp.package}/bin/"}julia",
+            '-e',
-              "--startup-file=no",
+            [[
-              "--history-file=no",
+              # Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig
-              "--eval",
+              # with the regular load path as a fallback
-              [[
+              ls_install_path = joinpath(
-                using LanguageServer
+                  get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),
-
+                  "environments", "nvim-lspconfig"
-                depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
+              )
-                project_path = let
+              pushfirst!(LOAD_PATH, ls_install_path)
-                    dirname(something(
+              using LanguageServer
-                        ## 1. Finds an explicitly set project (JULIA_PROJECT)
+              popfirst!(LOAD_PATH)
-                        Base.load_path_expand((
+              depot_path = get(ENV, "JULIA_DEPOT_PATH", "")
-                            p = get(ENV, "JULIA_PROJECT", nothing);
+              project_path = let
-                            p === nothing ? nothing : isempty(p) ? nothing : p
+                  dirname(something(
-                        )),
+                      ## 1. Finds an explicitly set project (JULIA_PROJECT)
-                        ## 2. Look for a Project.toml file in the current working directory,
+                      Base.load_path_expand((
-                        ##    or parent directories, with $HOME as an upper boundary
+                          p = get(ENV, "JULIA_PROJECT", nothing);
-                        Base.current_project(),
+                          p === nothing ? nothing : isempty(p) ? nothing : p
-                        ## 3. First entry in the load path
+                      )),
-                        get(Base.load_path(), 1, nothing),
+                      ## 2. Look for a Project.toml file in the current working directory,
-                        ## 4. Fallback to default global environment,
+                      ##    or parent directories, with $HOME as an upper boundary
-                        ##    this is more or less unreachable
+                      Base.current_project(),
-                        Base.load_path_expand("@v#.#"),
+                      ## 3. First entry in the load path
-                    ))
+                      get(Base.load_path(), 1, nothing),
-                end
+                      ## 4. Fallback to default global environment,
-                @info "Running language server" VERSION pwd() project_path depot_path
+                      ##    this is more or less unreachable
-                server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
+                      Base.load_path_expand("@v#.#"),
-                server.runlinter = true
+                  ))
-                run(server)
+              end
-              ]]
+              @info "Running language server" VERSION pwd() project_path depot_path
-            }
+              server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)
-          ''
+              server.runlinter = true
-        }
+              run(server)
-        }
+            ]],
-      '';
+          }
+        '';
+      filetypes = ["julia"];
+      root_markers = ["Project.toml" "JuliaProject.toml"];
+      on_attach =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          function(_, bufnr)
+              vim.api.nvim_buf_create_user_command(bufnr, 'LspJuliaActivateEnv', activate_julia_env, {
+                desc = 'Activate a Julia environment',
+                nargs = '?',
+                complete = 'file',
+              })
+          end
+        '';
     };
   };
 
@@ -76,11 +95,12 @@ in {
       };
 
       lsp = {
-        enable = mkOption {
+        enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
-          type = bool;
+        servers = mkOption {
-          default = config.vim.lsp.enable;
+          type = listOf (enum (attrNames servers));
+          default = defaultServers;
           description = ''
-            Whether to enable Julia LSP support.
+            Julia LSP Server to Use
 
             ::: {.note}
             The entirety of Julia is bundled with nvf, if you enable this
@@ -93,21 +113,6 @@ in {
             :::
           '';
         };
-
-        server = mkOption {
-          type = enum (attrNames servers);
-          default = defaultServer;
-          description = "Julia LSP server to use";
-        };
-
-        package = mkOption {
-          description = ''
-            Julia LSP server package, `null` to use the Julia binary in {env}`PATH`, or
-            the command to run as a list of strings.
-          '';
-          type = nullOr (either package (listOf str));
-          default = servers.${cfg.lsp.server}.package;
-        };
       };
     };
   };
@@ -119,8 +124,70 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.luaConfigRC.julia-util =
-      vim.lsp.lspconfig.sources.julia-lsp = servers.${cfg.lsp.server}.lspConfig;
+        entryBefore ["lsp-servers"]
+        /*
+        lua
+        */
+        ''
+          local function activate_julia_env(path)
+            assert(vim.fn.has 'nvim-0.10' == 1, 'requires Nvim 0.10 or newer')
+            local bufnr = vim.api.nvim_get_current_buf()
+            local julials_clients = vim.lsp.get_clients { bufnr = bufnr, name = 'julials' }
+            assert(
+              #julials_clients > 0,
+              'method julia/activateenvironment is not supported by any servers active on the current buffer'
+            )
+            local function _activate_env(environment)
+              if environment then
+                for _, julials_client in ipairs(julials_clients) do
+                  julials_client:notify('julia/activateenvironment', { envPath = environment })
+                end
+                vim.notify('Julia environment activated: \n`' .. environment .. '`', vim.log.levels.INFO)
+              end
+            end
+            if path then
+              path = vim.fs.normalize(vim.fn.fnamemodify(vim.fn.expand(path), ':p'))
+              local found_env = false
+              for _, project_file in ipairs(root_files) do
+                local file = vim.uv.fs_stat(vim.fs.joinpath(path, project_file))
+                if file and file.type then
+                  found_env = true
+                  break
+                end
+              end
+              if not found_env then
+                vim.notify('Path is not a julia environment: \n`' .. path .. '`', vim.log.levels.WARN)
+                return
+              end
+              _activate_env(path)
+            else
+              local depot_paths = vim.env.JULIA_DEPOT_PATH
+                  and vim.split(vim.env.JULIA_DEPOT_PATH, vim.fn.has 'win32' == 1 and ';' or ':')
+                or { vim.fn.expand '~/.julia' }
+              local environments = {}
+              vim.list_extend(environments, vim.fs.find(root_files, { type = 'file', upward = true, limit = math.huge }))
+              for _, depot_path in ipairs(depot_paths) do
+                local depot_env = vim.fs.joinpath(vim.fs.normalize(depot_path), 'environments')
+                vim.list_extend(
+                  environments,
+                  vim.fs.find(function(name, env_path)
+                    return vim.tbl_contains(root_files, name) and string.sub(env_path, #depot_env + 1):match '^/[^/]*$'
+                  end, { path = depot_env, type = 'file', limit = math.huge })
+                )
+              end
+              environments = vim.tbl_map(vim.fs.dirname, environments)
+              vim.ui.select(environments, { prompt = 'Select a Julia environment' }, _activate_env)
+            end
+          end
+        '';
+
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/kotlin.nix

@@ -4,16 +4,47 @@
   lib,
   ...
 }: let
-  inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.meta) getExe;
+  inherit (lib.meta) getExe' getExe;
-  inherit (lib.types) either package listOf str;
+  inherit (builtins) attrNames;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.lists) isList;
+  inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.kotlin;
 
+  defaultServers = ["kotlin-language-server"];
+  servers = {
+    kotlin-language-server = {
+      enable = true;
+      cmd = [(getExe' pkgs.kotlin-language-server "kotlin-language-server")];
+      filetypes = ["kotlin"];
+      root_markers = [
+        "settings.gradle" # Gradle (multi-project)
+        "settings.gradle.kts" # Gradle (multi-project)
+        "build.xml" # Ant
+        "pom.xml" # Maven
+        "build.gradle" # Gradle
+        "build.gradle.kts" # gradle
+      ];
+      init_options = {
+        storagePath = mkLuaInline "
+        vim.fs.root(vim.fn.expand '%:p:h',
+          {
+            'settings.gradle', -- Gradle (multi-project)
+            'settings.gradle.kts', -- Gradle (multi-project)
+            'build.xml', -- Ant
+            'pom.xml', -- Maven
+            'build.gradle', -- Gradle
+            'build.gradle.kts', -- Gradle
+          }
+        )";
+      };
+    };
+  };
+
   defaultDiagnosticsProvider = ["ktlint"];
   diagnosticsProviders = {
     ktlint = {
@@ -31,22 +62,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Kotlin LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      package = mkOption {
+        type = listOf (enum (attrNames servers));
-        description = "kotlin_language_server package with Kotlin runtime";
+        default = defaultServers;
-        type = either package (listOf str);
+        description = "Kotlin LSP server to use";
-        example = literalExpression ''
-          pkgs.symlinkJoin {
-            name = "kotlin-language-server-wrapped";
-            paths = [pkgs.kotlin-language-server];
-            nativeBuildInputs = [pkgs.makeBinaryWrapper];
-            postBuild = '''
-              wrapProgram $out/bin/kotlin-language-server \
-                --prefix PATH : ''${pkgs.kotlin}/bin
-            ''';
-          };
-        '';
-        default = pkgs.kotlin-language-server;
       };
     };
 
@@ -78,23 +97,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.kotlin_language_server = ''
+        mapListToAttrs (n: {
-        lspconfig.kotlin_language_server.setup {
+          name = n;
-          capabilities = capabilities,
+          value = servers.${n};
-          root_dir = lspconfig.util.root_pattern("main.kt", ".git"),
+        })
-          on_attach=default_on_attach,
+        cfg.lsp.servers;
-          init_options = {
-          -- speeds up the startup time for the LSP
-            storagePath = vim.fn.stdpath('state') .. '/kotlin',
-          },
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/kotlin-language-server"}''
-        },
-        }
-      '';
     })
   ]);
 }

modules/plugins/languages/lua.nix

@@ -8,13 +8,32 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.lists) isList;
+  inherit (lib.types) bool enum listOf package;
-  inherit (lib.types) bool either enum listOf package str;
   inherit (lib.nvim.types) diagnostics mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryBefore;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.lua;
+
+  defaultServers = ["lua-language-server"];
+  servers = {
+    lua-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.lua-language-server)];
+      filetypes = ["lua"];
+      root_markers = [
+        ".luarc.json"
+        ".luarc.jsonc"
+        ".luacheckrc"
+        ".stylua.toml"
+        "stylua.toml"
+        "selene.toml"
+        "selene.yml"
+        ".git"
+      ];
+    };
+  };
+
   defaultFormat = "stylua";
   formats = {
     stylua = {
@@ -43,12 +62,11 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Lua LSP support via LuaLS" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Lua LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      package = mkOption {
+        type = listOf (enum (attrNames servers));
-        description = "LuaLS package, or the command to run as a list of strings";
+        default = defaultServers;
-        type = either package (listOf str);
+        description = "Lua LSP server to use";
-        default = pkgs.lua-language-server;
       };
 
       lazydev.enable = mkEnableOption "lazydev.nvim integration, useful for neovim plugin developers";
@@ -91,23 +109,17 @@ in {
 
     (mkIf cfg.enable (mkMerge [
       (mkIf cfg.lsp.enable {
-        vim.lsp.lspconfig.enable = true;
+        vim.lsp.servers =
-        vim.lsp.lspconfig.sources.lua-lsp = ''
+          mapListToAttrs (n: {
-          lspconfig.lua_ls.setup {
+            name = n;
-            capabilities = capabilities;
+            value = servers.${n};
-            on_attach = default_on_attach;
+          })
-            cmd = ${
+          cfg.lsp.servers;
-            if isList cfg.lsp.package
-            then expToLua cfg.lsp.package
-            else ''{"${getExe cfg.lsp.package}"}''
-          };
-          }
-        '';
       })
 
       (mkIf cfg.lsp.lazydev.enable {
         vim.startPlugins = ["lazydev-nvim"];
-        vim.pluginRC.lazydev = entryBefore ["lua-lsp"] ''
+        vim.pluginRC.lazydev = entryBefore ["lsp-servers"] ''
           require("lazydev").setup({
             enabled = function(root_dir)
               return not vim.uv.fs_stat(root_dir .. "/.luarc.json")

modules/plugins/languages/markdown.nix

@@ -8,28 +8,20 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.lists) isList;
+  inherit (lib.types) bool enum package listOf str nullOr;
-  inherit (lib.types) bool enum either package listOf str nullOr;
+  inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.markdown;
-  defaultServer = "marksman";
+  defaultServers = ["marksman"];
   servers = {
     marksman = {
-      package = pkgs.marksman;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.marksman) "server"];
-        lspconfig.marksman.setup{
+      filetypes = ["markdown" "markdown.mdx"];
-          capabilities = capabilities;
+      root_markers = [".marksman.toml" ".git"];
-          on_attach = default_on_attach;
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/marksman", "server"}''
-        },
-        }
-      '';
     };
   };
 
@@ -67,19 +59,12 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "Enable Markdown LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Markdown LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
-        type = enum (attrNames servers);
-        default = defaultServer;
         description = "Markdown LSP server to use";
-      };
+        type = listOf (enum (attrNames servers));
-
+        default = defaultServers;
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
-        description = "Markdown LSP server package, or the command to run as a list of strings";
       };
     };
 
@@ -161,8 +146,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.markdown-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/nim.nix

@@ -6,31 +6,34 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe';
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf package;
-  inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.nim;
 
-  defaultServer = "nimlsp";
+  defaultServers = ["nimlsp"];
   servers = {
     nimlsp = {
-      package = pkgs.nimlsp;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe' pkgs.nimlsp "nimlsp")];
-        lspconfig.nimls.setup{
+      filetypes = ["nim"];
-          capabilities = capabilities;
+      root_dir =
-          on_attach = default_on_attach;
+        mkLuaInline
-          cmd = ${
+        /*
-          if isList cfg.lsp.package
+        lua
-          then expToLua cfg.lsp.package
+        */
-          else ''
+        ''
-            {"${cfg.lsp.package}/bin/nimlsp"}
+          function(bufnr, on_dir)
-          ''
+              local fname = vim.api.nvim_buf_get_name(bufnr)
-        };
+              on_dir(
-        }
+                util.root_pattern '*.nimble'(fname) or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1])
-      '';
+              )
+          end
+        '';
     };
   };
 
@@ -54,32 +57,26 @@ in {
 
     lsp = {
       enable = mkEnableOption "Nim LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
-        description = "Nim LSP server to use";
-        type = str;
-        default = defaultServer;
-      };
 
-      package = mkOption {
+      servers = mkOption {
-        description = "Nim LSP server package, or the command to run as a list of strings";
+        type = listOf (enum (attrNames servers));
-        example = ''[lib.getExe pkgs.nimlsp]'';
+        default = defaultServers;
-        type = either package (listOf str);
+        description = "Nim LSP server to use";
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
     format = {
       enable = mkEnableOption "Nim formatting" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        description = "Nim formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Nim formatter to use";
       };
 
       package = mkOption {
-        description = "Nim formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Nim formatter package";
       };
     };
   };
@@ -100,8 +97,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.nim-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/nix.nix

@@ -9,90 +9,43 @@
   inherit (lib.meta) getExe;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum package listOf;
-  inherit (lib.strings) optionalString;
-  inherit (lib.types) anything attrsOf enum either listOf nullOr package str;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.nix;
 
-  useFormat = "on_attach = default_on_attach";
+  formattingCmd = mkIf (cfg.format.enable && cfg.lsp.enable) {
-  noFormat = "on_attach = attach_keymaps";
+    formatting = mkMerge [
+      (mkIf (cfg.format.type == "alejandra") {
+        command = ["${cfg.format.package}/bin/alejandra" "--quiet"];
+      })
+      (mkIf (cfg.format.type == "nixfmt") {
+        command = ["${cfg.format.package}/bin/nixfmt"];
+      })
+    ];
+  };
 
-  defaultServer = "nil";
+  defaultServers = ["nil"];
-  packageToCmd = package: defaultCmd:
-    if isList package
-    then expToLua package
-    else ''{"${package}/bin/${defaultCmd}"}'';
   servers = {
     nil = {
-      package = pkgs.nil;
+      enable = true;
-      internalFormatter = true;
+      cmd = [(getExe pkgs.nil)];
-      lspConfig = ''
+      settings = {
-        lspconfig.nil_ls.setup{
+        nil = formattingCmd;
-          capabilities = capabilities,
+      };
-        ${
+      filetypes = ["nix"];
-          if cfg.format.enable
+      root_markers = [".git" "flake.nix"];
-          then useFormat
-          else noFormat
-        },
-          cmd = ${packageToCmd cfg.lsp.package "nil"},
-        ${optionalString cfg.format.enable ''
-          settings = {
-            ["nil"] = {
-          ${optionalString (cfg.format.type == "alejandra")
-            ''
-              formatting = {
-                command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
-              },
-            ''}
-          ${optionalString (cfg.format.type == "nixfmt")
-            ''
-              formatting = {
-                command = {"${cfg.format.package}/bin/nixfmt"},
-              },
-            ''}
-            },
-          },
-        ''}
-        }
-      '';
     };
 
     nixd = {
-      package = pkgs.nixd;
+      enable = true;
-      internalFormatter = true;
+      cmd = [(getExe pkgs.nixd)];
-      lspConfig = ''
+      settings = {
-        lspconfig.nixd.setup{
+        nixd = formattingCmd;
-          capabilities = capabilities,
+      };
-        ${
+      filetypes = ["nix"];
-          if cfg.format.enable
+      root_markers = [".git" "flake.nix"];
-          then useFormat
-          else noFormat
-        },
-          cmd = ${packageToCmd cfg.lsp.package "nixd"},
-        ${optionalString cfg.format.enable ''
-          settings = {
-            nixd = {
-          ${optionalString (cfg.format.type == "alejandra")
-            ''
-              formatting = {
-                command = {"${cfg.format.package}/bin/alejandra", "--quiet"},
-              },
-            ''}
-          ${optionalString (cfg.format.type == "nixfmt")
-            ''
-              formatting = {
-                command = {"${cfg.format.package}/bin/nixfmt"},
-              },
-            ''}
-          options = ${toLuaObject cfg.lsp.options},
-            },
-          },
-        ''}
-        }
-      '';
     };
   };
 
@@ -144,23 +97,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Nix LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Nix LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-      };
-
-      options = mkOption {
-        type = nullOr (attrsOf anything);
-        default = null;
-        description = "Options to pass to nixd LSP server";
       };
     };
 
@@ -201,13 +141,6 @@ in {
             ${concatStringsSep ", " (attrNames formats)}
           '';
         }
-        {
-          assertion = cfg.lsp.server != "rnix";
-          message = ''
-            rnix-lsp has been archived upstream. Please use one of the following available language servers:
-            ${concatStringsSep ", " (attrNames servers)}
-          '';
-        }
       ];
     }
 
@@ -217,11 +150,15 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.nix-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
-    (mkIf (cfg.format.enable && (!cfg.lsp.enable || !servers.${cfg.lsp.server}.internalFormatter)) {
+    (mkIf (cfg.format.enable && !cfg.lsp.enable) {
       vim.formatter.conform-nvim = {
         enable = true;
         setupOpts.formatters_by_ft.nix = [cfg.format.type];

modules/plugins/languages/nu.nix

@@ -5,27 +5,30 @@
   ...
 }: let
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) str either package listOf;
+  inherit (lib.types) enum listOf;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (builtins) isList;
+  inherit (lib.meta) getExe;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (builtins) attrNames;
 
-  defaultServer = "nushell";
+  defaultServers = ["nushell"];
   servers = {
     nushell = {
-      package = pkgs.nushell;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.nushell) "--no-config-file" "--lsp"];
-        lspconfig.nushell.setup{
+      filetypes = ["nu"];
-          capabilities = capabilities,
+      root_dir =
-          on_attach = default_on_attach,
+        mkLuaInline
-          cmd = ${
+        /*
-          if isList cfg.lsp.package
+        lua
-          then expToLua cfg.lsp.package
+        */
-          else ''{"${cfg.lsp.package}/bin/nu", "--no-config-file", "--lsp"}''
+        ''
-        }
+          function(bufnr, on_dir)
-        }
+            on_dir(vim.fs.root(bufnr, { '.git' }) or vim.fs.dirname(vim.api.nvim_buf_get_name(bufnr)))
-      '';
+          end
+        '';
     };
   };
 
@@ -41,17 +44,11 @@ in {
 
     lsp = {
       enable = mkEnableOption "Nu LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
-        type = str;
-        default = defaultServer;
-        description = "Nu LSP server to use";
-      };
 
-      package = mkOption {
+      servers = mkOption {
-        type = either package (listOf str);
+        type = listOf (enum (attrNames servers));
-        default = servers.${cfg.lsp.server}.package;
+        default = defaultServers;
-        example = ''[(lib.getExe pkgs.nushell) "--lsp"]'';
+        description = "Nu LSP server to use";
-        description = "Nu LSP server package, or the command to run as a list of strings";
       };
     };
   };
@@ -63,8 +60,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.nu-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/ocaml.nix

@@ -8,28 +8,50 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf package;
-  inherit (lib.types) either enum listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.ocaml;
 
-  defaultServer = "ocaml-lsp";
+  defaultServers = ["ocaml-lsp"];
   servers = {
     ocaml-lsp = {
-      package = pkgs.ocamlPackages.ocaml-lsp;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.ocamlPackages.ocaml-lsp)];
-        lspconfig.ocamllsp.setup {
+      filetypes = ["ocaml" "menhir" "ocamlinterface" "ocamllex" "reason" "dune"];
-          capabilities = capabilities,
+      root_dir =
-          on_attach = default_on_attach,
+        mkLuaInline
-            cmd = ${
+        /*
-          if isList cfg.lsp.package
+        lua
-          then expToLua cfg.lsp.package
+        */
-          else ''{"${getExe cfg.lsp.package}"}''
+        ''
-        };
+          function(bufnr, on_dir)
-        }
+            local fname = vim.api.nvim_buf_get_name(bufnr)
-      '';
+            on_dir(util.root_pattern('*.opam', 'esy.json', 'package.json', '.git', 'dune-project', 'dune-workspace')(fname))
+          end
+        '';
+      get_language_id =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          function(_, ftype)
+            local language_id_of = {
+              menhir = 'ocaml.menhir',
+              ocaml = 'ocaml',
+              ocamlinterface = 'ocaml.interface',
+              ocamllex = 'ocaml.ocamllex',
+              reason = 'reason',
+              dune = 'dune',
+            }
+
+            return language_id_of[ftype]
+
+          end
+        '';
     };
   };
 
@@ -49,38 +71,38 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "OCaml LSP support (ocaml-lsp)" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "OCaml LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
+
-        description = "OCaml LSP server to user";
+      servers = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = defaultServers;
-      };
+        description = "OCaml LSP server to use";
-      package = mkOption {
-        description = "OCaml language server package, or the command to run as a list of strings";
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
     format = {
       enable = mkEnableOption "OCaml formatting support (ocamlformat)" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        description = "OCaml formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "OCaml formatter to use";
       };
       package = mkOption {
-        description = "OCaml formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "OCaml formatter package";
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.ocaml-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/odin.nix

@@ -7,26 +7,28 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) listOf enum;
-  inherit (lib.types) either listOf package str enum;
+  inherit (lib.meta) getExe;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
-  defaultServer = "ols";
+  defaultServers = ["ols"];
   servers = {
     ols = {
-      package = pkgs.ols;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.ols)];
-        lspconfig.ols.setup {
+      filetypes = ["odin"];
-          capabilities = capabilities,
+      root_dir =
-          on_attach = default_on_attach,
+        mkLuaInline
-          cmd = ${
+        /*
-          if isList cfg.lsp.package
+        lua
-          then expToLua cfg.lsp.package
+        */
-          else "{'${cfg.lsp.package}/bin/ols'}"
+        ''
-        }
+          function(bufnr, on_dir)
-        }
+            local fname = vim.api.nvim_buf_get_name(bufnr)
-      '';
+            on_dir(util.root_pattern('ols.json', '.git', '*.odin')(fname))
+          end'';
     };
   };
 
@@ -43,17 +45,11 @@ in {
     lsp = {
       enable = mkEnableOption "Odin LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = defaultServers;
         description = "Odin LSP server to use";
       };
-
-      package = mkOption {
-        description = "Ols package, or the command to run as a list of strings";
-        type = either package (listOf str);
-        default = pkgs.ols;
-      };
     };
   };
 
@@ -64,8 +60,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.odin-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/php.nix

@@ -8,81 +8,60 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf;
-  inherit (lib.types) enum either listOf package str;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.php;
 
-  defaultServer = "phpactor";
+  defaultServers = ["phpactor"];
   servers = {
     phpactor = {
-      package = pkgs.phpactor;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.phpactor) "language-server"];
-        lspconfig.phpactor.setup{
+      filetypes = ["php"];
-          capabilities = capabilities,
+      root_markers = [".git" "composer.json" ".phpactor.json" ".phpactor.yml"];
-          on_attach = default_on_attach,
+      workspace_required = true;
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''
-            {
-              "${getExe cfg.lsp.package}",
-              "language-server"
-            },
-          ''
-        }
-        }
-      '';
     };
 
     phan = {
-      package = pkgs.php81Packages.phan;
+      enable = true;
-      lspConfig = ''
+      cmd = [
-        lspconfig.phan.setup{
+        (getExe pkgs.php81Packages.phan)
-          capabilities = capabilities,
+        "-m"
-          on_attach = default_on_attach,
+        "json"
-          cmd = ${
+        "--no-color"
-          if isList cfg.lsp.package
+        "--no-progress-bar"
-          then expToLua cfg.lsp.package
+        "-x"
-          else ''
+        "-u"
-              {
+        "-S"
-                "${getExe cfg.lsp.package}",
+        "--language-server-on-stdin"
-                "-m",
+        "--allow-polyfill-parser"
-                "json",
+      ];
-                "--no-color",
+      filetypes = ["php"];
-                "--no-progress-bar",
+      root_dir =
-                "-x",
+        mkLuaInline
-                "-u",
+        /*
-                "-S",
+        lua
-                "--language-server-on-stdin",
+        */
-                "--allow-polyfill-parser"
+        ''
-            },
+          function(bufnr, on_dir)
-          ''
+            local fname = vim.api.nvim_buf_get_name(bufnr)
-        }
+            local cwd = assert(vim.uv.cwd())
-        }
+            local root = vim.fs.root(fname, { 'composer.json', '.git' })
-      '';
+
+            -- prefer cwd if root is a descendant
+            on_dir(root and vim.fs.relpath(cwd, root) and cwd)
+          end
+        '';
     };
 
     intelephense = {
-      package = pkgs.intelephense;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.intelephense) "--stdio"];
-        lspconfig.intelephense.setup{
+      filetypes = ["php"];
-          capabilities = capabilities,
+      root_markers = ["composer.json" ".git"];
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''
-            {
-              "${getExe cfg.lsp.package}",
-              "--stdio"
-            },
-          ''
-        }
-        }
-      '';
     };
   };
 in {
@@ -97,17 +76,10 @@ in {
     lsp = {
       enable = mkEnableOption "PHP LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "PHP LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "PHP LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
@@ -117,11 +89,14 @@ in {
       vim.treesitter.enable = true;
       vim.treesitter.grammars = [cfg.treesitter.package];
     })
+
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig = {
+      vim.lsp.servers =
-        enable = true;
+        mapListToAttrs (n: {
-        sources.php-lsp = servers.${cfg.lsp.server}.lspConfig;
+          name = n;
-      };
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/python.nix

@@ -8,57 +8,114 @@
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf package str bool;
-  inherit (lib.types) enum either listOf package str bool;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.nvim.dag) entryBefore;
 
   cfg = config.vim.languages.python;
 
-  defaultServer = "basedpyright";
+  defaultServers = ["basedpyright"];
   servers = {
     pyright = {
-      package = pkgs.pyright;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.pyright) "--stdio"];
-        lspconfig.pyright.setup{
+      filetypes = ["python"];
-          capabilities = capabilities;
+      root_markers = [
-          on_attach = default_on_attach;
+        "pyproject.toml"
-          cmd = ${
+        "setup.py"
-          if isList cfg.lsp.package
+        "setup.cfg"
-          then expToLua cfg.lsp.package
+        "requirements.txt"
-          else ''{"${cfg.lsp.package}/bin/pyright-langserver", "--stdio"}''
+        "Pipfile"
-        }
+        "pyrightconfig.json"
-        }
+        ".git"
+      ];
+      settings = {
+        python = {
+          analysis = {
+            autoSearchPaths = true;
+            useLibraryCodeForTypes = true;
+            diagnosticMode = "openFilesOnly";
+          };
+        };
+      };
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
+            client:exec_cmd({
+              command = 'pyright.organizeimports',
+              arguments = { vim.uri_from_bufnr(bufnr) },
+            })
+          end, {
+            desc = 'Organize Imports',
+          })
+          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', function(opts)
+            set_python_path('pyright', opts.args)
+          end, {
+            desc = 'Reconfigure pyright with the provided python path',
+            nargs = 1,
+            complete = 'file',
+          })
+        end
       '';
     };
 
     basedpyright = {
-      package = pkgs.basedpyright;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.basedpyright) "--stdio"];
-        lspconfig.basedpyright.setup{
+      filetypes = ["python"];
-          capabilities = capabilities;
+      root_markers = [
-          on_attach = default_on_attach;
+        "pyproject.toml"
-          cmd = ${
+        "setup.py"
-          if isList cfg.lsp.package
+        "setup.cfg"
-          then expToLua cfg.lsp.package
+        "requirements.txt"
-          else ''{"${cfg.lsp.package}/bin/basedpyright-langserver", "--stdio"}''
+        "Pipfile"
-        }
+        "pyrightconfig.json"
-        }
+        ".git"
+      ];
+      settings = {
+        basedpyright = {
+          analysis = {
+            autoSearchPaths = true;
+            useLibraryCodeForTypes = true;
+            diagnosticMode = "openFilesOnly";
+          };
+        };
+      };
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightOrganizeImports', function()
+            client:exec_cmd({
+              command = 'basedpyright.organizeimports',
+              arguments = { vim.uri_from_bufnr(bufnr) },
+            })
+          end, {
+            desc = 'Organize Imports',
+          })
+
+          vim.api.nvim_buf_create_user_command(bufnr, 'LspPyrightSetPythonPath', function(opts)
+            set_python_path('basedpyright', opts.args)
+          end, {
+            desc = 'Reconfigure basedpyright with the provided python path',
+            nargs = 1,
+            complete = 'file',
+          })
+        end
       '';
     };
 
     python-lsp-server = {
-      package = pkgs.python3Packages.python-lsp-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.python3Packages.python-lsp-server)];
-        lspconfig.pylsp.setup{
+      filetypes = ["python"];
-          capabilities = capabilities;
+      root_markers = [
-          on_attach = default_on_attach;
+        "pyproject.toml"
-          cmd = ${
+        "setup.py"
-          if isList cfg.lsp.package
+        "setup.cfg"
-          then expToLua cfg.lsp.package
+        "requirements.txt"
-          else ''{"${cfg.lsp.package}/bin/pylsp"}''
+        "Pipfile"
-        }
+        ".git"
-        }
+      ];
-      '';
     };
   };
 
@@ -171,17 +228,10 @@ in {
     lsp = {
       enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Python LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "python LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -189,30 +239,30 @@ in {
       enable = mkEnableOption "Python formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "Python formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Python formatter to use";
       };
 
       package = mkOption {
-        description = "Python formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Python formatter package";
       };
     };
 
     # TODO this implementation is very bare bones, I don't know enough python to implement everything
     dap = {
       enable = mkOption {
-        description = "Enable Python Debug Adapter";
         type = bool;
         default = config.vim.languages.enableDAP;
+        description = "Enable Python Debug Adapter";
       };
 
       debugger = mkOption {
-        description = "Python debugger to use";
         type = enum (attrNames debuggers);
         default = defaultDebugger;
+        description = "Python debugger to use";
       };
 
       package = mkOption {
@@ -234,8 +284,34 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.luaConfigRC.python-util =
-      vim.lsp.lspconfig.sources.python-lsp = servers.${cfg.lsp.server}.lspConfig;
+        entryBefore ["lsp-servers"]
+        /*
+        lua
+        */
+        ''
+          local function set_python_path(server_name, path)
+            local clients = vim.lsp.get_clients {
+              bufnr = vim.api.nvim_get_current_buf(),
+              name = server_name,
+            }
+            for _, client in ipairs(clients) do
+              if client.settings then
+                client.settings.python = vim.tbl_deep_extend('force', client.settings.python or {}, { pythonPath = path })
+              else
+                client.config.settings = vim.tbl_deep_extend('force', client.config.settings, { python = { pythonPath = path } })
+              end
+              client.notify('workspace/didChangeConfiguration', { settings = nil })
+            end
+          end
+        '';
+
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/r.nix

@@ -7,10 +7,11 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf package;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.meta) getExe;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.r;
 
@@ -50,22 +51,16 @@
     };
   };
 
-  defaultServer = "r_language_server";
+  defaultServers = ["r_language_server"];
   servers = {
     r_language_server = {
-      package = pkgs.writeShellScriptBin "r_lsp" ''
+      enable = true;
-        ${r-with-languageserver}/bin/R --slave -e "languageserver::run()"
+      cmd = [(getExe r-with-languageserver) "--no-echo" "-e" "languageserver::run()"];
-      '';
+      filetypes = ["r" "rmd" "quarto"];
-      lspConfig = ''
+      root_dir = mkLuaInline ''
-        lspconfig.r_language_server.setup{
+        function(bufnr, on_dir)
-          capabilities = capabilities;
+          on_dir(vim.fs.root(bufnr, '.git') or vim.uv.os_homedir())
-          on_attach = default_on_attach;
+        end
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${lib.getExe cfg.lsp.package}"}''
-        }
-        }
       '';
     };
   };
@@ -81,17 +76,10 @@ in {
     lsp = {
       enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "R LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "R LSP server package, or the command to run as a list of strings";
-        example = literalExpression "[ (lib.getExe pkgs.jdt-language-server) \"-data\" \"~/.cache/jdtls/workspace\" ]";
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -127,8 +115,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.r-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/ruby.nix

@@ -9,44 +9,41 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.types) listOf package enum;
-  inherit (lib.lists) isList;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.types) either listOf package str enum;
 
   cfg = config.vim.languages.ruby;
 
-  defaultServer = "rubyserver";
+  defaultServers = ["solargraph"];
   servers = {
-    rubyserver = {
+    ruby_lsp = {
-      package = pkgs.rubyPackages.solargraph;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.ruby-lsp)];
-        lspconfig.solargraph.setup {
+      filetypes = ["ruby" "eruby"];
-          capabilities = capabilities,
+      root_markers = ["Gemfile" ".git"];
-          on_attach = attach_keymaps,
+      init_options = {
-          flags = {
+        formatter = "auto";
-            debounce_text_changes = 150,
+      };
-          },
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{ "${cfg.lsp.package}/bin/solargraph", "stdio" }''
-        }
-        }
-      '';
     };
-    rubylsp = {
+
-      package = pkgs.ruby-lsp;
+    solargraph = {
-      lspConfig = ''
+      enable = true;
-        lspconfig.ruby_lsp.setup {
+      cmd = [(getExe pkgs.rubyPackages.solargraph) "stdio"];
-          capabilities = capabilities,
+      filetypes = ["ruby"];
-          on_attach = default_on_attach,
+      root_markers = ["Gemfile" ".git"];
-          cmd = ${
+      settings = {
-          if isList cfg.lsp.package
+        solargraph = {
-          then expToLua cfg.lsp.package
+          diagnostics = true;
-          else ''{ "${cfg.lsp.package}/bin/ruby-lsp" }''
+        };
-        }
+      };
-        }
+
-      '';
+      flags = {
+        debounce_text_changes = 150;
+      };
+
+      init_options = {
+        formatting = true;
+      };
     };
   };
 
@@ -79,17 +76,11 @@ in {
     lsp = {
       enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = defaultServers;
         description = "Ruby LSP server to use";
       };
-
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        description = "Ruby LSP server package, or the command to run as a list of strings";
-      };
     };
 
     format = {
@@ -128,8 +119,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.ruby-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/sql.nix

@@ -8,31 +8,27 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) enum listOf package str;
-  inherit (lib.types) enum either listOf package str;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) diagnostics;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.sql;
   sqlfluffDefault = pkgs.sqlfluff;
 
-  defaultServer = "sqls";
+  defaultServers = ["sqls"];
   servers = {
     sqls = {
-      package = pkgs.sqls;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.sqls)];
-        lspconfig.sqls.setup {
+      filetypes = ["sql" "mysql"];
-          on_attach = function(client)
+      root_markers = ["config.yml"];
-            client.server_capabilities.execute_command = true
+      settings = {};
-            on_attach_keymaps(client, bufnr)
+      on_attach = mkLuaInline ''
-            require'sqls'.setup{}
+        function(client, bufnr)
-          end,
+          client.server_capabilities.execute_command = true
-          cmd = ${
+          require'sqls'.setup{}
-          if isList cfg.lsp.package
+        end
-          then expToLua cfg.lsp.package
-          else ''{ "${cfg.lsp.package}/bin/sqls", "-config", string.format("%s/config.yml", vim.fn.getcwd()) }''
-        }
-        }
       '';
     };
   };
@@ -63,35 +59,28 @@ in {
     enable = mkEnableOption "SQL language support";
 
     dialect = mkOption {
-      description = "SQL dialect for sqlfluff (if used)";
       type = str;
       default = "ansi";
+      description = "SQL dialect for sqlfluff (if used)";
     };
 
     treesitter = {
       enable = mkEnableOption "SQL treesitter" // {default = config.vim.languages.enableTreesitter;};
 
       package = mkOption {
-        description = "SQL treesitter grammar to use";
         type = package;
         default = pkgs.vimPlugins.nvim-treesitter.builtGrammars.sql;
+        description = "SQL treesitter grammar to use";
       };
     };
 
     lsp = {
       enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "SQL LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "SQL LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -99,15 +88,15 @@ in {
       enable = mkEnableOption "SQL formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "SQL formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "SQL formatter to use";
       };
 
       package = mkOption {
-        description = "SQL formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "SQL formatter package";
       };
     };
 
@@ -132,10 +121,12 @@ in {
       vim = {
         startPlugins = ["sqls-nvim"];
 
-        lsp.lspconfig = {
+        lsp.servers =
-          enable = true;
+          mapListToAttrs (n: {
-          sources.sql-lsp = servers.${cfg.lsp.server}.lspConfig;
+            name = n;
-        };
+            value = servers.${n};
+          })
+          cfg.lsp.servers;
       };
     })
 

modules/plugins/languages/svelte.nix

@@ -7,28 +7,39 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.types) enum listOf package;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.svelte;
 
-  defaultServer = "svelte";
+  defaultServers = ["svelte"];
   servers = {
     svelte = {
-      package = pkgs.svelte-language-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.svelte-language-server) "--stdio"];
-        lspconfig.svelte.setup {
+      filetypes = ["svelte"];
-          capabilities = capabilities;
+      root_dir = mkLuaInline ''
-          on_attach = attach_keymaps,
+        function(bufnr, on_dir)
-          cmd = ${
+          local root_files = { 'package.json', '.git' }
-          if isList cfg.lsp.package
+          local fname = vim.api.nvim_buf_get_name(bufnr)
-          then expToLua cfg.lsp.package
+          -- Svelte LSP only supports file:// schema. https://github.com/sveltejs/language-tools/issues/2777
-          else ''{"${cfg.lsp.package}/bin/svelteserver", "--stdio"}''
+          if vim.uv.fs_stat(fname) ~= nil then
-        }
+            on_dir(vim.fs.dirname(vim.fs.find(root_files, { path = fname, upward = true })[1]))
-        }
+          end
+        end
+      '';
+      on_attach = mkLuaInline ''
+        function(client, bufnr)
+          vim.api.nvim_buf_create_user_command(bufnr, 'LspMigrateToSvelte5', function()
+            client:exec_cmd({
+              command = 'migrate_to_svelte_5',
+              arguments = { vim.uri_from_bufnr(bufnr) },
+            })
+          end, { desc = 'Migrate Component to Svelte 5 Syntax' })
+        end
       '';
     };
   };
@@ -78,17 +89,10 @@ in {
     lsp = {
       enable = mkEnableOption "Svelte LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Svelte LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Svelte LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -96,15 +100,15 @@ in {
       enable = mkEnableOption "Svelte formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "Svelte formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Svelte formatter to use";
       };
 
       package = mkOption {
-        description = "Svelte formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Svelte formatter package";
       };
     };
 
@@ -126,8 +130,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.svelte-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     (mkIf cfg.format.enable {

modules/plugins/languages/tailwind.nix

@@ -7,26 +7,142 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.types) enum listOf;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.tailwind;
 
-  defaultServer = "tailwindcss-language-server";
+  defaultServers = ["tailwindcss"];
   servers = {
-    tailwindcss-language-server = {
+    tailwindcss = {
-      package = pkgs.tailwindcss-language-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.tailwindcss-language-server) "--stdio"];
-        lspconfig.tailwindcss.setup {
+      filetypes = [
-          capabilities = capabilities;
+        # html
-          on_attach = default_on_attach;
+        "aspnetcorerazor"
-          cmd = ${
+        "astro"
-          if isList cfg.lsp.package
+        "astro-markdown"
-          then expToLua cfg.lsp.package
+        "blade"
-          else ''{"${cfg.lsp.package}/bin/tailwindcss-language-server", "--stdio"}''
+        "clojure"
-        }
+        "django-html"
-        }
+        "htmldjango"
+        "edge"
+        "eelixir"
+        "elixir"
+        "ejs"
+        "erb"
+        "eruby"
+        "gohtml"
+        "gohtmltmpl"
+        "haml"
+        "handlebars"
+        "hbs"
+        "html"
+        "htmlangular"
+        "html-eex"
+        "heex"
+        "jade"
+        "leaf"
+        "liquid"
+        "markdown"
+        "mdx"
+        "mustache"
+        "njk"
+        "nunjucks"
+        "php"
+        "razor"
+        "slim"
+        "twig"
+        # css
+        "css"
+        "less"
+        "postcss"
+        "sass"
+        "scss"
+        "stylus"
+        "sugarss"
+        # js
+        "javascript"
+        "javascriptreact"
+        "reason"
+        "rescript"
+        "typescript"
+        "typescriptreact"
+        # mixed
+        "vue"
+        "svelte"
+        "templ"
+      ];
+      settings = {
+        tailwindCSS = {
+          validate = true;
+          lint = {
+            cssConflict = "warning";
+            invalidApply = "error";
+            invalidScreen = "error";
+            invalidVariant = "error";
+            invalidConfigPath = "error";
+            invalidTailwindDirective = "error";
+            recommendedVariantOrder = "warning";
+          };
+          classAttributes = [
+            "class"
+            "className"
+            "class:list"
+            "classList"
+            "ngClass"
+          ];
+          includeLanguages = {
+            eelixir = "html-eex";
+            elixir = "phoenix-heex";
+            eruby = "erb";
+            heex = "phoenix-heex";
+            htmlangular = "html";
+            templ = "html";
+          };
+        };
+      };
+      before_init = mkLuaInline ''
+        function(_, config)
+          if not config.settings then
+            config.settings = {}
+          end
+          if not config.settings.editor then
+            config.settings.editor = {}
+          end
+          if not config.settings.editor.tabSize then
+            config.settings.editor.tabSize = vim.lsp.util.get_effective_tabstop()
+          end
+        end
+      '';
+      workspace_required = true;
+      root_dir = mkLuaInline ''
+        function(bufnr, on_dir)
+          local util = require 'lspconfig.util'
+          local root_files = {
+            -- Generic
+            'tailwind.config.js',
+            'tailwind.config.cjs',
+            'tailwind.config.mjs',
+            'tailwind.config.ts',
+            'postcss.config.js',
+            'postcss.config.cjs',
+            'postcss.config.mjs',
+            'postcss.config.ts',
+            -- Django
+            'theme/static_src/tailwind.config.js',
+            'theme/static_src/tailwind.config.cjs',
+            'theme/static_src/tailwind.config.mjs',
+            'theme/static_src/tailwind.config.ts',
+            'theme/static_src/postcss.config.js',
+          }
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+          root_files = util.insert_package_json(root_files, 'tailwindcss', fname)
+          root_files = util.root_markers_with_field(root_files, { 'mix.lock', 'Gemfile.lock' }, 'tailwind', fname)
+          on_dir(vim.fs.dirname(vim.fs.find(root_files, { path = fname, upward = true })[1]))
+        end
       '';
     };
   };
@@ -37,25 +153,22 @@ in {
     lsp = {
       enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Tailwindcss LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Tailwindcss LSP server package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.tailwindcss-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/terraform.nix

@@ -4,12 +4,25 @@
   lib,
   ...
 }: let
+  inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) package;
+  inherit (lib.meta) getExe;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.terraform;
+
+  defaultServers = ["terraformls"];
+  servers = {
+    terraformls = {
+      enable = true;
+      cmd = [(getExe pkgs.terraform-ls) "serve"];
+      filetypes = ["terraform" "terraform-vars"];
+      root_markers = [".terraform" ".git"];
+    };
+  };
 in {
   options.vim.languages.terraform = {
     enable = mkEnableOption "Terraform/HCL support";
@@ -22,10 +35,10 @@ in {
     lsp = {
       enable = mkEnableOption "Terraform LSP support (terraform-ls)" // {default = config.vim.lsp.enable;};
 
-      package = mkOption {
+      servers = mkOption {
-        description = "terraform-ls package";
+        type = listOf (enum (attrNames servers));
-        type = package;
+        default = defaultServers;
-        default = pkgs.terraform-ls;
+        description = "Terraform LSP server to use";
       };
     };
   };
@@ -36,14 +49,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.terraform-ls = ''
+        mapListToAttrs (n: {
-        lspconfig.terraformls.setup {
+          name = n;
-          capabilities = capabilities,
+          value = servers.${n};
-          on_attach=default_on_attach,
+        })
-          cmd = {"${cfg.lsp.package}/bin/terraform-ls", "serve"},
+        cfg.lsp.servers;
-        }
-      '';
     })
   ]);
 }

modules/plugins/languages/typst.nix

@@ -6,52 +6,87 @@
 }: let
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.types) nullOr enum attrsOf listOf package str;
-  inherit (lib.types) nullOr enum either attrsOf listOf package str;
   inherit (lib.attrsets) attrNames;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAnywhere;
+  inherit (lib.nvim.lua) toLuaObject;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.typst;
 
-  defaultServer = "tinymist";
+  defaultServers = ["tinymist"];
   servers = {
-    typst-lsp = {
+    typst_lsp = {
-      package = pkgs.typst-lsp;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.typst-lsp)];
-        lspconfig.typst_lsp.setup {
+      filetypes = ["typst"];
-          capabilities = capabilities,
+      root_markers = [".git"];
-          on_attach = function(client, bufnr)
+      on_attach = mkLuaInline ''
-            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
+        function(client, bufnr)
-            client.server_capabilities.semanticTokensProvider = nil
+          -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
-          end,
+          client.server_capabilities.semanticTokensProvider = nil
-          cmd = ${
+        end
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else ''{"${cfg.lsp.package}/bin/typst-lsp"}''
-        },
-        }
       '';
     };
 
     tinymist = {
-      package = pkgs.tinymist;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.tinymist)];
-        lspconfig.tinymist.setup {
+      filetypes = ["typst"];
-          capabilities = capabilities,
+      root_markers = [".git"];
-          single_file_support = true,
+      on_attach = mkLuaInline ''
-          on_attach = function(client, bufnr)
+        function(client, bufnr)
-            -- Disable semantic tokens as a workaround for a semantic token error when using non-english characters
+          local function create_tinymist_command(command_name, client, bufnr)
-            client.server_capabilities.semanticTokensProvider = nil
+            local export_type = command_name:match 'tinymist%.export(%w+)'
-          end,
+            local info_type = command_name:match 'tinymist%.(%w+)'
-          cmd = ${
+            if info_type and info_type:match '^get' then
-          if isList cfg.lsp.package
+              info_type = info_type:gsub('^get', 'Get')
-          then expToLua cfg.lsp.package
+            end
-          else ''{"${cfg.lsp.package}/bin/tinymist"}''
+            local cmd_display = export_type or info_type
-        },
+            local function run_tinymist_command()
-        }
+              local arguments = { vim.api.nvim_buf_get_name(bufnr) }
+              local title_str = export_type and ('Export ' .. cmd_display) or cmd_display
+              local function handler(err, res)
+                if err then
+                  return vim.notify(err.code .. ': ' .. err.message, vim.log.levels.ERROR)
+                end
+                vim.notify(export_type and res or vim.inspect(res), vim.log.levels.INFO)
+              end
+              if vim.fn.has 'nvim-0.11' == 1 then
+                return client:exec_cmd({
+                  title = title_str,
+                  command = command_name,
+                  arguments = arguments,
+                }, { bufnr = bufnr }, handler)
+              else
+                return vim.notify('Tinymist commands require Neovim 0.11+', vim.log.levels.WARN)
+              end
+            end
+            local cmd_name = export_type and ('LspTinymistExport' .. cmd_display) or ('LspTinymist' .. cmd_display)
+            local cmd_desc = export_type and ('Export to ' .. cmd_display) or ('Get ' .. cmd_display)
+            return run_tinymist_command, cmd_name, cmd_desc
+          end
+
+          for _, command in ipairs {
+            'tinymist.exportSvg',
+            'tinymist.exportPng',
+            'tinymist.exportPdf',
+            'tinymist.exportMarkdown',
+            'tinymist.exportText',
+            'tinymist.exportQuery',
+            'tinymist.exportAnsiHighlight',
+            'tinymist.getServerInfo',
+            'tinymist.getDocumentTrace',
+            'tinymist.getWorkspaceLabels',
+            'tinymist.getDocumentMetrics',
+          } do
+            local cmd_func, cmd_name, cmd_desc = create_tinymist_command(command, client, bufnr)
+            vim.api.nvim_buf_create_user_command(bufnr, cmd_name, cmd_func, { nargs = 0, desc = cmd_desc })
+          end
+        end
       '';
     };
   };
@@ -78,17 +113,10 @@ in {
     lsp = {
       enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Typst LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "typst-lsp package, or the command to run as a list of strings";
-        example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
 
@@ -96,15 +124,15 @@ in {
       enable = mkEnableOption "Typst document formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        description = "Typst formatter to use";
         type = enum (attrNames formats);
         default = defaultFormat;
+        description = "Typst formatter to use";
       };
 
       package = mkOption {
-        description = "Typst formatter package";
         type = package;
         default = formats.${cfg.format.type}.package;
+        description = "Typst formatter package";
       };
     };
 
@@ -131,7 +159,7 @@ in {
           dependencies_bin = mkOption {
             type = attrsOf str;
             default = {
-              "tinymist" = getExe servers.tinymist.package;
+              "tinymist" = getExe pkgs.tinymist;
               "websocat" = getExe pkgs.websocat;
             };
 
@@ -169,8 +197,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.typst-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
 
     # Extensions

modules/plugins/languages/vala.nix

@@ -7,36 +7,57 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.vala;
 
-  defaultServer = "vala_ls";
+  defaultServers = ["vala_ls"];
   servers = {
     vala_ls = {
-      package = pkgs.symlinkJoin {
+      enable = true;
-        name = "vala-language-server-wrapper";
+      cmd = [
-        paths = [pkgs.vala-language-server];
+        (getExe (pkgs.symlinkJoin {
-        buildInputs = [pkgs.makeBinaryWrapper];
+          name = "vala-language-server-wrapper";
-        postBuild = ''
+          paths = [pkgs.vala-language-server];
-          wrapProgram $out/bin/vala-language-server \
+          buildInputs = [pkgs.makeBinaryWrapper];
-            --prefix PATH : ${pkgs.uncrustify}/bin
+          postBuild = ''
-        '';
+            wrapProgram $out/bin/vala-language-server \
-      };
+              --prefix PATH : ${pkgs.uncrustify}/bin
-      internalFormatter = true;
+          '';
-      lspConfig = ''
+        }))
-        lspconfig.vala_ls.setup {
+      ];
-          capabilities = capabilities;
+      filetypes = ["vala" "genie"];
-          on_attach = default_on_attach;
+      root_dir = mkLuaInline ''
-          cmd = ${
+        function(bufnr, on_dir)
-          if isList cfg.lsp.package
+          local meson_matcher = function(path)
-          then expToLua cfg.lsp.package
+            local pattern = 'meson.build'
-          else ''{"${cfg.lsp.package}/bin/vala-language-server"}''
+            local f = vim.fn.glob(table.concat({ path, pattern }, '/'))
-        },
+            if f == ''' then
-        }
+              return nil
+            end
+            for line in io.lines(f) do
+              -- skip meson comments
+              if not line:match '^%s*#.*' then
+                local str = line:gsub('%s+', ''')
+                if str ~= ''' then
+                  if str:match '^project%(' then
+                    return path
+                  else
+                    break
+                  end
+                end
+              end
+            end
+          end
+
+          local fname = vim.api.nvim_buf_get_name(bufnr)
+          local root = vim.iter(vim.fs.parents(fname)):find(meson_matcher)
+          on_dir(root or vim.fs.dirname(vim.fs.find('.git', { path = fname, upward = true })[1]))
+        end
       '';
     };
   };
@@ -51,16 +72,10 @@ in {
 
     lsp = {
       enable = mkEnableOption "Vala LSP support" // {default = config.vim.lsp.enable;};
-      server = mkOption {
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
         description = "Vala LSP server to use";
-        type = enum (attrNames servers);
-        default = defaultServer;
-      };
-
-      package = mkOption {
-        description = "Vala LSP server package, or the command to run as a list of strings";
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
       };
     };
   };
@@ -72,8 +87,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.vala_ls = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/wgsl.nix

@@ -5,31 +5,23 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.lists) isList;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.options) literalExpression mkEnableOption mkOption;
+  inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) either enum listOf package str;
+  inherit (lib.types) enum listOf;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.wgsl;
 
-  defaultServer = "wgsl-analyzer";
+  defaultServers = ["wgsl_analyzer"];
   servers = {
-    wgsl-analyzer = {
+    wgsl_analyzer = {
-      package = pkgs.wgsl-analyzer;
+      enable = true;
-      internalFormatter = true;
+      cmd = [(getExe pkgs.wgsl-analyzer)];
-      lspConfig = ''
+      filetypes = ["wgsl"];
-        lspconfig.wgsl_analyzer.setup {
+      root_markers = [".git"];
-          capabilities = capabilities,
+      settings = {};
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/wgsl_analyzer'}"
-        }
-        }
-      '';
     };
   };
 in {
@@ -44,18 +36,11 @@ in {
     lsp = {
       enable = mkEnableOption "WGSL LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = defaultServers;
         description = "WGSL LSP server to use";
       };
-
-      package = mkOption {
-        description = "wgsl-analyzer package, or the command to run as a list of strings";
-        example = literalExpression "[(lib.getExe pkgs.wgsl-analyzer)]";
-        type = either package (listOf str);
-        default = pkgs.wgsl-analyzer;
-      };
     };
   };
 
@@ -68,12 +53,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim = {
+      vim.lsp.servers =
-        lsp.lspconfig = {
+        mapListToAttrs (n: {
-          enable = true;
+          name = n;
-          sources.wgsl_analyzer = servers.${cfg.lsp.server}.lspConfig;
+          value = servers.${n};
-        };
+        })
-      };
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/yaml.nix

@@ -7,10 +7,10 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.lists) isList;
+  inherit (lib.meta) getExe;
-  inherit (lib.types) enum either listOf package str;
+  inherit (lib.types) enum listOf;
   inherit (lib.nvim.types) mkGrammarOption;
-  inherit (lib.nvim.lua) expToLua;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.yaml;
 
@@ -25,23 +25,22 @@
       end''
     else "on_attach = default_on_attach";
 
-  defaultServer = "yaml-language-server";
+  defaultServers = ["yaml-language-server"];
   servers = {
     yaml-language-server = {
-      package = pkgs.yaml-language-server;
+      enable = true;
-      lspConfig = ''
+      cmd = [(getExe pkgs.yaml-language-server) "--stdio"];
-
+      filetypes = ["yaml" "yaml.docker-compose" "yaml.gitlab" "yaml.helm-values"];
-
+      root_markers = [".git"];
-        lspconfig.yamlls.setup {
+      on_attach = onAttach;
-          capabilities = capabilities,
+      # -- https://github.com/redhat-developer/vscode-redhat-telemetry#how-to-disable-telemetry-reporting
-          ${onAttach},
+      settings = {
-          cmd = ${
+        redhat = {
-          if isList cfg.lsp.package
+          telemetry = {
-          then expToLua cfg.lsp.package
+            enabled = false;
-          else ''{"${cfg.lsp.package}/bin/yaml-language-server", "--stdio"}''
+          };
-        },
+        };
-        }
+      };
-      '';
     };
   };
 in {
@@ -55,18 +54,11 @@ in {
     };
 
     lsp = {
-      enable = mkEnableOption "YAML LSP support" // {default = config.vim.lsp.enable;};
+      enable = mkEnableOption "Yaml LSP support" // {default = config.vim.lsp.enable;};
-
+      servers = mkOption {
-      server = mkOption {
+        type = listOf (enum (attrNames servers));
-        type = enum (attrNames servers);
+        default = defaultServers;
-        default = defaultServer;
+        description = "Yaml LSP server to use";
-        description = "YAML LSP server to use";
-      };
-
-      package = mkOption {
-        type = either package (listOf str);
-        default = servers.${cfg.lsp.server}.package;
-        description = "YAML LSP server package";
       };
     };
   };
@@ -78,8 +70,12 @@ in {
     })
 
     (mkIf cfg.lsp.enable {
-      vim.lsp.lspconfig.enable = true;
+      vim.lsp.servers =
-      vim.lsp.lspconfig.sources.yaml-lsp = servers.${cfg.lsp.server}.lspConfig;
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
     })
   ]);
 }

modules/plugins/languages/zig.nix

@@ -7,29 +7,21 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge mkDefault;
-  inherit (lib.lists) isList;
+  inherit (lib.types) bool listOf package enum;
-  inherit (lib.types) bool either listOf package str enum;
-  inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.zig;
 
-  defaultServer = "zls";
+  defaultServers = ["zls"];
   servers = {
     zls = {
-      package = pkgs.zls;
+      enable = true;
-      internalFormatter = true;
+      cmd = [(getExe pkgs.zls)];
-      lspConfig = ''
+      filetypes = ["zig" "zir"];
-        lspconfig.zls.setup {
+      root_markers = ["zls.json" "build.zig" ".git"];
-          capabilities = capabilities,
+      workspace_required = false;
-          on_attach = default_on_attach,
-          cmd = ${
-          if isList cfg.lsp.package
-          then expToLua cfg.lsp.package
-          else "{'${cfg.lsp.package}/bin/zls'}"
-        }
-        }
-      '';
     };
   };
 
@@ -74,17 +66,11 @@ in {
     lsp = {
       enable = mkEnableOption "Zig LSP support" // {default = config.vim.lsp.enable;};
 
-      server = mkOption {
+      servers = mkOption {
-        type = enum (attrNames servers);
+        type = listOf (enum (attrNames servers));
-        default = defaultServer;
+        default = defaultServers;
         description = "Zig LSP server to use";
       };
-
-      package = mkOption {
-        description = "ZLS package, or the command to run as a list of strings";
-        type = either package (listOf str);
-        default = pkgs.zls;
-      };
     };
 
     dap = {
@@ -118,10 +104,12 @@ in {
 
     (mkIf cfg.lsp.enable {
       vim = {
-        lsp.lspconfig = {
+        lsp.servers =
-          enable = true;
+          mapListToAttrs (n: {
-          sources.zig-lsp = servers.${cfg.lsp.server}.lspConfig;
+            name = n;
-        };
+            value = servers.${n};
+          })
+          cfg.lsp.servers;
 
         # nvf handles autosaving already
         globals.zig_fmt_autosave = mkDefault 0;