Merge branch 'main' into fix/invalid-keys-in-haskell-tools

modules/plugins/languages/clang.nix

@@ -8,9 +8,12 @@
   inherit (lib.options) mkEnableOption mkOption literalExpression;
   inherit (lib.types) bool enum package listOf;
   inherit (lib) genAttrs;
+  inherit (lib.meta) getExe getExe';
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.generators) mkLuaInline;
   inherit (lib.nvim.dag) entryAfter;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.clang;
 
@@ -45,6 +48,54 @@
       '';
     };
   };
+
+  defaultFormat = ["clang-format"];
+  formats = {
+    astyle = {
+      command = getExe pkgs.astyle;
+      stdin = false;
+      args = mkLuaInline ''
+        function(self, ctx)
+          local args = {
+            "$FILENAME",
+          }
+
+          if not vim.bo[ctx.buf].expandtab then
+            table.insert(args, "--indent=tab=" .. ctx.shiftwidth)
+          else
+            table.insert(args, "--indent=spaces=" .. ctx.shiftwidth)
+          end
+
+          return args
+        end
+      '';
+    };
+    indent = {
+      command = getExe pkgs.indent;
+      stdin = true;
+      args = mkLuaInline ''
+        function(self, ctx)
+          local args = {
+            "--indent-level", ctx.shiftwidth,
+            "--tab-size", ctx.shiftwidth,
+          }
+
+          if not vim.bo[ctx.buf].expandtab then
+            table.insert(args, "--use-tabs")
+          else
+            table.insert(args, "--no-tabs")
+          end
+
+          return args
+        end
+      '';
+      # Default is GNU style. Nobody likes that one.
+      # This is under `append_args`, to allow easy editing of this argument,
+      # without having to redefine everything as a user.
+      append_args = ["--linux-style"];
+    };
+    clang-format.command = getExe' pkgs.clang-tools "clang-format";
+  };
 in {
   options.vim.languages.clang = {
     enable = mkEnableOption "C/C++ language support";
@@ -102,6 +153,21 @@ in {
         default = debuggers.${cfg.dap.debugger}.package;
       };
     };
+
+    format = {
+      enable =
+        mkEnableOption "C formatting"
+        // {
+          default = config.vim.languages.enableFormat;
+          defaultText = literalExpression "config.vim.languages.enableFormat";
+        };
+
+      type = mkOption {
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+        description = "C formatter to use";
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -127,5 +193,23 @@ in {
       vim.debugger.nvim-dap.enable = true;
       vim.debugger.nvim-dap.sources.clang-debugger = debuggers.${cfg.dap.debugger}.dapConfig;
     })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft = {
+            c = cfg.format.type;
+            cpp = cfg.format.type;
+          };
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
   ]);
 }

modules/plugins/languages/default.nix

