Merge remote-tracking branch 'upstream/main' into vue_language_server

modules/plugins/languages/arduino.nix

@@ -0,0 +1,95 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.meta) getExe getExe';
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum listOf str;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.arduino;
+
+  defaultServers = ["arduino-language-server"];
+  servers = {
+    arduino-language-server = {
+      enable = true;
+      cmd =
+        [
+          (getExe pkgs.arduino-language-server)
+          "-clangd"
+          (getExe' pkgs.clang-tools "clangd")
+          "-cli"
+          (getExe pkgs.arduino-cli)
+          "-cli-config"
+          "$HOME/.arduino15/arduino-cli.yaml"
+        ]
+        ++ cfg.lsp.extraArgs;
+      filetypes = ["arduino"];
+      root_dir =
+        mkLuaInline
+        /*
+        lua
+        */
+        ''
+          function(bufnr, on_dir)
+            local fname = vim.api.nvim_buf_get_name(bufnr)
+            on_dir(util.root_pattern("*.ino")(fname))
+          end
+        '';
+      capabilities = {
+        textDocument = {
+          semanticTokens = mkLuaInline "vim.NIL";
+        };
+        workspace = {
+          semanticTokens = mkLuaInline "vim.NIL";
+        };
+      };
+    };
+  };
+in {
+  options.vim.languages.arduino = {
+    enable = mkEnableOption "Arduino support";
+
+    treesitter = {
+      enable = mkEnableOption "Arduino treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "arduino";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Arduino LSP support" // {default = config.vim.lsp.enable;};
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+        description = "Arduino LSP servers to use";
+      };
+
+      extraArgs = mkOption {
+        type = listOf str;
+        default = [];
+        description = "Extra arguments passed to the Arduino LSP";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
+    })
+  ]);
+}

modules/plugins/languages/clang.nix

@@ -97,7 +97,7 @@
           local function symbol_info()
             local bufnr = vim.api.nvim_get_current_buf()
             local clangd_client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd" })[1]
-            if not clangd_client or not clangd_client.supports_method 'textDocument/symbolInfo' then
+            if not clangd_client or not clangd_client:supports_method 'textDocument/symbolInfo' then
               return vim.notify('Clangd client not found', vim.log.levels.ERROR)
             end
             local win = vim.api.nvim_get_current_win()

modules/plugins/languages/cmake.nix

@@ -0,0 +1,96 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.types) enum listOf package;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.cmake;
+
+  defaultServers = ["neocmakelsp"];
+  servers = {
+    neocmakelsp = {
+      enable = true;
+      cmd = [(getExe pkgs.neocmakelsp) "--stdio"];
+      filetypes = ["cmake"];
+      root_markers = [".gersemirc" ".git" "build" "cmake"];
+      capabilities = {
+        textDocument.completion.completionItem.snippetSupport = true;
+      };
+    };
+  };
+
+  defaultFormat = "gersemi";
+  formats = {
+    gersemi = {
+      package = pkgs.gersemi;
+    };
+  };
+in {
+  options.vim.languages.cmake = {
+    enable = mkEnableOption "CMake language support";
+
+    treesitter = {
+      enable = mkEnableOption "CMake treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "cmake";
+    };
+
+    lsp = {
+      enable = mkEnableOption "CMake LSP support" // {default = config.vim.lsp.enable;};
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+        description = "CMake LSP servers to use";
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "CMake formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "CMake formatter to use";
+        type = enum (attrNames formats);
+        default = defaultFormat;
+      };
+
+      package = mkOption {
+        description = "CMake formatter package";
+        type = package;
+        default = formats.${cfg.format.type}.package;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts.formatters_by_ft.cmake = [cfg.format.type];
+        setupOpts.formatters.${cfg.format.type} = {
+          command = getExe cfg.format.package;
+        };
+      };
+    })
+  ]);
+}

modules/plugins/languages/default.nix

