NotAShelf/nvf
2
1
Fork 0
mirror of https://github.com/NotAShelf/nvf.git synced 2025-11-03 04:16:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Compare commits

base: NotAShelf:69659e078b6531698255deda280c9407b34e29ea
Branches Tags
NotAShelf:main
NotAShelf:v0.8
NotAShelf:gh-pages
NotAShelf:notashelf/push-ysqzsqxwlsml
NotAShelf:notashelf/push-lnklzrqrwnym
NotAShelf:notashelf/push-qzzvtnwpuqmr
NotAShelf:notashelf/push-kxltupyypnpo
NotAShelf:machine-tests
NotAShelf:weekly-plugin-bumps
NotAShelf:get-edgy
NotAShelf:v0.7
NotAShelf:v0.6
NotAShelf:v0.5
NotAShelf:v0.4
NotAShelf:v0.3
NotAShelf:v0.2
..
compare: NotAShelf:58cb8ec418b5746c098ccd9bddb6bdc09d6b8802
Branches Tags
NotAShelf:main
NotAShelf:v0.8
NotAShelf:gh-pages
NotAShelf:notashelf/push-ysqzsqxwlsml
NotAShelf:notashelf/push-lnklzrqrwnym
NotAShelf:notashelf/push-qzzvtnwpuqmr
NotAShelf:notashelf/push-kxltupyypnpo
NotAShelf:machine-tests
NotAShelf:weekly-plugin-bumps
NotAShelf:get-edgy
NotAShelf:v0.7
NotAShelf:v0.6
NotAShelf:v0.5
NotAShelf:v0.4
NotAShelf:v0.3
NotAShelf:v0.2

No commits in common. "69659e078b6531698255deda280c9407b34e29ea" and "58cb8ec418b5746c098ccd9bddb6bdc09d6b8802" have entirely different histories.
69659e078b ... 58cb8ec418

38 changed files with 369 additions and 769 deletions
Download patch file Download diff file Expand all files Collapse all files

2
.github/typos.toml vendored
View file

@ -5,8 +5,6 @@ default.extend-ignore-words-re = [
"befores", "befores",
"annote", "annote",
"viw", "viw",
"edn",
"esy",
"BA", # somehow "BANanaD3V" is valid, but BA is not... "BA", # somehow "BANanaD3V" is valid, but BA is not...
] ]

4
lib/languages.nix
View file

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

5
lib/types/custom.nix
View file

@ -1,8 +1,7 @@
{lib}: let {lib}: let
inherit (lib.options) mergeEqualOption; inherit (lib.options) mergeEqualOption;
inherit (lib.lists) singleton;
inherit (lib.strings) isString stringLength match; inherit (lib.strings) isString stringLength match;
inherit (lib.types) listOf mkOptionType coercedTo; inherit (lib.types) listOf mkOptionType;
in { in {
mergelessListOf = elemType: let mergelessListOf = elemType: let
super = listOf elemType; super = listOf elemType;
@ -28,6 +27,4 @@ in {
description = "RGB color in hex format"; description = "RGB color in hex format";
check = v: isString v && (match "#?[0-9a-fA-F]{6}" v) != null; check = v: isString v && (match "#?[0-9a-fA-F]{6}" v) != null;
}; };
singleOrListOf = t: coercedTo t singleton (listOf t);
} }

2
lib/types/default.nix
View file

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

141
modules/extra/deprecations.nix
View file