@@ -7,67 +7,72 @@ in {
     ./asm.nix
     ./astro.nix
     ./bash.nix
-    ./cue.nix
-    ./dart.nix
     ./clang.nix
     ./clojure.nix
     ./cmake.nix
+    ./csharp.nix
     ./css.nix
-    ./scss.nix
+    ./cue.nix
+    ./dart.nix
+    ./docker.nix
     ./elixir.nix
     ./elm.nix
+    ./env.nix
     ./fish.nix
+    ./fluent.nix
     ./fsharp.nix
+    ./gettext.nix
     ./gleam.nix
     ./glsl.nix
     ./go.nix
+    ./haskell.nix
     ./hcl.nix
     ./helm.nix
-    ./kotlin.nix
     ./html.nix
-    ./tera.nix
-    ./twig.nix
-    ./liquid.nix
-    ./haskell.nix
     ./java.nix
     ./jinja.nix
+    ./jq.nix
     ./json.nix
+    ./julia.nix
+    ./just.nix
+    ./kotlin.nix
+    ./liquid.nix
     ./lua.nix
+    ./make.nix
     ./markdown.nix
-    ./tex.nix
     ./nim.nix
-    ./vala.nix
     ./nix.nix
+    ./nu.nix
     ./ocaml.nix
+    ./odin.nix
+    ./openscad.nix
     ./php.nix
     ./python.nix
     ./qml.nix
     ./r.nix
+    ./ruby.nix
     ./rust.nix
     ./scala.nix
+    ./scss.nix
+    ./scss.nix
     ./sql.nix
+    ./standard-ml.nix
     ./svelte.nix
-    ./vue.nix
+    ./tera.nix
     ./terraform.nix
+    ./tex.nix
     ./toml.nix
+    ./tsx.nix
+    ./twig.nix
     ./typescript.nix
     ./typst.nix
-    ./zig.nix
-    ./csharp.nix
-    ./julia.nix
-    ./nu.nix
-    ./odin.nix
+    ./vala.nix
+    ./vhdl.nix
+    ./vue.nix
     ./wgsl.nix
-    ./yaml.nix
-    ./ruby.nix
-    ./just.nix
-    ./make.nix
     ./xml.nix
-    ./gettext.nix
-    ./fluent.nix
-    ./openscad.nix
-    ./jq.nix
-    ./docker.nix
+    ./yaml.nix
+    ./zig.nix
 
     # This is now a hard deprecation.
     (mkRenamedOptionModule ["vim" "languages" "enableLSP"] ["vim" "lsp" "enable"])

modules/plugins/languages/env.nix

@@ -0,0 +1,70 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.options) mkEnableOption literalExpression;
+  inherit (lib.meta) getExe;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.nvim.types) diagnostics;
+
+  cfg = config.vim.languages.env;
+
+  defaultDiagnosticsProvider = ["dotenv-linter"];
+  diagnosticsProviders = {
+    dotenv-linter = let
+      pkg = pkgs.dotenv-linter;
+    in {
+      package = pkg;
+      config = {
+        cmd = getExe pkg;
+      };
+    };
+  };
+in {
+  options.vim.languages.env = {
+    enable = mkEnableOption "Env language support";
+
+    extraDiagnostics = {
+      enable =
+        mkEnableOption "extra Env diagnostics"
+        // {
+          default = config.vim.languages.enableExtraDiagnostics;
+          defaultText = literalExpression "config.vim.languages.enableExtraDiagnostics";
+        };
+      types = diagnostics {
+        langDesc = "Env";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    {
+      vim.autocmds = [
+        {
+          event = ["BufRead" "BufNewFile"];
+          pattern = [
+            # support common names like `dist.env`
+            "*.env"
+            # support weird env files names like symfony ones.
+            ".env.*"
+          ];
+          command = "set filetype=env";
+        }
+      ];
+    }
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.env = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
+  ]);
+}

modules/plugins/languages/go.nix

@@ -67,7 +67,21 @@
           "--output.junit-xml.path="
           "--output.teamcity.path="
           "--output.sarif.path="
+          (mkLuaInline ''
+            -- Run on current file only if go.mod is missing
+            function()
+              local fnmod = ":p";
+              local cmd = {"${getExe pkgs.go}", "env", "GOMOD"};
+              local ok, gomod = pcall(vim.fn.system, cmd);
+              gomod = gomod:gsub("%s+", "")
+              if ok and gomod ~= "" and gomod ~= "/dev/null" then
+                fnmod = ":h";
+              end
+              return vim.fn.fnamemodify(vim.api.nvim_buf_get_name(0), fnmod)
+            end
+          '')
         ];
+        append_fname = false;
         parser = mkLuaInline ''
           function(output, bufnr)
             local SOURCE = "golangci-lint";
@@ -111,15 +125,19 @@
                 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,
-              })
+
+              local buffer = vim.fn.fnamemodify(vim.api.nvim_buf_get_name(bufnr), ":p")
+              if vim.fs.normalize(buffer) == vim.fs.normalize(issue.Pos.Filename) then
+                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
             end
             return diagnostics
           end

modules/plugins/languages/json.nix

