Merge 163eb0d003 into c7a4e99837

docs/release-notes/rl-0.7.md

@@ -376,8 +376,8 @@ The changes are, in no particular order:
 
 - Add [biome](https://github.com/biomejs/biome) support for Typescript, CSS and
   Svelte. Enable them via [](#opt-vim.languages.ts.format.type),
-  [](#opt-vim.languages.css.format.type) and
+  [](#opt-vim.languages.css.format.type) and `vim.languages.svelte.format.type`
-  [](#opt-vim.languages.svelte.format.type) respectively.
+  respectively.
 - Replace [nixpkgs-fmt](https://github.com/nix-community/nixpkgs-fmt) with
   [nixfmt](https://github.com/NixOS/nixfmt) (nixfmt-rfc-style).
 

docs/release-notes/rl-0.8.md

@@ -130,6 +130,9 @@
 - Moved code setting `additionalRuntimePaths` and `enableLuaLoader` out of
   `luaConfigPre`'s default to prevent being overridden
 - Use conform over custom autocmds for LSP format on save
+- Allow multiple formatters in language modules.
+- Remove formatter options for `astro` and `svelte`, as they have been broken
+  since conception
 
 [diniamo](https://github.com/diniamo):
 

lib/types/custom.nix

@@ -1,4 +1,5 @@
 {lib}: let
+  inherit (builtins) warn toJSON;
   inherit (lib.options) mergeEqualOption;
   inherit (lib.lists) singleton;
   inherit (lib.strings) isString stringLength match;
@@ -29,5 +30,14 @@ in {
     check = v: isString v && (match "#?[0-9a-fA-F]{6}" v) != null;
   };
 
-  singleOrListOf = t: coercedTo t singleton (listOf t);
+  # no compound types please
+  deprecatedSingleOrListOf = option: t:
+    coercedTo
+    t
+    (x:
+      warn ''
+        ${option} no longer accepts non-list values, use [${toJSON x}] instead
+      ''
+      (singleton x))
+    (listOf t);
 }

lib/types/default.nix

@@ -10,5 +10,5 @@ in {
   inherit (typesDag) dagOf;
   inherit (typesPlugin) pluginsOpt extraPluginType mkPluginSetupOption luaInline pluginType borderType;
   inherit (typesLanguage) diagnostics mkGrammarOption;
-  inherit (customTypes) char hexColor mergelessListOf singleOrListOf;
+  inherit (customTypes) char hexColor mergelessListOf deprecatedSingleOrListOf;
 }

modules/extra/deprecations.nix

@@ -42,6 +42,10 @@
         "Obsolete option `vim.languages.${lang}.lsp.server` used, use `vim.languages.${lang}.lsp.servers` instead."
         (head x);
     };
+
+  mkRemovedFormatPackage = lang: (mkRemovedOptionModule ["vim" "languages" lang "format" "package"] ''
+    `vim.languages.${lang}.format.package` is removed, please use `vim.formatter.conform-nvim.formatters.<formatter_name>.command` instead.
+  '');
 in {
   imports = concatLists [
     [
@@ -259,8 +263,38 @@ in {
 
       (mkRenamedLspServer "zig")
       (mkRemovedLspPackage "zig")
+
+      (mkRemovedOptionModule ["vim" "language" "astro" "format"] ''
+        This option has been removed due to being broken for a long time.
+      '')
+      (mkRemovedOptionModule ["vim" "language" "svelte" "format"] ''
+        This option has been removed due to being broken for a long time.
+      '')
     ]
 
+    (map mkRemovedFormatPackage [
+      "bash"
+      "css"
+      "elixir"
+      "fsharp"
+      "go"
+      "hcl"
+      "html"
+      "json"
+      "lua"
+      "markdown"
+      "nim"
+      "nix"
+      "ocaml"
+      "python"
+      "qml"
+      "r"
+      "ruby"
+      "rust"
+      "sql"
+      "ts"
+      "typst"
+    ])
     # Migrated via batchRenameOptions. Further batch renames must be below this line.
     renamedVimOpts
   ];

modules/plugins/languages/asm.nix

@@ -8,7 +8,7 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -34,7 +34,7 @@ in {
     lsp = {
       enable = mkEnableOption "Assembly LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.asm.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Assembly LSP server to use";
       };

modules/plugins/languages/astro.nix

@@ -8,9 +8,9 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.astro;
@@ -40,22 +40,6 @@
     };
   };
 
-  # TODO: specify packages
-  defaultFormat = "prettier";
-  formats = {
-    prettier = {
-      package = pkgs.prettier;
-    };
-
-    prettierd = {
-      package = pkgs.prettierd;
-    };
-
-    biome = {
-      package = pkgs.biome;
-    };
-  };
-
   # TODO: specify packages
   defaultDiagnosticsProvider = ["eslint_d"];
   diagnosticsProviders = {
@@ -89,28 +73,12 @@ in {
     lsp = {
       enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.astro.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Astro LSP server to use";
       };
     };
 
-    format = {
-      enable = mkEnableOption "Astro formatting" // {default = config.vim.languages.enableFormat;};
-
-      type = mkOption {
-        type = enum (attrNames formats);
-        default = defaultFormat;
-        description = "Astro formatter to use";
-      };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Astro formatter package";
-      };
-    };
-
     extraDiagnostics = {
       enable = mkEnableOption "extra Astro diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
 
@@ -137,16 +105,6 @@ in {
         cfg.lsp.servers;
     })
 
-    (mkIf cfg.format.enable {
-      vim.formatter.conform-nvim = {
-        enable = true;
-        setupOpts.formatters_by_ft.astro = [cfg.format.type];
-        setupOpts.formatters.${cfg.format.type} = {
-          command = getExe cfg.format.package;
-        };
-      };
-    })
-
     (mkIf cfg.extraDiagnostics.enable {
       vim.diagnostics.nvim-lint = {
         enable = true;

modules/plugins/languages/bash.nix

@@ -8,9 +8,9 @@
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package bool;
+  inherit (lib.types) enum bool;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.types) diagnostics mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.bash;
@@ -30,10 +30,10 @@
     };
   };
 
-  defaultFormat = "shfmt";
+  defaultFormat = ["shfmt"];
   formats = {
     shfmt = {
-      package = pkgs.shfmt;
+      command = getExe pkgs.shfmt;
     };
   };
 
@@ -55,7 +55,7 @@ in {
     lsp = {
       enable = mkEnableOption "Bash LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.bash.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Bash LSP server to use";
       };
@@ -68,16 +68,10 @@ in {
         description = "Enable Bash formatting";
       };
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.bash.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Bash formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Bash formatter package";
-      };
     };
 
     extraDiagnostics = {
@@ -108,10 +102,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.sh = [cfg.format.type];
+        setupOpts.formatters_by_ft.sh = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/clang.nix

@@ -10,7 +10,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.dag) entryAfter;
 
@@ -198,7 +198,7 @@ in {
 
       servers = mkOption {
         description = "The clang LSP server to use";
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.clang.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
       };
     };

modules/plugins/languages/clojure.nix

@@ -8,10 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  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;
 
   cfg = config.vim.languages.clojure;

modules/plugins/languages/csharp.nix

@@ -12,7 +12,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.strings) optionalString;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -186,7 +186,7 @@ in {
         enable = mkEnableOption "C# LSP support" // {default = config.vim.lsp.enable;};
         servers = mkOption {
           description = "C# LSP server to use";
-          type = singleOrListOf (enum (attrNames servers));
+          type = deprecatedSingleOrListOf "vim.language.csharp.lsp.servers" (enum (attrNames servers));
           default = defaultServers;
         };
       };

modules/plugins/languages/css.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.css;
@@ -30,34 +30,18 @@
     };
   };
 
-  defaultFormat = "prettier";
+  defaultFormat = ["prettier"];
   formats = {
     prettier = {
-      package = pkgs.prettier;
+      command = getExe pkgs.prettier;
     };
 
     prettierd = {
-      package = pkgs.prettierd;
+      command = getExe pkgs.prettierd;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.prettier.with({
-            command = "${cfg.format.package}/bin/prettierd",
-          })
-        )
-      '';
     };
 
     biome = {
-      package = pkgs.biome;
+      command = getExe pkgs.biome;
-      nullConfig = ''
-        table.insert(
-          ls_sources,
-          null_ls.builtins.formatting.biome.with({
-            command = "${cfg.format.package}/bin/biome",
-          })
-        )
-      '';
     };
   };
 in {
@@ -74,7 +58,7 @@ in {
       enable = mkEnableOption "CSS LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.css.lsp.servers" (enum (attrNames servers));
         default = defaultServer;
         description = "CSS LSP server to use";
       };
@@ -85,15 +69,9 @@ in {
 
       type = mkOption {
         description = "CSS formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.css.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "CSS formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
   };
 
@@ -115,10 +93,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.css = [cfg.format.type];
+        setupOpts.formatters_by_ft.css = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/dart.nix

@@ -11,7 +11,7 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) enum package nullOr str bool;
   inherit (lib.strings) optionalString;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -52,7 +52,7 @@ in {
     lsp = {
       enable = mkEnableOption "Dart LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.dart.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Dart LSP server to use";
       };

modules/plugins/languages/elixir.nix

@@ -8,9 +8,9 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -40,13 +40,10 @@
     };
   };
 
-  defaultFormat = "mix";
+  defaultFormat = ["mix"];
   formats = {
     mix = {
-      package = pkgs.elixir;
+      command = "${pkgs.elixir}/bin/mix";
-      config = {
-        command = "${cfg.format.package}/bin/mix";
-      };
     };
   };
 in {
@@ -63,7 +60,7 @@ in {
     lsp = {
       enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.elixir.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Elixir LSP server to use";
       };
@@ -73,16 +70,10 @@ in {
       enable = mkEnableOption "Elixir formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.elixir.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Elixir formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Elixir formatter package";
-      };
     };
 
     elixir-tools = {
@@ -112,9 +103,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.elixir = [cfg.format.type];
+        setupOpts.formatters_by_ft.elixir = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} =
+        setupOpts.formatters =
-          formats.${cfg.format.type}.config;
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/fsharp.nix

@@ -6,11 +6,11 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) package enum;
+  inherit (lib.types) enum;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   defaultServer = ["fsautocomplete"];
@@ -51,10 +51,10 @@
     };
   };
 