@@ -3,6 +3,7 @@
   inherit (lib.nvim.languages) mkEnable;
 in {
   imports = [
+    ./arduino.nix
     ./asm.nix
     ./astro.nix
     ./bash.nix
@@ -10,17 +11,23 @@ in {
     ./dart.nix
     ./clang.nix
     ./clojure.nix
+    ./cmake.nix
     ./css.nix
     ./elixir.nix
+    ./elm.nix
     ./fsharp.nix
     ./gleam.nix
+    ./glsl.nix
     ./go.nix
     ./hcl.nix
     ./helm.nix
     ./kotlin.nix
     ./html.nix
+    ./tera.nix
+    ./twig.nix
     ./haskell.nix
     ./java.nix
+    ./jinja.nix
     ./json.nix
     ./lua.nix
     ./markdown.nix
@@ -51,6 +58,9 @@ in {
     ./ruby.nix
     ./just.nix
     ./vue.nix
+    ./make.nix
+    ./xml.nix
+    ./fluent.nix
 
     # This is now a hard deprecation.
     (mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])

modules/plugins/languages/elm.nix

@@ -0,0 +1,74 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.types) enum;
+  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.elm;
+
+  defaultServers = ["elm-language-server"];
+  servers = {
+    elm-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.elmPackages.elm-language-server)];
+      filetypes = ["elm"];
+      root_markers = ["elm.json"];
+      workspace_required = false;
+    };
+  };
+in {
+  options.vim.languages.elm = {
+    enable = mkEnableOption "Elm language support";
+
+    treesitter = {
+      enable =
+        mkEnableOption "Elm treesitter"
+        // {
+          default = config.vim.languages.enableTreesitter;
+        };
+      package = mkGrammarOption pkgs "elm";
+    };
+
+    lsp = {
+      enable =
+        mkEnableOption "Elm LSP support"
+        // {
+          default = config.vim.lsp.enable;
+        };
+
+      servers = mkOption {
+        type = deprecatedSingleOrListOf "vim.language.elm.lsp.servers" (enum (attrNames servers));
+        default = defaultServers;
+        description = "Elm LSP servers to use";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter = {
+        enable = true;
+        grammars = [cfg.treesitter.package];
+      };
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim = {
+        lsp.servers =
+          mapListToAttrs (n: {
+            name = n;
+            value = servers.${n};
+          })
+          cfg.lsp.servers;
+      };
+    })
+  ]);
+}

modules/plugins/languages/fluent.nix

@@ -0,0 +1,34 @@
+{
+  config,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.modules) mkIf;
+
+  cfg = config.vim.languages.fluent;
+in {
+  options.vim.languages.fluent = {
+    enable = mkEnableOption "Fluent language support";
+  };
+
+  config = mkIf cfg.enable {
+    vim = {
+      lazy.plugins.fluent-nvim = {
+        package = "fluent-nvim";
+        ft = ["fluent"];
+      };
+      autocmds = [
+        {
+          event = [
+            "BufRead"
+            "BufNewFile"
+          ];
+          pattern = ["*.ftl"];
+          desc = "Set fluent filetype";
+          command = "set filetype=fluent";
+        }
+      ];
+    };
+  };
+}

modules/plugins/languages/glsl.nix

@@ -0,0 +1,63 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum listOf;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.glsl;
+
+  defaultServers = ["glsl_analyzer"];
+  servers = {
+    glsl_analyzer = {
+      enable = true;
+      cmd = [(getExe pkgs.glsl_analyzer)];
+      filetypes = ["glsl" "vert" "tesc" "tese" "frag" "geom" "comp"];
+      root_markers = [".git"];
+    };
+  };
+in {
+  options.vim.languages.glsl = {
+    enable = mkEnableOption "GLSL language support";
+
+    treesitter = {
+      enable = mkEnableOption "GLSL treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "glsl";
+    };
+
+    lsp = {
+      enable = mkEnableOption "GLSL LSP support" // {default = config.vim.lsp.enable;};
+
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+        description = "GLSL LSP server to use";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter = {
+        enable = true;
+        grammars = [cfg.treesitter.package];
+      };
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
+    })
+  ]);
+}

modules/plugins/languages/go.nix

@@ -1,16 +1,17 @@
 {
+  inputs,
   config,
   pkgs,
   lib,
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.options) mkEnableOption mkOption literalMD;
+  inherit (lib.options) mkEnableOption mkOption literalMD literalExpression;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.generators) mkLuaInline;
-  inherit (lib.types) bool enum package;
-  inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.types) bool enum package str;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics deprecatedSingleOrListOf mkPluginSetupOption;
   inherit (lib.nvim.dag) entryAfter;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -20,7 +21,7 @@
   servers = {
     gopls = {
       cmd = [(getExe pkgs.gopls)];
-      filetypes = ["go" "gomod" "gowork" "gotmpl"];
+      filetypes = ["go" "gomod" "gosum" "gowork" "gotmpl"];
       root_dir = mkLuaInline ''
         function(bufnr, on_dir)
           local fname = vim.api.nvim_buf_get_name(bufnr)
@@ -64,9 +65,11 @@
     gofmt = {
       command = "${pkgs.go}/bin/gofmt";
     };
+
     gofumpt = {
       command = getExe pkgs.gofumpt;
     };
+
     golines = {
       command = "${pkgs.golines}/bin/golines";
     };
@@ -78,18 +81,117 @@
       package = pkgs.delve;
     };
   };