@@ -25,6 +25,14 @@
       command = getExe pkgs.jsonfmt;
       args = ["-w" "-"];
     };
+
+    prettier = {
+      command = getExe pkgs.prettier;
+    };
+
+    prettierd = {
+      command = getExe pkgs.prettierd;
+    };
   };
 in {
   options.vim.languages.json = {

modules/plugins/languages/php.nix

@@ -11,7 +11,7 @@
   inherit (lib.modules) mkIf mkMerge;
   inherit (lib.types) enum int attrs listOf;
   inherit (lib.nvim.lua) toLuaObject;
-  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
   inherit (lib.nvim.attrsets) mapListToAttrs;
 
   cfg = config.vim.languages.php;
@@ -33,6 +33,14 @@
       command = "${pkgs.php84Packages.php-cs-fixer}/bin/php-cs-fixer";
     };
   };
+
+  defaultDiagnosticsProvider = ["phpstan"];
+
+  diagnosticsProviders = {
+    phpstan = {
+      config.cmd = getExe pkgs.phpstan;
+    };
+  };
 in {
   options.vim.languages.php = {
     enable = mkEnableOption "PHP language support";
@@ -103,6 +111,21 @@ in {
         };
       };
     };
+
+    extraDiagnostics = {
+      enable =
+        mkEnableOption "extra PHP diagnostics"
+        // {
+          default = config.vim.languages.enableExtraDiagnostics;
+          defaultText = literalExpression "config.vim.languages.enableExtraDiagnostic";
+        };
+
+      types = diagnostics {
+        langDesc = "PHP";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
   };
 
   config = mkIf cfg.enable (mkMerge [
@@ -154,5 +177,15 @@ in {
         };
       };
     })
+
+    (mkIf cfg.extraDiagnostics.enable {
+      vim.diagnostics.nvim-lint = {
+        enable = true;
+        linters_by_ft.php = cfg.extraDiagnostics.types;
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
   ]);
 }

modules/plugins/languages/standard-ml.nix

@@ -0,0 +1,114 @@
+{
+  config,
+  lib,
+  pkgs,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.options) literalExpression mkEnableOption mkOption;
+  inherit (lib.types) enum listOf;
+  inherit (lib.attrsets) attrNames genAttrs;
+  inherit (lib.generators) mkLuaInline;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) mkTreesitterGrammarOption;
+
+  cfg = config.vim.languages.standard-ml;
+
+  defaultServers = ["millet"];
+  servers = ["millet"];
+
+  defaultFormat = ["smlfmt"];
+  formats = {
+    smlfmt = {
+      command = getExe pkgs.smlfmt;
+      stdin = false;
+      args = mkLuaInline ''
+        function(self, ctx)
+          return {
+            "--force",
+            "-tab-width", ctx.shiftwidth,
+            "-indent-width", ctx.shiftwidth,
+            "$FILENAME",
+          }
+        end
+      '';
+    };
+  };
+in {
+  options.vim.languages.standard-ml = {
+    enable = mkEnableOption "Standard ML support";
+
+    treesitter = {
+      enable =
+        mkEnableOption "Standard ML treesitter"
+        // {
+          default = config.vim.languages.enableTreesitter;
+          defaultText = literalExpression "config.vim.languages.enableTreesitter";
+        };
+      package = mkTreesitterGrammarOption pkgs "sml";
+    };
+
+    lsp = {
+      enable =
+        mkEnableOption "Standard ML LSP support"
+        // {
+          default = config.vim.lsp.enable;
+          defaultText = literalExpression "config.vim.lsp.enable";
+        };
+      servers = mkOption {
+        type = listOf (enum servers);
+        default = defaultServers;
+        description = "Standard ML LSP server to use";
+      };
+    };
+
+    format = {
+      enable =
+        mkEnableOption "Standard ML formatting"
+        // {
+          default = config.vim.languages.enableFormat;
+          defaultText = literalExpression "config.vim.languages.enableFormat";
+        };
+
+      type = mkOption {
+        description = "Standard ML formatter to use";
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter = {
+        enable = true;
+        grammars = [cfg.treesitter.package];
+      };
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp = {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
+        servers = genAttrs cfg.lsp.servers (_: {
+          filetypes = ["sml"];
+        });
+      };
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft.sml = cfg.format.type;
+          formatters =
+            mapListToAttrs (name: {
+              inherit name;
+              value = formats.${name};
+            })
+            cfg.format.type;
+        };
+      };
+    })
+  ]);
+}