-  defaultFormat = "fantomas";
+  defaultFormat = ["fantomas"];
   formats = {
     fantomas = {
-      package = pkgs.fantomas;
+      command = getExe pkgs.fantomas;
     };
   };
 
@@ -72,7 +72,7 @@ in {
       lsp = {
         enable = mkEnableOption "F# LSP support" // {default = config.vim.lsp.enable;};
         servers = mkOption {
-          type = singleOrListOf (enum (attrNames servers));
+          type = deprecatedSingleOrListOf "vim.language.fsharp.lsp.servers" (enum (attrNames servers));
           default = defaultServer;
           description = "F# LSP server to use";
         };
@@ -81,16 +81,10 @@ in {
         enable = mkEnableOption "F# formatting" // {default = config.vim.languages.enableFormat;};
 
         type = mkOption {
-          type = enum (attrNames formats);
+          type = deprecatedSingleOrListOf "vim.language.fsharp.format.type" (enum (attrNames formats));
           default = defaultFormat;
           description = "F# formatter to use";
         };
-
-        package = mkOption {
-          type = package;
-          default = formats.${cfg.format.type}.package;
-          description = "F# formatter package";
-        };
       };
     };
   };
@@ -113,10 +107,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.fsharp = [cfg.format.type];
+        setupOpts.formatters_by_ft.fsharp = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/gleam.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.gleam;
@@ -35,7 +35,7 @@ in {
     lsp = {
       enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.gleam.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Gleam LSP server to use";
       };

modules/plugins/languages/go.nix

@@ -10,7 +10,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.types) bool enum package;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -59,19 +59,16 @@
     };
   };
 