+
+  defaultDiagnosticsProvider = ["golangci-lint"];
+  diagnosticsProviders = {
+    golangci-lint = let
+      pkg = pkgs.golangci-lint;
+    in {
+      package = pkg;
+      config = {
+        cmd = getExe pkg;
+        args = [
+          "run"
+          "--output.json.path=stdout"
+          "--issues-exit-code=0"
+          "--show-stats=false"
+          "--fix=false"
+          "--path-mode=abs"
+          # Overwrite values that could be configured and result in unwanted writes
+          "--output.text.path="
+          "--output.tab.path="
+          "--output.html.path="
+          "--output.checkstyle.path="
+          "--output.code-climate.path="
+          "--output.junit-xml.path="
+          "--output.teamcity.path="
+          "--output.sarif.path="
+        ];
+        parser = mkLuaInline ''
+          function(output, bufnr)
+            local SOURCE = "golangci-lint";
+
+            local function display_tool_error(msg)
+              return{
+                {
+                  bufnr = bufnr,
+                  lnum = 0,
+                  col = 0,
+                  message = string.format("[%s] %s", SOURCE, msg),
+                  severity = vim.diagnostic.severity.ERROR,
+                  source = SOURCE,
+                },
+              }
+            end
+
+            if output == "" then
+              return display_tool_error("no output provided")
+            end
+
+            local ok, decoded = pcall(vim.json.decode, output)
+            if not ok then
+              return display_tool_error("failed to parse JSON output")
+            end
+
+            if not decoded or not decoded.Issues then
+              return display_tool_error("unexpected output format")
+            end
+
+            local severity_map = {
+              error   = vim.diagnostic.severity.ERROR,
+              warning = vim.diagnostic.severity.WARN,
+              info    = vim.diagnostic.severity.INFO,
+              hint    = vim.diagnostic.severity.HINT,
+            }
+            local diagnostics = {}
+            for _, issue in ipairs(decoded.Issues) do
+              local sev = vim.diagnostic.severity.ERROR
+              if issue.Severity and issue.Severity ~= "" then
+                local normalized = issue.Severity:lower()
+                sev = severity_map[normalized] or vim.diagnostic.severity.ERROR
+              end
+              table.insert(diagnostics, {
+                bufnr = bufnr,
+                lnum = issue.Pos.Line - 1,
+                col = issue.Pos.Column - 1,
+                message = issue.Text,
+                code = issue.FromLinter,
+                severity = sev,
+                source = SOURCE,
+              })
+            end
+            return diagnostics
+          end
+        '';
+      };
+    };
+  };
 in {
   options.vim.languages.go = {
     enable = mkEnableOption "Go language support";
 
     treesitter = {
-      enable = mkEnableOption "Go treesitter" // {default = config.vim.languages.enableTreesitter;};
+      enable =
+        mkEnableOption "Go treesitter"
+        // {
+          default = config.vim.languages.enableTreesitter;
+          defaultText = literalExpression "config.vim.languages.enableTreesitter";
+        };
 
-      package = mkGrammarOption pkgs "go";
+      goPackage = mkGrammarOption pkgs "go";
+      gomodPackage = mkGrammarOption pkgs "gomod";
+      gosumPackage = mkGrammarOption pkgs "gosum";
+      goworkPackage = mkGrammarOption pkgs "gowork";
+      gotmplPackage = mkGrammarOption pkgs "gotmpl";
     };
 
     lsp = {
-      enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;};
+      enable =
+        mkEnableOption "Go LSP support"
+        // {
+          default = config.vim.lsp.enable;
+          defaultText = literalExpression "config.vim.lsp.enable";
+        };
 
       servers = mkOption {
         type = deprecatedSingleOrListOf "vim.language.go.lsp.servers" (enum (attrNames servers));
@@ -109,37 +211,111 @@ in {
         };
 
       type = mkOption {
-        description = "Go formatter to use";
         type = deprecatedSingleOrListOf "vim.language.go.format.type" (enum (attrNames formats));
         default = defaultFormat;
+        description = "Go formatter to use";
       };
     };
 
     dap = {
-      enable = mkOption {
-        description = "Enable Go Debug Adapter via nvim-dap-go plugin";
-        type = bool;
-        default = config.vim.languages.enableDAP;
-      };
+      enable =
+        mkEnableOption "Go Debug Adapter (DAP) via `nvim-dap-go"
+        // {
+          default = config.vim.languages.enableDAP;
+          defaultText = literalExpression "config.vim.languages.enableDAP";
+        };
 
       debugger = mkOption {
-        description = "Go debugger to use";
         type = enum (attrNames debuggers);
         default = defaultDebugger;
+        description = "Go debugger to use";
       };
 
       package = mkOption {
-        description = "Go debugger package.";
         type = package;
         default = debuggers.${cfg.dap.debugger}.package;
+        description = "Go debugger package.";
+      };
+    };
+
+    extraDiagnostics = {
+      enable =
+        mkEnableOption "extra Go diagnostics"
+        // {
+          default = config.vim.languages.enableExtraDiagnostics;
+          defaultText = literalExpression "config.vim.languages.enableExtraDiagnostic";
+        };
+
+      types = diagnostics {
+        langDesc = "Go";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+
+    extensions = {
+      gopher-nvim = {
+        enable = mkEnableOption "Minimalistic plugin for Go development";
+        setupOpts = mkPluginSetupOption "gopher-nvim" {
+          commands = {
+            go = mkOption {
+              type = str;
+              default = "go";
+              description = "Go binary to use";
+            };
+
+            gomodifytags = mkOption {
+              type = str;
+              default = getExe pkgs.gomodifytags;
+              defaultText = literalExpression "getExe pkgs.gomodifytags";
+              description = "gomodifytags binary to use";
+            };
+
+            gotests = mkOption {
+              type = str;
+              default = getExe pkgs.gotests;
+              defaultText = literalExpression "getExe pkgs.gotests";
+              description = "gotests binary to use";
+            };
+
+            impl = mkOption {
+              type = str;
+              default = getExe pkgs.impl;
+              defaultText = literalExpression "getExe pkgs.impl";
+              description = "impl binary to use";
+            };
+
+            iferr = mkOption {
+              type = str;
+              default = getExe pkgs.iferr;
+              defaultText = literalExpression "getExe pkgs.iferr";
+              description = "iferr binary to use";
+            };
+
+            json2go = mkOption {
+              type = str;
+              default = getExe inputs.self.packages.${pkgs.stdenv.hostPlatform.system}.json2go;
+              defaultText = literalExpression "getExe inputs.self.packages.$${pkgs.stdenv.hostPlatform.system}.json2go";
+              description = "json2go binary to use";
+            };
+          };
+        };
       };
     };
   };
 
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.treesitter.enable {
-      vim.treesitter.enable = true;
-      vim.treesitter.grammars = [cfg.treesitter.package];
+      vim.treesitter = {
+        enable = true;
+        grammars = [
+          cfg.treesitter.goPackage
+          cfg.treesitter.gomodPackage
+          cfg.treesitter.gosumPackage
+          cfg.treesitter.goworkPackage
+          cfg.treesitter.gotmplPackage
+        ];
+      };
     })
 
     (mkIf cfg.lsp.enable {
@@ -179,5 +355,24 @@ in {
         debugger.nvim-dap.enable = true;
       };
     })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.go = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