modules/plugins/languages/tsx.nix

@@ -0,0 +1,159 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.options) mkEnableOption mkOption literalExpression;
+  inherit (lib.types) enum listOf;
+  inherit (lib.attrsets) attrNames genAttrs;
+  inherit (lib.meta) getExe;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+  inherit (lib.nvim.types) mkGrammarOption diagnostics;
+
+  cfg = config.vim.languages.tsx;
+
+  defaultServers = ["typescript-language-server"];
+  servers = ["typescript-language-server" "deno" "typescript-go" "emmet-ls"];
+
+  defaultFormat = ["prettier"];
+  formats = {
+    prettier = {
+      command = getExe pkgs.prettier;
+    };
+
+    prettierd = {
+      command = getExe pkgs.prettierd;
+    };
+
+    biome = {
+      command = getExe pkgs.biome;
+    };
+
+    biome-check = {
+      command = getExe pkgs.biome;
+    };
+
+    biome-organize-imports = {
+      command = getExe pkgs.biome;
+    };
+  };
+
+  defaultDiagnosticsProvider = ["biomejs"];
+  diagnosticsProviders = {
+    biomejs = let
+      pkg = pkgs.biome;
+    in {
+      package = pkg;
+      config = {
+        cmd = getExe pkg;
+      };
+    };
+  };
+in {
+  options.vim.languages.tsx = {
+    enable = mkEnableOption "Typescript XML (TSX) language support";
+
+    treesitter = {
+      enable =
+        mkEnableOption "Typescript XML (TSX) treesitter"
+        // {
+          default = config.vim.languages.enableTreesitter;
+          defaultText = literalExpression "config.vim.languages.enableTreesitter";
+        };
+      package = mkGrammarOption pkgs "tsx";
+    };
+
+    lsp = {
+      enable =
+        mkEnableOption "Typescript XML (TSX) LSP support"
+        // {
+          default = config.vim.lsp.enable;
+          defaultText = literalExpression "config.vim.lsp.enable";
+        };
+      servers = mkOption {
+        type = listOf (enum servers);
+        default = defaultServers;
+        description = "Typescript XML (TSX) LSP server to use";
+      };
+    };
+
+    format = {
+      enable =
+        mkEnableOption "Typescript XML (TSX) formatting"
+        // {
+          default = config.vim.languages.enableFormat;
+          defaultText = literalExpression "config.vim.languages.enableFormat";
+        };
+
+      type = mkOption {
+        description = "Typescript XML (TSX) formatter to use";
+        type = listOf (enum (attrNames formats));
+        default = defaultFormat;
+      };
+    };
+
+    extraDiagnostics = {
+      enable = mkEnableOption "extra Typescript XML (TSX) diagnostics" // {default = config.vim.languages.enableExtraDiagnostics;};
+
+      types = diagnostics {
+        langDesc = "Typescript XML (TSX)";
+        inherit diagnosticsProviders;
+        inherit defaultDiagnosticsProvider;
+      };
+    };
+  };
+
+  config = mkIf cfg.enable (mkMerge [
+    (mkIf cfg.treesitter.enable {
+      vim.treesitter = {
+        enable = true;
+        grammars = [cfg.treesitter.package];
+      };
+    })
+
+    (mkIf cfg.lsp.enable {
+      vim.lsp = {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
+        servers = genAttrs cfg.lsp.servers (_: {
+          filetypes = [
+            "typescriptreact"
+            "javascriptreact"
+          ];
+        });
+      };
+    })
+
+    (mkIf cfg.format.enable {
+      vim.formatter.conform-nvim = {
+        enable = true;
+        setupOpts = {
+          formatters_by_ft = {
+            typescriptreact = cfg.format.type;
+            javascriptreact = 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 = {
+          typescriptreact = cfg.extraDiagnostics.types;
+          javascriptreact = cfg.extraDiagnostics.types;
+        };
+        linters =
+          mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
+            cfg.extraDiagnostics.types);
+      };
+    })
+  ]);
+}