-  defaultFormat = "gofmt";
+  defaultFormat = ["gofmt"];
   formats = {
     gofmt = {
-      package = pkgs.go;
+      command = "${pkgs.go}/bin/gofmt";
-      config.command = "${cfg.format.package}/bin/gofmt";
     };
     gofumpt = {
-      package = pkgs.gofumpt;
+      command = getExe pkgs.gofumpt;
-      config.command = getExe cfg.format.package;
     };
     golines = {
-      package = pkgs.golines;
+      command = "${pkgs.golines}/bin/golines";
-      config.command = "${cfg.format.package}/bin/golines";
     };
   };
 
@@ -95,7 +92,7 @@ in {
       enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.go.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Go LSP server to use";
       };
@@ -113,15 +110,9 @@ in {
 
       type = mkOption {
         description = "Go formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.go.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "Go formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
 
     dap = {
@@ -163,8 +154,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.go = [cfg.format.type];
+        setupOpts.formatters_by_ft.go = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+        setupOpts.formatters =
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/hcl.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) package bool enum listOf;
+  inherit (lib.types) bool enum listOf;
-  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.hcl;
@@ -24,10 +24,10 @@
     };
   };
 
-  defaultFormat = "hclfmt";
+  defaultFormat = ["hclfmt"];
   formats = {
     hclfmt = {
-      package = pkgs.hclfmt;
+      command = getExe pkgs.hclfmt;
     };
   };
 in {
@@ -55,15 +55,10 @@ in {
         description = "Enable HCL formatting";
       };
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.hcl.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "HCL formatter to use";
       };
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "HCL formatter package";
-      };
     };
   };
 
@@ -103,10 +98,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.hcl = [cfg.format.type];
+        setupOpts.formatters_by_ft.hcl = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/helm.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.helm;
@@ -49,7 +49,7 @@ in {
     lsp = {
       enable = mkEnableOption "Helm LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.helm.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Helm LSP server to use";
       };

modules/plugins/languages/html.nix

@@ -8,9 +8,9 @@
   inherit (lib.meta) getExe;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) bool enum package;
+  inherit (lib.types) bool enum;
   inherit (lib.lists) optional;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -25,14 +25,11 @@
     };
   };
 
-  defaultFormat = "superhtml";
+  defaultFormat = ["superhtml"];
   formats = {
     superhtml = {
-      package = pkgs.writeShellApplication {
+      command = "${pkgs.superhtml}/bin/superhtml";
-        name = "superhtml_fmt";
+      args = ["fmt" "-"];
-        runtimeInputs = [pkgs.superhtml];
-        text = "superhtml fmt -";
-      };
     };
   };
 