@ -1,6 +1,5 @@
{lib, ...}: let {lib, ...}: let
inherit (builtins) head warn; inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule;
inherit (lib.modules) mkRemovedOptionModule mkRenamedOptionModule doRename;
inherit (lib.lists) concatLists; inherit (lib.lists) concatLists;
inherit (lib.nvim.config) batchRenameOptions; inherit (lib.nvim.config) batchRenameOptions;
@ -21,27 +20,6 @@
# 2025-02-07 # 2025-02-07
scrollOffset = "scrolloff"; scrollOffset = "scrolloff";
}; };
mkRemovedLspOpt = lang: (mkRemovedOptionModule ["vim" "languages" lang "lsp" "opts"] ''
`vim.languages.${lang}.lsp.opts` is now moved to `vim.lsp.servers.<server_name>.init_options`
'');
mkRemovedLspPackage = lang: (mkRemovedOptionModule ["vim" "languages" lang "lsp" "package"] ''
`vim.languages.${lang}.lsp.package` is now moved to `vim.lsp.servers.<server_name>.cmd`
'');
mkRenamedLspServer = lang:
doRename
{
from = ["vim" "languages" lang "lsp" "server"];
to = ["vim" "languages" lang "lsp" "servers"];
visible = false;
warn = true;
use = x:
warn
"Obsolete option `vim.languages.${lang}.lsp.server` used, use `vim.languages.${lang}.lsp.servers` instead."
(head x);
};
in { in {
imports = concatLists [ imports = concatLists [
[ [
@ -142,123 +120,6 @@ in {
in 'vim.clipboard.registers'. Please see the documentation for the new module for more in 'vim.clipboard.registers'. Please see the documentation for the new module for more
details, or open an issue if you are confused. details, or open an issue if you are confused.
'') '')
# 2025-07-12
(mkRenamedLspServer "assembly")
(mkRenamedLspServer "astro")
(mkRemovedLspPackage "astro")
(mkRenamedLspServer "bash")
(mkRemovedLspPackage "bash")
(mkRemovedLspOpt "clang")
(mkRemovedLspPackage "clang")
(mkRenamedLspServer "clang")
(mkRemovedLspPackage "clojure")
(mkRenamedLspServer "csharp")
(mkRemovedLspPackage "csharp")
(mkRenamedLspServer "css")
(mkRemovedLspPackage "css")
(mkRemovedLspPackage "cue")
(mkRenamedLspServer "dart")
(mkRemovedLspPackage "dart")
(mkRemovedLspOpt "dart")
(mkRenamedLspServer "elixir")
(mkRemovedLspPackage "elixir")
(mkRenamedLspServer "fsharp")
(mkRemovedLspPackage "fsharp")
(mkRenamedLspServer "gleam")
(mkRemovedLspPackage "gleam")
(mkRenamedLspServer "go")
(mkRemovedLspPackage "go")
(mkRemovedLspPackage "haskell")
(mkRemovedLspPackage "hcl")
(mkRenamedLspServer "helm")
(mkRemovedLspPackage "helm")
(mkRemovedLspPackage "java")
(mkRenamedLspServer "julia")
(mkRemovedLspPackage "julia")
(mkRemovedLspPackage "kotlin")
(mkRemovedLspPackage "lua")
(mkRenamedLspServer "markdown")
(mkRemovedLspPackage "markdown")
(mkRenamedLspServer "nim")
(mkRemovedLspPackage "nim")
(mkRenamedLspServer "nix")
(mkRemovedLspPackage "nix")
(mkRemovedOptionModule ["vim" "languages" "nix" "lsp" "options"] ''
`vim.languages.nix.lsp.options` has been moved to `vim.lsp.servers.<server_name>.init_options`.
'')
(mkRenamedLspServer "nu")
(mkRemovedLspPackage "nu")
(mkRenamedLspServer "ocaml")
(mkRemovedLspPackage "ocaml")
(mkRenamedLspServer "odin")
(mkRemovedLspPackage "odin")
(mkRenamedLspServer "php")
(mkRemovedLspPackage "php")
(mkRenamedLspServer "python")
(mkRemovedLspPackage "python")
(mkRenamedLspServer "r")
(mkRemovedLspPackage "r")
(mkRenamedLspServer "ruby")
(mkRemovedLspPackage "ruby")
(mkRenamedLspServer "sql")
(mkRemovedLspPackage "sql")
(mkRenamedLspServer "svelte")
(mkRemovedLspPackage "svelte")
(mkRenamedLspServer "tailwind")
(mkRemovedLspPackage "tailwind")
(mkRemovedLspPackage "terraform")
(mkRenamedLspServer "ts")
(mkRemovedLspPackage "ts")
(mkRenamedLspServer "typst")
(mkRemovedLspPackage "typst")
(mkRenamedLspServer "vala")
(mkRemovedLspPackage "vala")
(mkRenamedLspServer "wgsl")
(mkRemovedLspPackage "wgsl")
(mkRenamedLspServer "yaml")
(mkRemovedLspPackage "yaml")
(mkRenamedLspServer "zig")
(mkRemovedLspPackage "zig")
] ]
# Migrated via batchRenameOptions. Further batch renames must be below this line. # Migrated via batchRenameOptions. Further batch renames must be below this line.

6
modules/plugins/languages/asm.nix
View file

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

8
modules/plugins/languages/astro.nix
View file

@ -7,10 +7,12 @@
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.types) enum package; inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf; inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.astro; cfg = config.vim.languages.astro;
@ -89,7 +91,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Astro LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Astro LSP server to use"; description = "Astro LSP server to use";
}; };

10
modules/plugins/languages/bash.nix
View file

@ -5,12 +5,14 @@
... ...
}: let }: let
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkOption mkEnableOption; inherit (lib.options) mkOption mkEnableOption literalExpression;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package bool; inherit (lib.lists) isList;
inherit (lib.types) enum either package listOf str bool;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) diagnostics mkGrammarOption singleOrListOf; inherit (lib.nvim.types) diagnostics mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.bash; cfg = config.vim.languages.bash;
@ -55,7 +57,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Bash LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Bash LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Bash LSP server to use"; description = "Bash LSP server to use";
}; };

184
modules/plugins/languages/clang.nix
View file