+
+    (mkIf cfg.extensions.gopher-nvim.enable {
+      vim.lazy.plugins.gopher-nvim = {
+        package = "gopher-nvim";
+        setupModule = "gopher";
+        inherit (cfg.extensions.gopher-nvim) setupOpts;
+        ft = ["go"];
+      };
+    })
   ]);
 }

modules/plugins/languages/haskell.nix

@@ -57,7 +57,7 @@
       settings = {
         haskell = {
           formattingProvider = "ormolu";
-          cabalFormattingProvider = "cabalfmt";
+          cabalFormattingProvider = "cabal-fmt";
         };
       };
     };

modules/plugins/languages/hcl.nix

@@ -76,9 +76,14 @@ in {
           end
         })
 
-        local ft = require('Comment.ft')
-        ft
-          .set('hcl', '#%s')
+         ${
+          if config.vim.comments.comment-nvim.enable
+          then ''
+            local ft = require('Comment.ft')
+            ft.set('hcl', '#%s')
+          ''
+          else ""
+        }
       '';
     }
     (mkIf cfg.treesitter.enable {

modules/plugins/languages/jinja.nix

@@ -0,0 +1,65 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.types) enum listOf;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.jinja;
+  defaultServers = ["jinja-lsp"];
+  servers = {
+    jinja-lsp = {
+      enable = true;
+      cmd = [(getExe pkgs.jinja-lsp)];
+      filetypes = ["jinja"];
+      root_markers = [
+        ".git"
+      ];
+    };
+  };
+in {
+  options.vim.languages.jinja = {
+    enable = mkEnableOption "Jinja template language support";
+
+    treesitter = {
+      enable = mkEnableOption "Jinja treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "jinja";
+      inlinePackage = mkGrammarOption pkgs "jinja_inline";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Jinja LSP support" // {default = config.vim.lsp.enable;};
+      servers = mkOption {
+        description = "Jinja LSP server to use";
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [
+        cfg.treesitter.package
+        cfg.treesitter.inlinePackage
+      ];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
+    })
+  ]);
+}