@@ -58,7 +55,7 @@ in {
     lsp = {
       enable = mkEnableOption "HTML LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.html.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "HTML LSP server to use";
       };
@@ -68,16 +65,10 @@ in {
       enable = mkEnableOption "HTML formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.html.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "HTML formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "HTML formatter package";
-      };
     };
 
     extraDiagnostics = {
@@ -119,10 +110,13 @@ in {
     (mkIf (cfg.format.enable && !cfg.lsp.enable) {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.html = [cfg.format.type];
+        setupOpts.formatters_by_ft.html = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/json.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkOption mkEnableOption;
   inherit (lib.meta) getExe' getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.json;
@@ -24,15 +24,12 @@
     };
   };
 
-  defaultFormat = "jsonfmt";
+  defaultFormat = ["jsonfmt"];
 
   formats = {
     jsonfmt = {
-      package = pkgs.writeShellApplication {
+      command = getExe pkgs.jsonfmt;
-        name = "jsonfmt";
+      args = ["-w" "-"];
-        runtimeInputs = [pkgs.jsonfmt];
-        text = "jsonfmt -w -";
-      };
     };
   };
 in {
@@ -49,7 +46,7 @@ in {
       enable = mkEnableOption "JSON LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.json.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "JSON LSP server to use";
       };
@@ -60,15 +57,9 @@ in {
 
       type = mkOption {
         description = "JSON formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.json.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "JSON formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
   };
 
@@ -90,10 +81,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.json = [cfg.format.type];
+        setupOpts.formatters_by_ft.json = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/julia.nix

@@ -9,7 +9,7 @@
   inherit (lib.types) enum;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.dag) entryBefore;
@@ -97,7 +97,7 @@ in {
       lsp = {
         enable = mkEnableOption "Julia LSP support" // {default = config.vim.lsp.enable;};
         servers = mkOption {
-          type = singleOrListOf (enum (attrNames servers));
+          type = deprecatedSingleOrListOf "vim.language.julia.lsp.servers" (enum (attrNames servers));
           default = defaultServers;
           description = ''
             Julia LSP Server to Use

modules/plugins/languages/lua.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) bool enum listOf package;
+  inherit (lib.types) bool enum listOf;
-  inherit (lib.nvim.types) diagnostics mkGrammarOption;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryBefore;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -34,10 +34,10 @@
     };
   };
 
-  defaultFormat = "stylua";
+  defaultFormat = ["stylua"];
   formats = {
     stylua = {
-      package = pkgs.stylua;
+      command = getExe pkgs.stylua;
     };
   };
 
@@ -79,16 +79,10 @@ in {
         description = "Enable Lua formatting";
       };
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.lua.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Lua formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Lua formatter package";
-      };
     };
 
     extraDiagnostics = {
@@ -132,10 +126,13 @@ in {
       (mkIf cfg.format.enable {
         vim.formatter.conform-nvim = {
           enable = true;
-          setupOpts.formatters_by_ft.lua = [cfg.format.type];
+          setupOpts.formatters_by_ft.lua = cfg.format.type;
-          setupOpts.formatters.${cfg.format.type} = {
+          setupOpts.formatters =
-            command = getExe cfg.format.package;
+            mapListToAttrs (name: {
-          };
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
         };
       })
 

modules/plugins/languages/markdown.nix

@@ -4,13 +4,13 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames warn;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) bool enum package listOf str nullOr;
+  inherit (lib.types) bool enum listOf str nullOr;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption singleOrListOf;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -25,17 +25,17 @@
     };
   };
 
-  defaultFormat = "deno_fmt";
+  defaultFormat = ["deno_fmt"];
   formats = {
     # for backwards compatibility
     denofmt = {
-      package = pkgs.deno;
+      command = getExe pkgs.deno;
     };
     deno_fmt = {
-      package = pkgs.deno;
+      command = getExe pkgs.deno;
     };
     prettierd = {
-      package = pkgs.prettierd;
+      command = getExe pkgs.prettierd;
     };
   };
   defaultDiagnosticsProvider = ["markdownlint-cli2"];
@@ -63,7 +63,7 @@ in {
 
       servers = mkOption {
         description = "Markdown LSP server to use";
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.markdown.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
       };
     };
@@ -72,17 +72,11 @@ in {
       enable = mkEnableOption "Markdown formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.markdown.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Markdown formatter to use. `denofmt` is deprecated and currently aliased to deno_fmt.";
       };
 
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Markdown formatter package";
-      };
-
       extraFiletypes = mkOption {
         type = listOf str;
         default = [];
@@ -157,14 +151,22 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.markdown = [cfg.format.type];
+        setupOpts.formatters_by_ft.markdown = cfg.format.type;
-        setupOpts.formatters.${
+        setupOpts.formatters = let
-          if cfg.format.type == "denofmt"
+          names = map (name:
-          then "deno_fmt"
+            if name == "denofmt"
-          else cfg.format.type
+            then
-        } = {
+              warn ''
-          command = getExe cfg.format.package;
+                vim.languages.markdown.format.type: "denofmt" is renamed to "deno_fmt".
-        };
+              '' "deno_fmt"
+            else name)
+          cfg.format.type;
+        in
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          names;
       };
     })
 