@ -5,143 +5,47 @@
... ...
}: let }: let
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.lists) isList;
inherit (lib.strings) optionalString;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) bool enum package; inherit (lib.types) bool enum package either listOf str nullOr;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline; inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.dag) entryAfter; inherit (lib.nvim.dag) entryAfter;
packageToCmd = package: defaultCmd:
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{ "${cfg.lsp.package}/bin/${defaultCmd}" }'';
cfg = config.vim.languages.clang; cfg = config.vim.languages.clang;
defaultServers = ["clangd"]; defaultServer = "clangd";
servers = { servers = {
ccls = { ccls = {
cmd = [(getExe pkgs.ccls)]; package = pkgs.ccls;
filetypes = ["c" "cpp" "objc" "objcpp" "cuda"]; lspConfig = ''
offset_encoding = "utf-32"; lspconfig.ccls.setup{
root_markers = ["compile_commands.json" ".ccls" ".git"]; capabilities = capabilities;
workspace_required = true; on_attach=default_on_attach;
on_attach = mkLuaInline '' cmd = ${packageToCmd cfg.lsp.package "ccls"};
function(client, bufnr) ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.opts}"}
default_on_attach(client, bufnr) }
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local params = vim.lsp.util.make_text_document_params(bufnr)
client:request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"LspCclsSwitchSourceHeader",
function(arg)
switch_source_header(client, 0)
end,
{desc = "Switch between source/header"}
)
end
''; '';
}; };
clangd = { clangd = {
cmd = ["${pkgs.clang-tools}/bin/clangd"]; package = pkgs.clang-tools;
filetypes = ["c" "cpp" "objc" "objcpp" "cuda" "proto"]; lspConfig = ''
root_markers = [ local clangd_cap = capabilities
".clangd" -- use same offsetEncoding as null-ls
".clang-tidy" clangd_cap.offsetEncoding = {"utf-16"}
".clang-format" lspconfig.clangd.setup{
"compile_commands.json" capabilities = clangd_cap;
"compile_flags.txt" on_attach=default_on_attach;
"configure.ac" cmd = ${packageToCmd cfg.lsp.package "clangd"};
".git" ${optionalString (cfg.lsp.opts != null) "init_options = ${cfg.lsp.opts}"}
]; }
capabilities = {
textDocument = {
completion = {
editsNearCursor = true;
};
};
offsetEncoding = ["utf-8" "utf-16"];
};
on_attach = mkLuaInline ''
function(client, bufnr)
default_on_attach(client, bufnr)
local function switch_source_header(bufnr)
local method_name = "textDocument/switchSourceHeader"
local client = vim.lsp.get_clients({ bufnr = bufnr, name = "clangd", })[1]
if not client then
return vim.notify(('method %s is not supported by any servers active on the current buffer'):format(method_name))
end
local params = vim.lsp.util.make_text_document_params(bufnr)
client.request(method_name, params, function(err, result)
if err then
error(tostring(err))
end
if not result then
vim.notify('corresponding file cannot be determined')
return
end
vim.cmd.edit(vim.uri_to_fname(result))
end, bufnr)
end
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
return vim.notify('Clangd client not found', vim.log.levels.ERROR)
end
local win = vim.api.nvim_get_current_win()
local params = vim.lsp.util.make_position_params(win, clangd_client.offset_encoding)
clangd_client:request('textDocument/symbolInfo', params, function(err, res)
if err or #res == 0 then
-- Clangd always returns an error, there is not reason to parse it
return
end
local container = string.format('container: %s', res[1].containerName) ---@type string
local name = string.format('name: %s', res[1].name) ---@type string
vim.lsp.util.open_floating_preview({ name, container }, "", {
height = 2,
width = math.max(string.len(name), string.len(container)),
focusable = false,
focus = false,
border = 'single',
title = 'Symbol Info',
})
end, bufnr)
end
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdSwitchSourceHeader",
function(arg)
switch_source_header(0)
end,
{desc = "Switch between source/header"}
)
vim.api.nvim_buf_create_user_command(
bufnr,
"ClangdShowSymbolInfo",
function(arg)
symbol_info()
end,
{desc = "Show symbol info"}
)
end
''; '';
}; };
}; };
@ -196,10 +100,23 @@ in {
lsp = { lsp = {
enable = mkEnableOption "clang LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "clang LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
description = "The clang LSP server to use"; description = "The clang LSP server to use";
type = singleOrListOf (enum (attrNames servers)); type = enum (attrNames servers);
default = defaultServers; default = defaultServer;
};
package = mkOption {
description = "clang LSP server package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
};
opts = mkOption {
description = "Options to pass to clang LSP server";
type = nullOr str;
default = null;
}; };
}; };
@ -233,12 +150,9 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: {
inherit name; vim.lsp.lspconfig.sources.clang-lsp = servers.${cfg.lsp.server}.lspConfig;
value = servers.${name};
})
cfg.lsp.servers;
}) })
(mkIf cfg.dap.enable { (mkIf cfg.dap.enable {

152
modules/plugins/languages/csharp.nix
View file

@ -5,16 +5,14 @@
options, options,
... ...
}: let }: let
inherit (builtins) attrNames concatMap; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) enum; inherit (lib.types) either listOf package str enum;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe; inherit (lib.lists) isList;
inherit (lib.generators) mkLuaInline;
inherit (lib.strings) optionalString; inherit (lib.strings) optionalString;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) toLuaObject; inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.attrsets) mapListToAttrs;
lspKeyConfig = config.vim.lsp.mappings; lspKeyConfig = config.vim.lsp.mappings;
lspKeyOptions = options.vim.lsp.mappings; lspKeyOptions = options.vim.lsp.mappings;
@ -27,104 +25,52 @@
# Omnisharp doesn't have colors in popup docs for some reason, and I've also # Omnisharp doesn't have colors in popup docs for some reason, and I've also
# seen mentions of it being way slower, so until someone finds missing # seen mentions of it being way slower, so until someone finds missing
# functionality, this will be the default. # functionality, this will be the default.
defaultServers = ["csharp_ls"]; defaultServer = "csharp_ls";
servers = { servers = {
omnisharp = { omnisharp = {
cmd = mkLuaInline '' package = pkgs.omnisharp-roslyn;
{ internalFormatter = true;
${toLuaObject (getExe pkgs.omnisharp-roslyn)}, lspConfig = ''
'-z', -- https://github.com/OmniSharp/omnisharp-vscode/pull/4300 lspconfig.omnisharp.setup {
'--hostPID', capabilities = capabilities,
tostring(vim.fn.getpid()), on_attach = function(client, bufnr)
'DotNet:enablePackageRestore=false', default_on_attach(client, bufnr)
'--encoding',
'utf-8',
'--languageserver',
}
'';
filetypes = ["cs" "vb"];
root_markers = [".sln" ".csproj" "omnisharp.json" "function.json"];
init_options = {};
capabilities = {
workspace = {
workspaceFolders = false; # https://github.com/OmniSharp/omnisharp-roslyn/issues/909
};
};
on_attach = mkLuaInline ''
function(client, bufnr)
default_on_attach(client, bufnr)
local oe = require("omnisharp_extended") local oe = require("omnisharp_extended")
${mkLspBinding "goToDefinition" "oe.lsp_definition"} ${mkLspBinding "goToDefinition" "oe.lsp_definition"}
${mkLspBinding "goToType" "oe.lsp_type_definition"} ${mkLspBinding "goToType" "oe.lsp_type_definition"}
${mkLspBinding "listReferences" "oe.lsp_references"} ${mkLspBinding "listReferences" "oe.lsp_references"}
${mkLspBinding "listImplementations" "oe.lsp_implementation"} ${mkLspBinding "listImplementations" "oe.lsp_implementation"}
end end,
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else "{'${cfg.lsp.package}/bin/OmniSharp'}"
}
}
''; '';
settings = {
FormattingOptions = {
# Enables support for reading code style, naming convention and analyzer
# settings from .editorconfig.
EnableEditorConfigSupport = true;
# Specifies whether 'using' directives should be grouped and sorted during
# document formatting.
OrganizeImports = null;
};
MsBuild = {
# If true, MSBuild project system will only load projects for files that
# were opened in the editor. This setting is useful for big C# codebases
# and allows for faster initialization of code navigation features only
# for projects that are relevant to code that is being edited. With this
# setting enabled OmniSharp may load fewer projects and may thus display
# incomplete reference lists for symbols.
LoadProjectsOnDemand = null;
};
RoslynExtensionsOptions = {
# Enables support for roslyn analyzers, code fixes and rulesets.
EnableAnalyzersSupport = null;
# Enables support for showing unimported types and unimported extension
# methods in completion lists. When committed, the appropriate using
# directive will be added at the top of the current file. This option can
# have a negative impact on initial completion responsiveness;
# particularly for the first few completion sessions after opening a
# solution.
EnableImportCompletion = null;
# Only run analyzers against open files when 'enableRoslynAnalyzers' is
# true
AnalyzeOpenDocumentsOnly = null;
# Enables the possibility to see the code in external nuget dependencies
EnableDecompilationSupport = null;
};
RenameOptions = {
RenameInComments = null;
RenameOverloads = null;
RenameInStrings = null;
};
Sdk = {
# Specifies whether to include preview versions of the .NET SDK when
# determining which version to use for project loading.
IncludePrereleases = true;
};
};
}; };
csharp_ls = { csharp_ls = {
cmd = [(lib.getExe pkgs.csharp-ls)]; package = pkgs.csharp-ls;
filetypes = ["cs"]; internalFormatter = true;
root_dir = mkLuaInline '' lspConfig = ''
function(bufnr, on_dir) local extended_handler = require("csharpls_extended").handler
local function find_root_pattern(fname, lua_pattern)
return vim.fs.root(0, function(name, path)
return name:match(lua_pattern)
end)
end
local fname = vim.api.nvim_buf_get_name(bufnr) lspconfig.csharp_ls.setup {
on_dir(find_root_pattern(fname, "%.sln$") or find_root_pattern(fname, "%.csproj$")) capabilities = capabilities,
end on_attach = default_on_attach,
handlers = {
["textDocument/definition"] = extended_handler,
["textDocument/typeDefinition"] = extended_handler
},
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else "{'${cfg.lsp.package}/bin/csharp-ls'}"
}
}
''; '';
init_options = {
AutomaticWorkspaceInit = true;
};
}; };
}; };
@ -146,10 +92,16 @@ in {
lsp = { lsp = {
enable = mkEnableOption "C# LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "C# LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
description = "C# LSP server to use"; description = "C# LSP server to use";
type = singleOrListOf (enum (attrNames servers)); type = enum (attrNames servers);
default = defaultServers; default = defaultServer;
};
package = mkOption {
description = "C# LSP server package, or the command to run as a list of strings";
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
}; };
}; };
}; };
@ -162,13 +114,9 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.startPlugins = concatMap (server: extraServerPlugins.${server}) cfg.lsp.servers; vim.startPlugins = extraServerPlugins.${cfg.lsp.server} or [];
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: { vim.lsp.lspconfig.sources.csharp-lsp = servers.${cfg.lsp.server}.lspConfig;
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
}) })
]); ]);
} }