modules/plugins/languages/json.nix

@@ -18,7 +18,7 @@
   servers = {
     jsonls = {
       cmd = [(getExe' pkgs.vscode-langservers-extracted "vscode-json-language-server") "--stdio"];
-      filetypes = ["json" "jsonc"];
+      filetypes = ["json" "jsonc" "json5"];
       init_options = {provideFormatter = true;};
       root_markers = [".git"];
     };
@@ -39,7 +39,8 @@ in {
     treesitter = {
       enable = mkEnableOption "JSON treesitter" // {default = config.vim.languages.enableTreesitter;};
 
-      package = mkGrammarOption pkgs "json";
+      jsonPackage = mkGrammarOption pkgs "json";
+      json5Package = mkGrammarOption pkgs "json5";
     };
 
     lsp = {
@@ -66,7 +67,10 @@ in {
   config = mkIf cfg.enable (mkMerge [
     (mkIf cfg.treesitter.enable {
       vim.treesitter.enable = true;
-      vim.treesitter.grammars = [cfg.treesitter.package];
+      vim.treesitter.grammars = [
+        cfg.treesitter.jsonPackage
+        cfg.treesitter.json5Package
+      ];
     })
 
     (mkIf cfg.lsp.enable {
@@ -83,6 +87,7 @@ in {
         enable = true;
         setupOpts = {
           formatters_by_ft.json = cfg.format.type;
+          formatters_by_ft.json5 = cfg.format.type;
           formatters =
             mapListToAttrs (name: {
               inherit name;

modules/plugins/languages/lua.nix

@@ -9,7 +9,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.meta) getExe;
   inherit (lib.types) bool enum listOf;
-  inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) diagnostics mkGrammarOption;
   inherit (lib.nvim.dag) entryBefore;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
@@ -46,6 +46,9 @@
     luacheck = {
       package = pkgs.luajitPackages.luacheck;
     };
+    selene = {
+      package = pkgs.selene;
+    };
   };
 in {
   imports = [
@@ -79,7 +82,7 @@ in {
         description = "Enable Lua formatting";
       };
       type = mkOption {
-        type = deprecatedSingleOrListOf "vim.language.lua.format.type" (enum (attrNames formats));
+        type = listOf (enum (attrNames formats));
         default = defaultFormat;
         description = "Lua formatter to use";
       };

modules/plugins/languages/make.nix

@@ -0,0 +1,93 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.meta) getExe;
+  inherit (lib.types) listOf enum;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.make;
+
+  defaultFormat = ["bake"];
+  formats = {
+    bake = {
+      command = "${pkgs.mbake}/bin/mbake";
+    };
+  };
+
+  defaultDiagnosticsProvider = ["checkmake"];
+  diagnosticsProviders = {
+    checkmake = {
+      config = {
+        cmd = getExe pkgs.checkmake;
+      };
+    };
+  };
+in {
+  options.vim.languages.make = {
+    enable = mkEnableOption "Make support";
+
+    treesitter = {
+      enable = mkEnableOption "Make treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "make";
+    };
+
+    format = {
+      enable = mkEnableOption "Make formatting" // {default = config.vim.languages.enableFormat;};
+      type = mkOption {
+        description = "make formatter to use";
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Make diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Make";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter = {
+        enable = true;
+        grammars = [cfg.treesitter.package];
+      };
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft.make = cfg.format.type;
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.make = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
+  ]);
+}

modules/plugins/languages/markdown.nix

@@ -5,7 +5,7 @@
   ...
 }: let
   inherit (builtins) attrNames;
-  inherit (lib.meta) getExe;
+  inherit (lib.meta) getExe getExe';
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.types) bool enum listOf str nullOr;
@@ -55,6 +55,15 @@
     prettierd = {
       command = getExe pkgs.prettierd;
     };
+    mdformat = {
+      command = getExe' (pkgs.python313Packages.python.withPackages (p:
+        with p; [
+          mdformat
+          mdformat-gfm
+          mdformat-frontmatter
+          mdformat-footnote
+        ])) "mdformat";
+    };
   };
   defaultDiagnosticsProvider = ["markdownlint-cli2"];
   diagnosticsProviders = {

modules/plugins/languages/odin.nix

@@ -7,12 +7,15 @@
   inherit (builtins) attrNames;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum package;
+  inherit (lib.nvim.dag) entryAfter;
   inherit (lib.meta) getExe;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
+  cfg = config.vim.languages.odin;
+
   defaultServers = ["ols"];
   servers = {
     ols = {
@@ -32,7 +35,19 @@
     };
   };
 
-  cfg = config.vim.languages.odin;
+  defaultDebugger = "codelldb";
+  debuggers = {
+    codelldb = {
+      package = pkgs.lldb;
+      dapConfig = ''
+        dap.adapters.codelldb = {
+          type = 'executable',
+          command = '${cfg.dap.package}/bin/lldb-dap',
+          name = 'codelldb'
+        }
+      '';
+    };
+  };
 in {
   options.vim.languages.odin = {
     enable = mkEnableOption "Odin language support";
@@ -51,6 +66,22 @@ in {
         description = "Odin LSP server to use";
       };
     };
+
+    dap = {
+      enable = mkEnableOption "Enable Odin Debug Adapter" // {default = config.vim.languages.enableDAP;};
+
+      debugger = mkOption {
+        description = "Odin debugger to use";
+        type = enum (attrNames debuggers);
+        default = defaultDebugger;
+      };
+
+      package = mkOption {
+        description = "Odin debugger package.";
+        type = package;
+        default = debuggers.${cfg.dap.debugger}.package;
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -67,5 +98,18 @@ in {
         })
         cfg.lsp.servers;
     })
+
+    (mkIf cfg.dap.enable {
+      vim = {
+        startPlugins = ["nvim-dap-odin"];
+        debugger.nvim-dap.sources.odin-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
+        pluginRC.nvim-dap-odin = entryAfter ["nvim-dap"] ''
+          require('nvim-dap-odin').setup({
+            notifications = false -- contains no useful information
+          })
+        '';
+        debugger.nvim-dap.enable = true;
+      };
+    })
   ]);
 }

modules/plugins/languages/php.nix

@@ -4,11 +4,12 @@
   lib,
   ...
 }: let
-  inherit (builtins) attrNames;
+  inherit (builtins) attrNames toString;
   inherit (lib.options) mkEnableOption mkOption;
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
-  inherit (lib.types) enum;
+  inherit (lib.types) enum int attrs listOf;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.types) mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.generators) mkLuaInline;
@@ -64,6 +65,21 @@
       root_markers = ["composer.json" ".git"];
     };
   };