modules/plugins/languages/nim.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe';
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -37,13 +37,10 @@
     };
   };
 
-  defaultFormat = "nimpretty";
+  defaultFormat = ["nimpretty"];
   formats = {
     nimpretty = {
-      package = pkgs.nim;
+      command = "${pkgs.nim}/bin/nimpretty";
-      config = {
-        command = "${cfg.format.package}/bin/nimpretty";
-      };
     };
   };
 in {
@@ -59,7 +56,7 @@ in {
       enable = mkEnableOption "Nim LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.nim.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Nim LSP server to use";
       };
@@ -68,16 +65,10 @@ in {
     format = {
       enable = mkEnableOption "Nim formatting" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.nim.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Nim formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Nim formatter package";
-      };
     };
   };
 
@@ -108,8 +99,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.nim = [cfg.format.type];
+        setupOpts.formatters_by_ft.nim = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+        setupOpts.formatters =
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/nix.nix

@@ -9,8 +9,8 @@
   inherit (lib.meta) getExe;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.nix;
@@ -49,14 +49,14 @@
     };
   };
 
-  defaultFormat = "alejandra";
+  defaultFormat = ["alejandra"];
   formats = {
     alejandra = {
-      package = pkgs.alejandra;
+      command = getExe pkgs.alejandra;
     };
 
     nixfmt = {
-      package = pkgs.nixfmt-rfc-style;
+      command = getExe pkgs.nixfmt-rfc-style;
     };
   };
 
@@ -98,7 +98,7 @@ in {
     lsp = {
       enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.nix.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Nix LSP server to use";
       };
@@ -109,15 +109,9 @@ in {
 
       type = mkOption {
         description = "Nix formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.nix.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "Nix formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
 
     extraDiagnostics = {
@@ -161,10 +155,13 @@ in {
     (mkIf (cfg.format.enable && !cfg.lsp.enable) {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.nix = [cfg.format.type];
+        setupOpts.formatters_by_ft.nix = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/nu.nix

@@ -7,7 +7,7 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) enum;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
@@ -46,7 +46,7 @@ in {
       enable = mkEnableOption "Nu LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.nu.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Nu LSP server to use";
       };

modules/plugins/languages/ocaml.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -55,10 +55,10 @@
     };
   };
 
-  defaultFormat = "ocamlformat";
+  defaultFormat = ["ocamlformat"];
   formats = {
     ocamlformat = {
-      package = pkgs.ocamlPackages.ocamlformat;
+      command = getExe pkgs.ocamlPackages.ocamlformat;
     };
   };
 in {
@@ -74,7 +74,7 @@ in {
       enable = mkEnableOption "OCaml LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.ocaml.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "OCaml LSP server to use";
       };
@@ -83,15 +83,10 @@ in {
     format = {
       enable = mkEnableOption "OCaml formatting support (ocamlformat)" // {default = config.vim.languages.enableFormat;};
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.ocaml.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "OCaml formatter to use";
       };
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "OCaml formatter package";
-      };
     };
   };
 
@@ -113,10 +108,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.ocaml = [cfg.format.type];
+        setupOpts.formatters_by_ft.ocaml = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/odin.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -46,7 +46,7 @@ in {
       enable = mkEnableOption "Odin LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.odin.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Odin LSP server to use";
       };

modules/plugins/languages/php.nix

@@ -9,7 +9,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
 
@@ -77,7 +77,7 @@ in {
       enable = mkEnableOption "PHP LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.php.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "PHP LSP server to use";
       };

modules/plugins/languages/python.nix

@@ -4,13 +4,14 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames warn;
   inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib.lists) flatten;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum package bool;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) singleOrListOf;
+  inherit (lib.nvim.types) deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryBefore;
 
@@ -120,34 +121,22 @@
     };
   };
 
-  defaultFormat = "black";
+  defaultFormat = ["black"];
   formats = {
     black = {
-      package = pkgs.black;
+      command = getExe pkgs.black;
     };
 
     isort = {
-      package = pkgs.isort;
+      command = getExe pkgs.isort;
     };
 
-    black-and-isort = {
+    # dummy option for backwards compat
-      package = pkgs.writeShellApplication {
+    black-and-isort = {};
-        name = "black";
-        runtimeInputs = [pkgs.black pkgs.isort];
-        text = ''
-          black --quiet - "$@" | isort --profile black -
-        '';
-      };
-    };
 
     ruff = {
-      package = pkgs.writeShellApplication {
+      command = getExe pkgs.ruff;
-        name = "ruff";
+      args = ["format" "-"];
-        runtimeInputs = [pkgs.ruff];
-        text = ''
-          ruff format -
-        '';
-      };
     };
   };
 
@@ -230,7 +219,7 @@ in {
       enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.python.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Python LSP server to use";
       };
@@ -240,15 +229,9 @@ in {
       enable = mkEnableOption "Python formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.python.format.type" (enum (attrNames formats));
         default = defaultFormat;
-        description = "Python formatter to use";
+        description = "Python formatters to use";
-      };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Python formatter package";
       };
     };
 