60
modules/plugins/languages/css.nix
View file

@ -8,25 +8,34 @@
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package; inherit (lib.lists) isList;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
cfg = config.vim.languages.css; cfg = config.vim.languages.css;
defaultServer = ["cssls"]; defaultServer = "vscode-langservers-extracted";
servers = { servers = {
cssls = { vscode-langservers-extracted = {
cmd = ["${pkgs.vscode-langservers-extracted}/bin/vscode-css-language-server" "--stdio"]; package = pkgs.vscode-langservers-extracted;
filetypes = ["css" "scss" "less"]; lspConfig = ''
# needed to enable formatting -- enable (broadcasting) snippet capability for completion
init_options = {provideFormatter = true;}; -- see <https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#cssls>
root_markers = [".git" "package.json"]; local css_capabilities = vim.lsp.protocol.make_client_capabilities()
settings = { css_capabilities.textDocument.completion.completionItem.snippetSupport = true
css.validate = true;
scss.validate = true; -- cssls setup
less.validate = true; lspconfig.cssls.setup {
}; capabilities = css_capabilities;
on_attach = default_on_attach;
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{"${cfg.lsp.package}/bin/vscode-css-language-server", "--stdio"}''
}
}
'';
}; };
}; };
@ -73,10 +82,17 @@ in {
lsp = { lsp = {
enable = mkEnableOption "CSS LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "CSS LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
type = singleOrListOf (enum (attrNames servers));
default = defaultServer;
description = "CSS LSP server to use"; description = "CSS LSP server to use";
type = enum (attrNames servers);
default = defaultServer;
};
package = mkOption {
description = "CSS LSP server package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
}; };
}; };
@ -104,12 +120,8 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: { vim.lsp.lspconfig.sources.css-lsp = servers.${cfg.lsp.server}.lspConfig;
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
}) })
(mkIf cfg.format.enable { (mkIf cfg.format.enable {

25
modules/plugins/languages/cue.nix
View file

@ -4,17 +4,11 @@
lib, lib,
... ...
}: let }: let
inherit (lib.options) mkEnableOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) package;
inherit (lib.nvim.types) mkGrammarOption; inherit (lib.nvim.types) mkGrammarOption;
lspOptions = {
cmd = [(getExe pkgs.cue) "lsp"];
filetypes = ["cue"];
root_markers = ["cue.mod" ".git"];
};
cfg = config.vim.languages.cue; cfg = config.vim.languages.cue;
in { in {
options.vim.languages.cue = { options.vim.languages.cue = {
@ -28,6 +22,12 @@ in {
lsp = { lsp = {
enable = mkEnableOption "CUE LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "CUE LSP support" // {default = config.vim.lsp.enable;};
package = mkOption {
type = package;
default = pkgs.cue;
description = "cue lsp implementation";
};
}; };
}; };
@ -38,7 +38,14 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers.cue = lspOptions; vim.lsp.lspconfig.enable = true;
vim.lsp.lspconfig.sources.cue-lsp = ''
lspconfig.cue.setup {
capabilities = capabilities,
on_attach = default_on_attach,
cmd = {"${cfg.lsp.package}/bin/cue", "lsp"},
}
'';
}) })
]); ]);
} }