+
+  defaultFormat = ["php_cs_fixer"];
+  formats = {
+    php_cs_fixer = {
+      /*
+      Using 8.4 instead of 8.5 because of compatibility:
+      ```logs
+      2026-02-08 00:42:23[ERROR] Formatter 'php_cs_fixer' error: PHP CS Fixer 3.87.2
+      PHP runtime: 8.5.2
+      PHP CS Fixer currently supports PHP syntax only up to PHP 8.4, current PHP version: 8.5.2.
+      ```
+      */
+      command = "${pkgs.php84Packages.php-cs-fixer}/bin/php-cs-fixer";
+    };
+  };
 in {
   options.vim.languages.php = {
     enable = mkEnableOption "PHP language support";
@@ -82,6 +98,38 @@ in {
         description = "PHP LSP server to use";
       };
     };
+
+    format = {
+      enable = mkEnableOption "PHP formatting" // {default = config.vim.languages.enableFormat;};
+
+      type = mkOption {
+        description = "PHP formatter to use";
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+      };
+    };
+
+    dap = {
+      enable = mkEnableOption "Enable PHP Debug Adapter" // {default = config.vim.languages.enableDAP;};
+      xdebug = {
+        adapter = mkOption {
+          type = attrs;
+          default = {
+            type = "executable";
+            command = "${pkgs.nodePackages_latest.nodejs}/bin/node";
+            args = [
+              "${pkgs.vscode-extensions.xdebug.php-debug}/share/vscode/extensions/xdebug.php-debug/out/phpDebug.js"
+            ];
+          };
+          description = "XDebug adapter to use for nvim-dap";
+        };
+        port = mkOption {
+          type = int;
+          default = 9003;
+          description = "Port to use for XDebug";
+        };
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -98,5 +146,39 @@ in {
         })
         cfg.lsp.servers;
     })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft.php = cfg.format.type;
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
+
+    (mkIf cfg.dap.enable {
+      vim = {
+        debugger.nvim-dap = {
+          enable = true;
+          sources.php-debugger = ''
+            dap.adapters.xdebug = ${toLuaObject cfg.dap.xdebug.adapter}
+            dap.configurations.php = {
+              {
+                  type = 'xdebug',
+                  request = 'launch',
+                  name = 'Listen for XDebug',
+                  port = ${toString cfg.dap.xdebug.port},
+              },
+            }
+          '';
+        };
+      };
+    })
   ]);
 }