modules/plugins/languages/typescript.nix

@@ -85,7 +85,6 @@ in {
           defaultText = literalExpression "config.vim.languages.enableTreesitter";
         };
       tsPackage = mkGrammarOption pkgs "typescript";
-      tsxPackage = mkGrammarOption pkgs "tsx";
       jsPackage = mkGrammarOption pkgs "javascript";
     };
 
@@ -162,7 +161,6 @@ in {
       vim.treesitter.enable = true;
       vim.treesitter.grammars = [
         cfg.treesitter.tsPackage
-        cfg.treesitter.tsxPackage
         cfg.treesitter.jsPackage
       ];
     })
@@ -173,11 +171,6 @@ in {
         servers = genAttrs cfg.lsp.servers (_: {
           filetypes = [
             "typescript"
-            # TODO: move to a React module
-            "typescriptreact"
-            "typescript.tsx"
-            "javascriptreact"
-            "javascript.jsx"
             # TODO: move to a JavaScript module
             "javascript"
           ];
@@ -192,8 +185,6 @@ in {
           formatters_by_ft = {
             typescript = cfg.format.type;
             javascript = cfg.format.type;
-            # .tsx/.jsx files
-            typescriptreact = cfg.format.type;
           };
           formatters =
             mapListToAttrs (name: {
@@ -209,8 +200,6 @@ in {
       vim.diagnostics.nvim-lint = {
         enable = true;
         linters_by_ft.typescript = cfg.extraDiagnostics.types;
-        linters_by_ft.typescriptreact = cfg.extraDiagnostics.types;
-
         linters =
           mkMerge (map (name: {${name} = diagnosticsProviders.${name}.config;})
             cfg.extraDiagnostics.types);

modules/plugins/languages/vhdl.nix

@@ -0,0 +1,65 @@
+{
+  config,
+  pkgs,
+  lib,
+  ...
+}: let
+  inherit (builtins) attrNames;
+  inherit (lib.options) mkOption mkEnableOption literalExpression;
+  inherit (lib.modules) mkIf mkMerge;
+  inherit (lib.types) enum bool listOf;
+  inherit (lib) genAttrs;
+  inherit (lib.nvim.types) mkGrammarOption;
+  inherit (lib.nvim.attrsets) mapListToAttrs;
+
+  cfg = config.vim.languages.vhdl;
+
+  defaultServers = ["vhdl-ls"];
+  servers = ["vhdl-ls"];
+in {
+  options.vim.languages.vhdl = {
+    enable = mkEnableOption "VHDL language support";
+
+    treesitter = {
+      enable =
+        mkEnableOption "VHDL treesitter"
+        // {
+          default = config.vim.languages.enableTreesitter;
+          defaultText = literalExpression "config.vim.languages.enableTreesitter";
+        };
+      package = mkGrammarOption pkgs "vhdl";
+    };
+
+    lsp = {
+      enable =
+        mkEnableOption "VHDL LSP support"
+        // {
+          default = config.vim.lsp.enable;
+          defaultText = literalExpression "config.vim.lsp.enable";
+        };
+      servers = mkOption {
+        type = listOf (enum servers);
+        default = defaultServers;
+        description = "VHDL 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 = {
+        presets = genAttrs cfg.lsp.servers (_: {enable = true;});
+        servers = genAttrs cfg.lsp.servers (_: {
+          filetypes = ["vhdl"];
+        });
+      };
+    })
+  ]);
+}