8
modules/plugins/languages/dart.nix
View file

@ -8,10 +8,12 @@
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.trivial) boolToString; inherit (lib.trivial) boolToString;
inherit (lib.lists) isList;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) enum package nullOr str bool; inherit (lib.types) enum either listOf package nullOr str bool;
inherit (lib.strings) optionalString; inherit (lib.strings) optionalString;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.dag) entryAfter; inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
@ -52,7 +54,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Dart LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Dart LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Dart LSP server to use"; description = "Dart LSP server to use";
}; };

8
modules/plugins/languages/elixir.nix
View file

@ -7,10 +7,12 @@
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.types) enum package; inherit (lib.types) enum either listOf package str;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.dag) entryAnywhere; inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
@ -61,7 +63,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Elixir LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Elixir LSP server to use"; description = "Elixir LSP server to use";
}; };

72
modules/plugins/languages/fsharp.nix
View file

@ -6,48 +6,29 @@
}: let }: let
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) package enum; inherit (lib.types) either listOf package str enum;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.generators) mkLuaInline; inherit (lib.lists) isList;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.lua) expToLua;
defaultServer = ["fsautocomplete"]; defaultServer = "fsautocomplete";
servers = { servers = {
fsautocomplete = { fsautocomplete = {
cmd = [(getExe pkgs.fsautocomplete) "--adaptive-lsp-server-enabled"]; package = pkgs.fsautocomplete;
filetypes = ["fsharp"]; internalFormatter = false;
root_dir = mkLuaInline '' lspConfig = ''
function(bufnr, on_dir) lspconfig.fsautocomplete.setup {
on_dir(vim.fs.root(bufnr, function(name, path) capabilities = capabilities;
return name == ".git" or name:match("%.sln$") or name:match("%.fsproj$") on_attach = default_on_attach;
end)) cmd = ${
end if isList cfg.lsp.package
then expToLua cfg.lsp.package
else "{'${cfg.lsp.package}/bin/fsautocomplete'}"
},
}
''; '';
init_options = {
AutomaticWorkspaceInit = true;
};
settings = {
FSharp = {
keywordsAutocomplete = true;
ExternalAutocomplete = false;
Linter = true;
UnionCaseStubGeneration = true;
UnionCaseStubGenerationBody = ''failwith "Not Implemented"'';
RecordStubGeneration = true;
RecordStubGenerationBody = ''failwith "Not Implemented"'';
InterfaceStubGeneration = true;
InterfaceStubGenerationObjectIdentifier = "this";
InterfaceStubGenerationMethodBody = ''failwith "Not Implemented"'';
UnusedOpensAnalyzer = true;
UnusedDeclarationsAnalyzer = true;
UseSdkScripts = true;
SimplifyNameAnalyzer = true;
ResolveNamespaces = true;
EnableReferenceCodeLens = true;
};
};
}; };
}; };
@ -71,11 +52,18 @@ in {
lsp = { lsp = {
enable = mkEnableOption "F# LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "F# LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = enum (attrNames servers);
default = defaultServer; default = defaultServer;
description = "F# LSP server to use"; description = "F# LSP server to use";
}; };
package = mkOption {
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
example = ''[lib.getExe pkgs.fsautocomplete "--state-directory" "~/.cache/fsautocomplete"]'';
description = "F# LSP server package, or the command to run as a list of strings";
};
}; };
format = { format = {
enable = mkEnableOption "F# formatting" // {default = config.vim.languages.enableFormat;}; enable = mkEnableOption "F# formatting" // {default = config.vim.languages.enableFormat;};
@ -102,12 +90,8 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: { vim.lsp.lspconfig.sources.fsharp-lsp = servers.${cfg.lsp.server}.lspConfig;
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
}) })
(mkIf cfg.format.enable { (mkIf cfg.format.enable {

8
modules/plugins/languages/gleam.nix
View file

@ -7,9 +7,11 @@
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.types) enum; inherit (lib.types) enum either listOf package str;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.gleam; cfg = config.vim.languages.gleam;
@ -35,7 +37,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Gleam LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Gleam LSP server to use"; description = "Gleam LSP server to use";
}; };

78
modules/plugins/languages/go.nix
View file

@ -8,53 +8,28 @@
inherit (lib.options) mkEnableOption mkOption literalMD; inherit (lib.options) mkEnableOption mkOption literalMD;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.generators) mkLuaInline; inherit (lib.lists) isList;
inherit (lib.types) bool enum package; inherit (lib.types) bool enum either listOf package str;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.lua) expToLua;
inherit (lib.nvim.dag) entryAfter; inherit (lib.nvim.dag) entryAfter;
inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.go; cfg = config.vim.languages.go;
defaultServers = ["gopls"]; defaultServer = "gopls";
servers = { servers = {
gopls = { gopls = {
cmd = [(getExe pkgs.gopls)]; package = pkgs.gopls;
filetypes = ["go" "gomod" "gowork" "gotmpl"]; lspConfig = ''
root_dir = mkLuaInline '' lspconfig.gopls.setup {
function(bufnr, on_dir) capabilities = capabilities;
local fname = vim.api.nvim_buf_get_name(bufnr) on_attach = default_on_attach;
cmd = ${
local function get_root(fname) if isList cfg.lsp.package
if _G.nvf_gopls_mod_cache and fname:sub(1, #_G.nvf_gopls_mod_cache) == _G.nvf_gopls_mod_cache then then expToLua cfg.lsp.package
local clients = vim.lsp.get_clients { name = 'gopls' } else ''{"${cfg.lsp.package}/bin/gopls", "serve"}''
if #clients > 0 then },
return clients[#clients].config.root_dir }
end
end
return vim.fs.root(fname, 'go.work') or vim.fs.root(fname, 'go.mod') or vim.fs.root(fname, '.git')
end
-- see: https://github.com/neovim/nvim-lspconfig/issues/804
if _G.nvf_gopls_mod_cache then
on_dir(get_root(fname))
return
end
local cmd = { 'go', 'env', 'GOMODCACHE' }
local ok, err = pcall(vim.system, cmd, { text = true }, function(output)
if output.code == 0 then
if output.stdout then
_G.nvf_gopls_mod_cache = vim.trim(output.stdout)
end
on_dir(get_root(fname))
else
vim.schedule(function()
vim.notify(('[gopls] cmd failed with code %d: %s\n%s'):format(output.code, cmd, output.stderr))
end)
end
end)
if not ok then vim.notify(('[gopls] cmd failed: %s\n%s'):format(cmd, err)) end
end
''; '';
}; };
}; };
@ -94,10 +69,17 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Go LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
type = singleOrListOf (enum (attrNames servers));
default = defaultServers;
description = "Go LSP server to use"; description = "Go LSP server to use";
type = enum (attrNames servers);
default = defaultServer;
};
package = mkOption {
description = "Go LSP server package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.jdt-language-server " - data " " ~/.cache/jdtls/workspace "]'';
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
}; };
}; };
@ -152,12 +134,8 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: { vim.lsp.lspconfig.sources.go-lsp = servers.${cfg.lsp.server}.lspConfig;
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
}) })
(mkIf cfg.format.enable { (mkIf cfg.format.enable {

6
modules/plugins/languages/helm.nix
View file

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

20
modules/plugins/languages/julia.nix
View file

@ -6,17 +6,17 @@
}: let }: let
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) enum; inherit (lib.types) listOf enum;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.dag) entryBefore; inherit (lib.nvim.dag) entryBefore;
defaultServers = ["julials"]; defaultServers = ["jdtls"];
servers = { servers = {
julials = { jdtls = {
enable = true; enable = true;
cmd = cmd =
mkLuaInline mkLuaInline
@ -95,9 +95,9 @@ in {
}; };
lsp = { lsp = {
enable = mkEnableOption "Julia LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Java LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = '' description = ''
Julia LSP Server to Use Julia LSP Server to Use
@ -107,11 +107,9 @@ in {
option, since there is no way to provide only the LSP server. option, since there is no way to provide only the LSP server.
If you want to avoid that, you have to change If you want to avoid that, you have to change
[vim.lsp.servers.julials.cmd](#opt-vim.lsp.servers._name_.cmd) to use [](#opt-vim.languages.julia.lsp.package) to use the Julia binary
the Julia binary in {env}`PATH`, and add the `LanguageServer` in {env}`PATH` (set it to `null`), and add the `LanguageServer` package to
package to Julia in your devshells. Julia in your devshells.
Check the source file of this option for the full `cmd`.
::: :::
''; '';
}; };

4
modules/plugins/languages/markdown.nix
View file

@ -10,7 +10,7 @@
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.types) bool enum package listOf str nullOr; inherit (lib.types) bool enum package listOf str nullOr;
inherit (lib.nvim.lua) toLuaObject; inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption singleOrListOf; inherit (lib.nvim.types) diagnostics mkGrammarOption mkPluginSetupOption;
inherit (lib.nvim.dag) entryAnywhere; inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
@ -63,7 +63,7 @@ in {
servers = mkOption { servers = mkOption {
description = "Markdown LSP server to use"; description = "Markdown LSP server to use";
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
}; };
}; };

6
modules/plugins/languages/nim.nix
View file

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

6
modules/plugins/languages/nix.nix
View file

@ -9,8 +9,8 @@
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package; inherit (lib.types) enum package listOf;
inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf; inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.nix; cfg = config.vim.languages.nix;
@ -98,7 +98,7 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Nix LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Nix LSP server to use"; description = "Nix LSP server to use";
}; };

6
modules/plugins/languages/nu.nix
View file

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

6
modules/plugins/languages/ocaml.nix
View file

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

6
modules/plugins/languages/odin.nix
View file

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

6
modules/plugins/languages/php.nix
View file

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

5
modules/plugins/languages/python.nix
View file

@ -8,9 +8,8 @@
inherit (lib.options) mkEnableOption mkOption literalExpression; inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package bool; inherit (lib.types) enum listOf package str bool;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) singleOrListOf;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
inherit (lib.nvim.dag) entryBefore; inherit (lib.nvim.dag) entryBefore;
@ -230,7 +229,7 @@ in {
enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Python LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Python LSP server to use"; description = "Python LSP server to use";
}; };