modules/plugins/languages/python.nix

@@ -11,7 +11,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum package bool;
   inherit (lib.nvim.attrsets) mapListToAttrs;
-  inherit (lib.nvim.types) deprecatedSingleOrListOf;
+  inherit (lib.nvim.types) deprecatedSingleOrListOf diagnostics;
   inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryBefore;
   inherit (lib.trivial) warn;
@@ -169,6 +169,22 @@
         ".git"
       ];
     };
+
+    zuban = {
+      enable = true;
+      cmd = [(getExe pkgs.zuban) "server"];
+      filetypes = ["python"];
+      root_markers = [
+        "pyproject.toml"
+        "setup.py"
+        "setup.cfg"
+        "requirements.txt"
+        "Pipfile"
+        ".git"
+        "mypy.ini"
+        ".mypy.ini"
+      ];
+    };
   };
 
   defaultFormat = ["black"];
@@ -262,6 +278,14 @@
       '';
     };
   };
+  defaultDiagnosticsProvider = ["mypy"];
+  diagnosticsProviders = {
+    mypy = {
+      config = {
+        cmd = getExe' pkgs.mypy "mypy";
+      };
+    };
+  };
 in {
   options.vim.languages.python = {
     enable = mkEnableOption "Python language support";
@@ -319,6 +343,15 @@ in {
         '';
       };
     };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Python diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Python";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -388,5 +421,15 @@ in {
       vim.debugger.nvim-dap.enable = true;
       vim.debugger.nvim-dap.sources.python-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
     })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.python = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
   ]);
 }

modules/plugins/languages/rust.nix

@@ -11,7 +11,7 @@
   inherit (lib.lists) isList;
   inherit (lib.attrsets) attrNames;
   inherit (lib.types) bool package str listOf either enum int;
-  inherit (lib.nvim.lua) expToLua toLuaObject;
+  inherit (lib.nvim.lua) toLuaObject;
   inherit (lib.nvim.attrsets) mapListToAttrs;
   inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption deprecatedSingleOrListOf;
   inherit (lib.nvim.dag) entryAfter entryAnywhere;