@@ -316,21 +299,25 @@ in {
     })
 
     (mkIf cfg.format.enable {
-      vim.formatter.conform-nvim = {
+      vim.formatter.conform-nvim = let
+        names = flatten (map (type:
+          if type == "black-and-isort"
+          then
+            warn ''
+              vim.languages.python.format.type: "black-and-isort" is deprecated,
+              use `["black" "isort"]` instead.
+            '' ["black" "isort"]
+          else type)
+        cfg.format.type);
+      in {
         enable = true;
-        # HACK: I'm planning to remove these soon so I just took the easiest way out
+        setupOpts.formatters_by_ft.python = names;
-        setupOpts.formatters_by_ft.python =
-          if cfg.format.type == "black-and-isort"
-          then ["black"]
-          else [cfg.format.type];
         setupOpts.formatters =
-          if (cfg.format.type == "black-and-isort")
+          mapListToAttrs (name: {
-          then {
+            inherit name;
-            black.command = "${cfg.format.package}/bin/black";
+            value = formats.${name};
-          }
+          })
-          else {
+          names;
-            ${cfg.format.type}.command = getExe cfg.format.package;
-          };
       };
     })
 

modules/plugins/languages/qml.nix

@@ -5,11 +5,11 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.meta) getExe getExe';
+  inherit (lib.meta) getExe';
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.qml;
@@ -28,11 +28,9 @@
   defaultFormat = "qmlformat";
   formats = {
     qmlformat = {
-      package = pkgs.writeShellApplication {
+      command = "${qmlPackage}/bin/qmlformat";
-        name = "qmlformat";
+      args = ["-i" "$FILENAME"];
-        runtimeInputs = [qmlPackage];
+      stdin = false;
-        text = "qmlformat -";
-      };
     };
   };
 in {
@@ -46,7 +44,7 @@ in {
     lsp = {
       enable = mkEnableOption "QML LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.qml.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "QML LSP server to use";
       };
@@ -56,16 +54,10 @@ in {
       enable = mkEnableOption "QML formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.qml.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "QML formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "QML formatter package";
-      };
     };
   };
 
@@ -88,10 +80,13 @@ in {
     (mkIf (cfg.format.enable && !cfg.lsp.enable) {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.qml = [cfg.format.type];
+        setupOpts.formatters_by_ft.qml = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
   ]);

modules/plugins/languages/r.nix

@@ -7,9 +7,9 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
 
@@ -19,35 +19,31 @@
     packages = [pkgs.rPackages.languageserver];
   };
 
-  defaultFormat = "format_r";
+  defaultFormat = ["format_r"];
   formats = {
     styler = {
-      package = pkgs.rWrapper.override {
+      command = let
-        packages = [pkgs.rPackages.styler];
+        pkg = pkgs.rWrapper.override {packages = [pkgs.rPackages.styler];};
-      };
+      in "${pkg}/bin/R";
-      config = {
-        command = "${cfg.format.package}/bin/R";
-      };
     };
 
     format_r = {
-      package = pkgs.rWrapper.override {
+      command = let
-        packages = [pkgs.rPackages.formatR];
+        pkg = pkgs.rWrapper.override {
-      };
+          packages = [pkgs.rPackages.formatR];
-      config = {
+        };
-        command = "${cfg.format.package}/bin/R";
+      in "${pkg}/bin/R";
-        stdin = true;
+      stdin = true;
-        args = [
+      args = [
-          "--slave"
+        "--slave"
-          "--no-restore"
+        "--no-restore"
-          "--no-save"
+        "--no-save"
-          "-s"
+        "-s"
-          "-e"
+        "-e"
-          ''formatR::tidy_source(source="stdin")''
+        ''formatR::tidy_source(source="stdin")''
-        ];
+      ];
-        # TODO: range_args seem to be possible
+      # TODO: range_args seem to be possible
-        # https://github.com/nvimtools/none-ls.nvim/blob/main/lua/null-ls/builtins/formatting/format_r.lua
+      # https://github.com/nvimtools/none-ls.nvim/blob/main/lua/null-ls/builtins/formatting/format_r.lua
-      };
     };
   };
 
@@ -77,7 +73,7 @@ in {
       enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.r.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "R LSP server to use";
       };
@@ -87,16 +83,10 @@ in {
       enable = mkEnableOption "R formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.r.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "R formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "R formatter package";
-      };
     };
   };
 
@@ -109,8 +99,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.r = [cfg.format.type];
+        setupOpts.formatters_by_ft.r = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+        setupOpts.formatters =
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/ruby.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
-  inherit (lib.types) package enum;
+  inherit (lib.types) enum;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.ruby;
@@ -49,11 +49,10 @@
 
   # testing
 
-  defaultFormat = "rubocop";
+  defaultFormat = ["rubocop"];
   formats = {
     rubocop = {
-      # TODO: is this right?
+      command = getExe pkgs.rubyPackages.rubocop;
-      package = pkgs.rubyPackages.rubocop;
     };
   };
 