8
modules/plugins/languages/r.nix
View file

@ -5,11 +5,11 @@
... ...
}: let }: let
inherit (builtins) attrNames; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption literalExpression;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package; inherit (lib.types) enum listOf package;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
@ -77,7 +77,7 @@ in {
enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "R LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "R LSP server to use"; description = "R LSP server to use";
}; };

6
modules/plugins/languages/ruby.nix
View file

@ -8,8 +8,8 @@
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.nvim.types) mkGrammarOption diagnostics singleOrListOf; inherit (lib.nvim.types) mkGrammarOption diagnostics;
inherit (lib.types) package enum; inherit (lib.types) listOf package enum;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
cfg = config.vim.languages.ruby; cfg = config.vim.languages.ruby;
@ -77,7 +77,7 @@ in {
enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Ruby LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Ruby LSP server to use"; description = "Ruby LSP server to use";
}; };

6
modules/plugins/languages/sql.nix
View file

@ -8,8 +8,8 @@
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.types) enum package str; inherit (lib.types) enum listOf package str;
inherit (lib.nvim.types) diagnostics singleOrListOf; inherit (lib.nvim.types) diagnostics;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
@ -78,7 +78,7 @@ in {
enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "SQL LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "SQL LSP server to use"; description = "SQL LSP server to use";
}; };