@@ -169,7 +169,7 @@ in {
             server = {
               cmd = ${
               if isList cfg.lsp.package
-              then expToLua cfg.lsp.package
+              then toLuaObject cfg.lsp.package
               else ''{"${cfg.lsp.package}/bin/rust-analyzer"}''
             },
               default_settings = {
@@ -228,10 +228,17 @@ in {
     (mkIf cfg.extensions.crates-nvim.enable {
       vim = mkMerge [
         {
-          startPlugins = ["crates-nvim"];
-          pluginRC.rust-crates = entryAnywhere ''
-            require("crates").setup(${toLuaObject cfg.extensions.crates-nvim.setupOpts})
-          '';
+          lazy.plugins.crates-nvim = {
+            package = "crates-nvim";
+            setupModule = "crates";
+            setupOpts = cfg.extensions.crates-nvim.setupOpts;
+            event = [
+              {
+                event = "BufRead";
+                pattern = "Cargo.toml";
+              }
+            ];
+          };
         }
       ];
     })

modules/plugins/languages/tera.nix

@@ -0,0 +1,28 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.types) mkGrammarOption;
+
+  cfg = config.vim.languages.tera;
+in {
+  options.vim.languages.tera = {
+    enable = mkEnableOption "Tera templating language support";
+
+    treesitter = {
+      enable = mkEnableOption "Tera treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "tera";
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+  ]);
+}

modules/plugins/languages/toml.nix

@@ -8,12 +8,12 @@
   inherit (lib.meta) getExe;
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.options) mkEnableOption mkOption;
-  inherit (lib.types) bool enum;
+  inherit (lib.types) enum;
   inherit (lib.nvim.types) diagnostics mkGrammarOption deprecatedSingleOrListOf;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.toml;
-  defaultServers = ["tombi"];
+  defaultServers = ["taplo"];
   servers = {
     tombi = {
       enable = true;
@@ -27,9 +27,21 @@
         ".git"
       ];
     };
+    taplo = {
+      enable = true;
+      cmd = [
+        (getExe pkgs.taplo)
+        "lsp"
+        "stdio"
+      ];
+      filetypes = ["toml"];
+      root_markers = [
+        ".git"
+      ];
+    };
   };
 
-  defaultFormat = ["tombi"];
+  defaultFormat = ["taplo"];
   formats = {
     tombi = {
       command = getExe pkgs.tombi;
@@ -40,6 +52,15 @@
         "-"
       ];
     };
+    taplo = {
+      command = getExe pkgs.taplo;
+      args = [
+        "format"
+        "--stdin-filepath"
+        "$FILENAME"
+        "-"
+      ];
+    };
   };
   defaultDiagnosticsProvider = ["tombi"];
   diagnosticsProviders = {

modules/plugins/languages/twig.nix

@@ -0,0 +1,120 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkEnableOption mkOption;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.meta) getExe;
+  inherit (lib.types) listOf enum;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.twig;
+
+  defaultServers = ["twig-language-server"];
+  servers = {
+    twig-language-server = {
+      enable = true;
+      cmd = [(getExe pkgs.twig-language-server) "--stdio"];
+      filetypes = ["twig"];
+      root_markers = [".git"];
+    };
+  };
+
+  defaultFormat = ["djlint"];
+  formats = {
+    djlint = {
+      command = getExe pkgs.djlint;
+    };
+    # TODO: if twig-cs-fixer gets packaged for nix, add it and default to it.
+  };
+  defaultDiagnosticsProvider = ["djlint"];
+  diagnosticsProviders = {
+    djlint = {
+      config = {
+        cmd = getExe pkgs.djlint;
+      };
+    };
+    # TODO: if curlylint gets packaged for nix, add it.
+  };
+in {
+  options.vim.languages.twig = {
+    enable = mkEnableOption "Twig templating language support";
+
+    treesitter = {
+      enable = mkEnableOption "Twig treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "twig";
+    };
+
+    lsp = {
+      enable = mkEnableOption "Twig LSP support" // {default = config.vim.lsp.enable;};
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+        description = "Twig LSP server to use";
+      };
+    };
+
+    format = {
+      enable = mkEnableOption "PHP formatting" // {default = config.vim.languages.enableFormat;};
+      type = mkOption {
+        description = "Twig formatter to use";
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Twig diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+      types = diagnostics {
+        langDesc = "Twig";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (n: {
+          name = n;
+          value = servers.${n};
+        })
+        cfg.lsp.servers;
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft.twig = cfg.format.type;
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.twig = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
+  ]);
+}

modules/plugins/languages/xml.nix

@@ -0,0 +1,62 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkOption mkEnableOption;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.types) enum listOf;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.xml;
+
+  defaultServers = ["lemminx"];
+  servers = {
+    lemminx = {
+      enable = true;
+      cmd = [
+        (getExe pkgs.lemminx)
+      ];
+      filetypes = ["xml"];
+      root_markers = [".git"];
+    };
+  };
+in {
+  options.vim.languages.xml = {
+    enable = mkEnableOption "XML language support";
+
+    treesitter = {
+      enable = mkEnableOption "XML treesitter" // {default = config.vim.languages.enableTreesitter;};
+      package = mkGrammarOption pkgs "xml";
+    };
+
+    lsp = {
+      enable = mkEnableOption "XML LSP support" // {default = config.vim.lsp.enable;};
+      servers = mkOption {
+        type = listOf (enum (attrNames servers));
+        default = defaultServers;
+        description = "XML LSP server to use";
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter.enable = true;
+      vim.treesitter.grammars = [cfg.treesitter.package];
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp.servers =
+        mapListToAttrs (name: {
+          inherit name;
+          value = servers.${name};
+        })
+        cfg.lsp.servers;
+    })
+  ]);
+}