@@ -77,7 +76,7 @@ in {
       enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.ruby.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Ruby LSP server to use";
       };
@@ -87,16 +86,10 @@ in {
       enable = mkEnableOption "Ruby formatter support" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.ruby.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Ruby formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Ruby formatter package";
-      };
     };
 
     extraDiagnostics = {
@@ -130,10 +123,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.ruby = [cfg.format.type];
+        setupOpts.formatters_by_ft.ruby = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/rust.nix

@@ -12,16 +12,17 @@
   inherit (lib.trivial) boolToString;
   inherit (lib.lists) isList;
   inherit (lib.types) bool package str listOf either enum;
-  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.lua) expToLua;
   inherit (lib.nvim.dag) entryAfter entryAnywhere;
 
   cfg = config.vim.languages.rust;
 
-  defaultFormat = "rustfmt";
+  defaultFormat = ["rustfmt"];
   formats = {
     rustfmt = {
-      package = pkgs.rustfmt;
+      command = getExe pkgs.rustfmt;
     };
   };
 in {
@@ -79,15 +80,9 @@ in {
 
       type = mkOption {
         description = "Rust formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.rust.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "Rust formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
 
     dap = {
@@ -130,10 +125,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.rust = [cfg.format.type];
+        setupOpts.formatters_by_ft.rust = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/sql.nix

@@ -9,7 +9,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum package str;
-  inherit (lib.nvim.types) diagnostics singleOrListOf;
+  inherit (lib.nvim.types) diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
 
@@ -33,14 +33,11 @@
     };
   };
 
-  defaultFormat = "sqlfluff";
+  defaultFormat = ["sqlfluff"];
   formats = {
     sqlfluff = {
-      package = sqlfluffDefault;
+      command = getExe sqlfluffDefault;
-      config = {
+      append_args = ["--dialect=${cfg.dialect}"];
-        command = getExe cfg.format.package;
-        append_args = ["--dialect=${cfg.dialect}"];
-      };
     };
   };
 
@@ -78,7 +75,7 @@ in {
       enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.sql.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "SQL LSP server to use";
       };
@@ -88,16 +85,10 @@ in {
       enable = mkEnableOption "SQL formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.sql.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "SQL formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "SQL formatter package";
-      };
     };
 
     extraDiagnostics = {
@@ -133,8 +124,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.sql = [cfg.format.type];
+        setupOpts.formatters_by_ft.sql = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = formats.${cfg.format.type}.config;
+        setupOpts.formatters =
+          mapListToAttrs (name: {
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/svelte.nix

@@ -8,8 +8,8 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
-  inherit (lib.types) enum package;
+  inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
 
@@ -53,19 +53,6 @@
     };
   };
 
-  # TODO: specify packages
-  defaultFormat = "prettier";
-  formats = {
-    prettier = {
-      package = pkgs.prettier;
-    };
-
-    biome = {
-      package = pkgs.biome;
-    };
-  };
-
-  # TODO: specify packages
   defaultDiagnosticsProvider = ["eslint_d"];
   diagnosticsProviders = {
     eslint_d = let
@@ -99,28 +86,12 @@ in {
       enable = mkEnableOption "Svelte LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.svelte.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Svelte LSP server to use";
       };
     };
 
-    format = {
-      enable = mkEnableOption "Svelte formatting" // {default = config.vim.languages.enableFormat;};
-
-      type = mkOption {
-        type = enum (attrNames formats);
-        default = defaultFormat;
-        description = "Svelte formatter to use";
-      };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Svelte formatter package";
-      };
-    };
-
     extraDiagnostics = {
       enable = mkEnableOption "extra Svelte diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
 
@@ -147,16 +118,6 @@ in {
         cfg.lsp.servers;
     })
 
-    (mkIf cfg.format.enable {
-      vim.formatter.conform-nvim = {
-        enable = true;
-        setupOpts.formatters_by_ft.svelte = [cfg.format.type];
-        setupOpts.formatters.${cfg.format.type} = {
-          command = getExe cfg.format.package;
-        };
-      };
-    })
-
     (mkIf cfg.extraDiagnostics.enable {
       vim.diagnostics.nvim-lint = {
         enable = true;

modules/plugins/languages/tailwind.nix

@@ -10,7 +10,7 @@
   inherit (lib.meta) getExe;
   inherit (lib.types) enum;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) singleOrListOf;
+  inherit (lib.nvim.types) deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
 
   cfg = config.vim.languages.tailwind;
@@ -154,7 +154,7 @@ in {
       enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.tailwind.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Tailwindcss LSP server to use";
       };

modules/plugins/languages/ts.nix

@@ -12,7 +12,7 @@
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere entryBefore;
 
   cfg = config.vim.languages.ts;
@@ -176,18 +176,18 @@
   '';
 
   # TODO: specify packages
-  defaultFormat = "prettier";
+  defaultFormat = ["prettier"];
   formats = {
     prettier = {
-      package = pkgs.prettier;
+      command = getExe pkgs.prettier;
     };
 
     prettierd = {
-      package = pkgs.prettierd;
+      command = getExe pkgs.prettierd;
     };
 
     biome = {
-      package = pkgs.biome;
+      command = getExe pkgs.biome;
     };
   };
 
@@ -228,7 +228,7 @@ in {
       enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.ts.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Typescript/Javascript LSP server to use";
       };
@@ -239,15 +239,9 @@ in {
 
       type = mkOption {
         description = "Typescript/Javascript formatter to use";
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.ts.format.type" (enum (attrNames formats));
         default = defaultFormat;
       };
-
-      package = mkOption {
-        description = "Typescript/Javascript formatter package";
-        type = package;
-        default = formats.${cfg.format.type}.package;
-      };
     };
 
     extraDiagnostics = {
@@ -309,12 +303,15 @@ in {
       vim.formatter.conform-nvim = {
         enable = true;
         setupOpts = {
-          formatters_by_ft.typescript = [cfg.format.type];
+          formatters_by_ft.typescript = cfg.format.type;
           # .tsx files
-          formatters_by_ft.typescriptreact = [cfg.format.type];
+          formatters_by_ft.typescriptreact = cfg.format.type;
-          formatters.${cfg.format.type} = {
+          setupOpts.formatters =
-            command = getExe cfg.format.package;
+            mapListToAttrs (name: {
-          };
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
         };
       };
     })

modules/plugins/languages/typst.nix

@@ -9,7 +9,7 @@
   inherit (lib.types) nullOr enum attrsOf listOf package str;
   inherit (lib.attrsets) attrNames;
   inherit (lib.meta) getExe;
-  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAnywhere;
   inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.attrsets) mapListToAttrs;
@@ -91,14 +91,14 @@
     };
   };
 
-  defaultFormat = "typstfmt";
+  defaultFormat = ["typstfmt"];
   formats = {
     typstfmt = {
-      package = pkgs.typstfmt;
+      command = getExe pkgs.typstfmt;
     };
     # https://github.com/Enter-tainer/typstyle
     typstyle = {
-      package = pkgs.typstyle;
+      command = getExe pkgs.typstyle;
     };
   };
 in {
@@ -114,7 +114,7 @@ in {
       enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.typst.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Typst LSP server to use";
       };
@@ -124,16 +124,10 @@ in {
       enable = mkEnableOption "Typst document formatting" // {default = config.vim.languages.enableFormat;};
 
       type = mkOption {
-        type = enum (attrNames formats);
+        type = deprecatedSingleOrListOf "vim.language.typst.format.type" (enum (attrNames formats));
         default = defaultFormat;
         description = "Typst formatter to use";
       };
-
-      package = mkOption {
-        type = package;
-        default = formats.${cfg.format.type}.package;
-        description = "Typst formatter package";
-      };
     };
 
     extensions = {
@@ -189,10 +183,13 @@ in {
     (mkIf cfg.format.enable {
       vim.formatter.conform-nvim = {
         enable = true;
-        setupOpts.formatters_by_ft.typst = [cfg.format.type];
+        setupOpts.formatters_by_ft.typst = cfg.format.type;
-        setupOpts.formatters.${cfg.format.type} = {
+        setupOpts.formatters =
-          command = getExe cfg.format.package;
+          mapListToAttrs (name: {
-        };
+            inherit name;
+            value = formats.${name};
+          })
+          cfg.format.type;
       };
     })
 

modules/plugins/languages/vala.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
 
@@ -73,7 +73,7 @@ in {
     lsp = {
       enable = mkEnableOption "Vala LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.vala.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Vala LSP server to use";
       };

modules/plugins/languages/wgsl.nix

@@ -6,7 +6,7 @@
 }: let
   inherit (builtins) attrNames;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) enum;
   inherit (lib.meta) getExe;
@@ -37,7 +37,7 @@ in {
       enable = mkEnableOption "WGSL LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.wgsl.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "WGSL LSP server to use";
       };

modules/plugins/languages/yaml.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.types) enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.yaml;
@@ -56,7 +56,7 @@ in {
     lsp = {
       enable = mkEnableOption "Yaml LSP support" // {default = config.vim.lsp.enable;};
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.yaml.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Yaml LSP server to use";
       };

modules/plugins/languages/zig.nix

@@ -8,7 +8,7 @@
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge mkDefault;
   inherit (lib.types) bool package enum;
-  inherit (lib.nvim.types) mkGrammarOption singleOrListOf;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -67,7 +67,7 @@ in {
       enable = mkEnableOption "Zig LSP support" // {default = config.vim.lsp.enable;};
 
       servers = mkOption {
-        type = singleOrListOf (enum (attrNames servers));
+        type = deprecatedSingleOrListOf "vim.language.zig.lsp.servers" (enum (attrNames servers));
         default = defaultServers;
         description = "Zig LSP server to use";
       };