6
modules/plugins/languages/svelte.nix
View file

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

6
modules/plugins/languages/tailwind.nix
View file

@ -8,9 +8,8 @@
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.types) enum; inherit (lib.types) enum listOf;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
inherit (lib.nvim.types) singleOrListOf;
inherit (lib.generators) mkLuaInline; inherit (lib.generators) mkLuaInline;
cfg = config.vim.languages.tailwind; cfg = config.vim.languages.tailwind;
@ -121,6 +120,7 @@
workspace_required = true; workspace_required = true;
root_dir = mkLuaInline '' root_dir = mkLuaInline ''
function(bufnr, on_dir) function(bufnr, on_dir)
local util = require 'lspconfig.util'
local root_files = { local root_files = {
-- Generic -- Generic
'tailwind.config.js', 'tailwind.config.js',
@ -154,7 +154,7 @@ in {
enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Tailwindcss LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Tailwindcss LSP server to use"; description = "Tailwindcss LSP server to use";
}; };

234
modules/plugins/languages/ts.nix
View file

@ -4,177 +4,73 @@
lib, lib,
... ...
}: let }: let
inherit (builtins) attrNames elem; inherit (builtins) attrNames;
inherit (lib.options) mkEnableOption mkOption; inherit (lib.options) mkEnableOption mkOption;
inherit (lib.modules) mkIf mkMerge; inherit (lib.modules) mkIf mkMerge;
inherit (lib.lists) isList;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.types) enum package bool; inherit (lib.types) enum either listOf package str bool;
inherit (lib.generators) mkLuaInline; inherit (lib.nvim.lua) expToLua toLuaObject;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption;
inherit (lib.nvim.lua) toLuaObject; inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.types) mkGrammarOption diagnostics mkPluginSetupOption singleOrListOf;
inherit (lib.nvim.dag) entryAnywhere entryBefore;
cfg = config.vim.languages.ts; cfg = config.vim.languages.ts;
defaultServers = ["ts_ls"]; defaultServer = "ts_ls";
servers = let servers = {
ts_ls = { ts_ls = {
cmd = [(getExe pkgs.typescript-language-server) "--stdio"]; package = pkgs.typescript-language-server;
init_options = {hostInfo = "neovim";}; lspConfig = ''
filetypes = [ lspconfig.ts_ls.setup {
"javascript" capabilities = capabilities,
"javascriptreact" on_attach = function(client, bufnr)
"javascript.jsx" attach_keymaps(client, bufnr);
"typescript" client.server_capabilities.documentFormattingProvider = false;
"typescriptreact" end,
"typescript.tsx" cmd = ${
]; if isList cfg.lsp.package
root_markers = ["tsconfig.json" "jsconfig.json" "package.json" ".git"]; then expToLua cfg.lsp.package
handlers = { else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}''
# handle rename request for certain code actions like extracting functions / types }
"_typescript.rename" = mkLuaInline '' }
function(_, result, ctx)
local client = assert(vim.lsp.get_client_by_id(ctx.client_id))
vim.lsp.util.show_document({
uri = result.textDocument.uri,
range = {
start = result.position,
['end'] = result.position,
},
}, client.offset_encoding)
vim.lsp.buf.rename()
return vim.NIL
end
'';
};
on_attach = mkLuaInline ''
function(client, bufnr)
default_on_attach(client, bufnr);
-- ts_ls provides `source.*` code actions that apply to the whole file. These only appear in
-- `vim.lsp.buf.code_action()` if specified in `context.only`.
vim.api.nvim_buf_create_user_command(0, 'LspTypescriptSourceAction', function()
local source_actions = vim.tbl_filter(function(action)
return vim.startswith(action, 'source.')
end, client.server_capabilities.codeActionProvider.codeActionKinds)
vim.lsp.buf.code_action({
context = {
only = source_actions,
},
})
end, {})
end
''; '';
}; };
in {
inherit ts_ls; denols = {
package = pkgs.deno;
lspConfig = ''
vim.g.markdown_fenced_languages = { "ts=typescript" }
lspconfig.denols.setup {
capabilities = capabilities;
on_attach = attach_keymaps,
cmd = ${
if isList cfg.lsp.package
then expToLua cfg.lsp.package
else ''{"${cfg.lsp.package}/bin/deno", "lsp"}''
}
}
'';
};
# Here for backwards compatibility. Still consider tsserver a valid # Here for backwards compatibility. Still consider tsserver a valid
# configuration in the enum, but assert if it's set to *properly* # configuration in the enum, but assert if it's set to *properly*
# redirect the user to the correct server. # redirect the user to the correct server.
tsserver = ts_ls; tsserver = {
package = pkgs.typescript-language-server;
denols = { lspConfig = ''
cmd = [(getExe pkgs.deno) "lsp"]; lspconfig.ts_ls.setup {
cmd_env = {NO_COLOR = true;}; capabilities = capabilities;
filetypes = [ on_attach = attach_keymaps,
"javascript" cmd = ${
"javascriptreact" if isList cfg.lsp.package
"javascript.jsx" then expToLua cfg.lsp.package
"typescript" else ''{"${cfg.lsp.package}/bin/typescript-language-server", "--stdio"}''
"typescriptreact" }
"typescript.tsx" }
];
root_markers = ["deno.json" "deno.jsonc" ".git"];
settings = {
deno = {
enable = true;
suggest = {
imports = {
hosts = {
"https://deno.land" = true;
};
};
};
};
};
handlers = {
"textDocument/definition" = mkLuaInline "nvf_denols_handler";
"textDocument/typeDefinition" = mkLuaInline "nvf_denols_handler";
"textDocument/references" = mkLuaInline "nvf_denols_handler";
};
on_attach = mkLuaInline ''
function(client, bufnr)
default_on_attach(client, bufnr)
vim.api.nvim_buf_create_user_command(0, 'LspDenolsCache', function()
client:exec_cmd({
command = 'deno.cache',
arguments = { {}, vim.uri_from_bufnr(bufnr) },
}, { bufnr = bufnr }, function(err, _result, ctx)
if err then
local uri = ctx.params.arguments[2]
vim.api.nvim_err_writeln('cache command failed for ' .. vim.uri_to_fname(uri))
end
end)
end, {
desc = 'Cache a module and all of its dependencies.',
})
end
''; '';
}; };
}; };
denols_handlers = ''
local function nvf_denols_virtual_text_document_handler(uri, res, client)
if not res then
return nil
end
local lines = vim.split(res.result, '\n')
local bufnr = vim.uri_to_bufnr(uri)
local current_buf = vim.api.nvim_buf_get_lines(bufnr, 0, -1, false)
if #current_buf ~= 0 then
return nil
end
vim.api.nvim_buf_set_lines(bufnr, 0, -1, false, lines)
vim.api.nvim_set_option_value('readonly', true, { buf = bufnr })
vim.api.nvim_set_option_value('modified', false, { buf = bufnr })
vim.api.nvim_set_option_value('modifiable', false, { buf = bufnr })
vim.lsp.buf_attach_client(bufnr, client.id)
end
local function nvf_denols_virtual_text_document(uri, client)
local params = {
textDocument = {
uri = uri,
},
}
local result = client.request_sync('deno/virtualTextDocument', params)
nvf_denols_virtual_text_document_handler(uri, result, client)
end
local function nvf_denols_handler(err, result, ctx, config)
if not result or vim.tbl_isempty(result) then
return nil
end
local client = vim.lsp.get_client_by_id(ctx.client_id)
for _, res in pairs(result) do
local uri = res.uri or res.targetUri
if uri:match '^deno:' then
nvf_denols_virtual_text_document(uri, client)
res['uri'] = uri
res['targetUri'] = uri
end
end
vim.lsp.handlers[ctx.method](err, result, ctx, config)
end
'';
# TODO: specify packages # TODO: specify packages
defaultFormat = "prettier"; defaultFormat = "prettier";
formats = { formats = {
@ -226,10 +122,17 @@ in {
lsp = { lsp = {
enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Typescript/Javascript LSP support" // {default = config.vim.lsp.enable;};
servers = mkOption { server = mkOption {
type = singleOrListOf (enum (attrNames servers));
default = defaultServers;
description = "Typescript/Javascript LSP server to use"; description = "Typescript/Javascript LSP server to use";
type = enum (attrNames servers);
default = defaultServer;
};
package = mkOption {
description = "Typescript/Javascript LSP server package, or the command to run as a list of strings";
example = ''[lib.getExe pkgs.jdt-language-server "-data" "~/.cache/jdtls/workspace"]'';
type = either package (listOf str);
default = servers.${cfg.lsp.server}.package;
}; };
}; };
@ -287,17 +190,8 @@ in {
}) })
(mkIf cfg.lsp.enable { (mkIf cfg.lsp.enable {
vim.lsp.servers = vim.lsp.lspconfig.enable = true;
mapListToAttrs (name: { vim.lsp.lspconfig.sources.ts-lsp = servers.${cfg.lsp.server}.lspConfig;
inherit name;
value = servers.${name};
})
cfg.lsp.servers;
})
(mkIf (cfg.lsp.enable && elem "denols" cfg.lsp.servers) {
vim.globals.markdown_fenced_languages = ["ts=typescript"];
vim.luaConfigRC.denols_handlers = entryBefore ["lsp-servers"] denols_handlers;
}) })
(mkIf cfg.format.enable { (mkIf cfg.format.enable {
@ -340,7 +234,7 @@ in {
{ {
assertions = [ assertions = [
{ {
assertion = cfg.lsp.enable -> !(elem "tsserver" cfg.lsp.servers); assertion = cfg.lsp.enable -> cfg.lsp.server != "tsserver";
message = '' message = ''
As of a recent lspconfig update, the `tsserver` configuration has been renamed As of a recent lspconfig update, the `tsserver` configuration has been renamed
to `ts_ls` to match upstream behaviour of `lspconfig`, and the name `tsserver` to `ts_ls` to match upstream behaviour of `lspconfig`, and the name `tsserver`

4
modules/plugins/languages/typst.nix
View file

@ -9,7 +9,7 @@
inherit (lib.types) nullOr enum attrsOf listOf package str; inherit (lib.types) nullOr enum attrsOf listOf package str;
inherit (lib.attrsets) attrNames; inherit (lib.attrsets) attrNames;
inherit (lib.meta) getExe; inherit (lib.meta) getExe;
inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption singleOrListOf; inherit (lib.nvim.types) mkGrammarOption mkPluginSetupOption;
inherit (lib.nvim.dag) entryAnywhere; inherit (lib.nvim.dag) entryAnywhere;
inherit (lib.nvim.lua) toLuaObject; inherit (lib.nvim.lua) toLuaObject;
inherit (lib.nvim.attrsets) mapListToAttrs; inherit (lib.nvim.attrsets) mapListToAttrs;
@ -114,7 +114,7 @@ in {
enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;}; enable = mkEnableOption "Typst LSP support (typst-lsp)" // {default = config.vim.lsp.enable;};
servers = mkOption { servers = mkOption {
type = singleOrListOf (enum (attrNames servers)); type = listOf (enum (attrNames servers));
default = defaultServers; default = defaultServers;
description = "Typst LSP server to use"; description = "Typst LSP server to use";
}; };

6
modules/plugins/languages/vala.nix
View file

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

6
modules/plugins/languages/wgsl.nix
View file

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

6
modules/plugins/languages/yaml.nix
View file

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

6
modules/plugins/languages/zig.nix
View file

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