Nvim-Utils

nvim-utils is a collection of utility functions and modules for managing Neovim configurations / plugins in Nix. It aims to simplify the creation of reproducible, reusable, and extensible configurations.

nvim-utils is module-based. Just like with NixOS modules, users may create their own modules or use one of several prebuilt ones to build up their configs, depending on their needs.

The plugin backend used in nvim-utils is the wonderful lazy.nvim. For one, this plugin manager is extremely performant and allows for trivial implementation of lazy-loading, resulting in snappy configs. Furthermore, the structure of lazy.nvim's plugin specs lends itself quite nicely to the module structure found within nvim-utils.

Under the hood, each module corresponding to a plugin or component of a user's config is simply transpiled to Lua and inserted into a final init.lua file, as one may already be familiar with. In fact, you may also use nvim-utils to simply generate a valid init.lua and use it as-is!

To get started, view the next page to get your first configuration going.

Getting Started

To create a basic config without any tweaks, we can simply call mkNvimPkg without any additional arguments.

# default.nix
{pkgs ? import <nixpkgs> {}}: let
  nvim-utils = import (builtins.fetchGit {
    url = "https://github.com/toalaah/nvim-utils";
  });
in
  nvim-utils.lib.mkNvimPkg {
    inherit pkgs;
  }

Using Modules

Let's try to set the colorscheme by using the builtin colorschemes module. Make sure to include the corresponding module, otherwise you will get definition errors!

# default.nix
nvim-utils.lib.mkNvimPkg {
  inherit pkgs;
  modules = with nvim-utils.lib.baseModules; [colorschemes.tokyonight];
  configuration = {
    colorschemes.tokyonight.enable = true;
  };
}

Refer to the builtin modules for all available modules along with their options.

Writing Custom Modules

Say we want to use a colorscheme which is not a builtin module. No problem, let's write our own. The process is very similar to writing a NixOS module, as under the hood the same process is used to merge and apply each module.

Let's create a file myCoolColorscheme.nix and use mkSimplePlugin to reduce the amount of boilerplate needed.

# myCoolColorscheme.nix
{ config, pkgs, mkSimplePlugin, ... }: mkSimplePlugin {
  inherit config;
  # The category correspondes to the module path. So we will be able to
  # activate this module by specifying `colorschemes.myCoolColorscheme`
  category = "colorschemes/myCoolColorscheme";
  plugin = pkgs.fetchFromGitHub {
    owner = "user";
    repo = "myCoolColorscheme";
    rev = "v1.0.0";
  };
}

Then in default.nix, simply add the module file and enable the configuration.

# default.nix
nvim-utils.lib.mkNvimPkg {
  inherit pkgs;
  modules = [ ./myCoolColorscheme.nix ];
  configuration = {
    colorschemes.myCoolColorscheme.enable = true;
    # Opts are converted to lua and passed to `myCoolColorscheme.setup()` by lazy.nvim.
    colorschemes.myCoolColorscheme.opts = {
        style = "foo";
        highlights = [ "bar" "baz" ];
    }
  };
}

Autocmds, Keymaps, etc.

Besides plugins, there are a number of other components which you can configure, for instance:

  • Autocommands
  • Keymaps
  • Pre- and post-hooks

Refer to the core module for more information.

Note: The core and lazy modules are implicitly included and do not need to be specified in the modules argument of mkNvimPkg.

Flake Usage

In addition to standard Nix expressions, nvim-utils fully supports flake usage. See the example below.

# flake.nix
{
  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";

  inputs.nvim-utils.url = "github:/toalaah/nvim-utils";
  inputs.nvim-utils.inputs.nixpkgs.follows = "nixpkgs";

  outputs = {
    self,
    nixpkgs,
    nvim-utils,
  }: let
    system = "x86_64-linux";
  in {
    packages.${system}.default = with nvim-utils.lib;
      mkNvimPkg {
        pkgs = import nixpkgs {inherit system;};
        modules = [baseModules.all];
        configuration = import ./configuration.nix;
      };

    apps.${system}.default = let
      pkg = self.packages.${system}.default;
    in {
      type = "app";
      program = "${pkg}/bin/nvim";
    };
  };
}

NixOS / Home Manager Modules

nvim-utils can also directly be used as a NixOS or Home Manager module.

You can import the NixOS module by adding nvim-utils.nixosModules.nvim to your configuration imports.

# configuration.nix
{
  imports = [nvim-utils.nixosModules.nvim]
  # ...
  programs.nvim = {
    enable = true;
    configuraiton = {};
    modules = [];
  };
}

Similarly, you can import the Home Manager module to specify your configuration in a homeManagerConfiguration. Again, you must add the module to Home Manager's extraSpecialArgs when using flakes.

# flake.nix
# ...
outputs = {...}: {
}

# home.nix
{
  imports = [nvim-utils.homeManagerModules.nvim];
  programs.nvim = {
    enable = true;
    configuraiton = {};
    modules = [];
  };
}

lib.lua

lib.lua.rawLua

Type: rawLua :: String -> (a -> String)

Embed raw lua code in a nix expression.

code The lua expression to embed

lib.lua.rawLua usage example

x = rawLua "function(msg) print('hello ' .. msg) end"

toLua x
=> _: "function(msg) print('hello ' .. msg) end"

lib.lua.luaFile

Type: luaFile :: String -> (a -> String)

Embed raw lua code from a file into a nix expression.

The contents of file is embedded as-is into the assigned variable.

file Function argument

lib.lua.luaFile usage example

builtins.readFile ./test.lua
=> "function(msg) print('hello ' .. msg) end"

x = luaFile ./test.lua
=> _: "function(msg) print('hello ' .. msg) end"

lib.lua.processPrimitive

Type: processPrimitive :: value -> String

Converts a primitive value to its stringified lua counterpart.

Types nil, boolean, number, string, and table are convertable from their respective nix-equivalents. Functions are supported in limited a fashion; a passed function must be callable with exactly one argument (which should be ignored in the implementation). The function must return raw lua code (stringified). The following lambda is an example of such a valid function:

foo = _: "function(msg) print('hello ' .. msg) end"

The remaining types userdata and thread are not able to be converted to.

value Value to convert to stringified lua representation

lib.lua.processPrimitive usage example

x = { a = "foo"; b = null }
processPrimitive x.a
=> "\"foo\""
processPrimitive x.b
=> "nil"

lib.lua.toLua

Type: toLua :: values -> String

Converts an attribute set, list, or primitive into its stringified lua representation.

Note on converting attribute sets: Since lua supports both named and unnamed table values (but nix attrsets do not), a magic identifier __index__ is used to convert from named values to anonymous ones. This identified may occur anywhere inside the name. Note that since attrsets are implicitly sorted by key names, you will need to lexicographically sort the keys which you want to anonymize by hand, ex: zzz__index__.

values values to convert to lua

lib.lua.toLua usage example

x = { a = { b = 3; }; __index__baz = "some string"; c = "foo"; d = null; }
y = "some string"

toLua x
=> ''
 { "some string", a = { b = 3 }, c = "foo", d = nil }
''

toLua y
=> "\"some string\""

lib.vim

lib.vim.processVimPrefs

processes each vim namespace (for example vim.g or vim.o) into stringified lua code

ns Function argument

values Function argument

lib.vim.mkKeymap

Creates a lua keymap. Note that opts may be omitted when using this function. Although this results in a curried function, the internal keymap module takes care of this by automatically adding an empty option set at eval-time (see modules/core/keymap.nix).

mode Function argument

lhs Function argument

rhs Function argument

opts Function argument

lib.vim.mkSimplePlugin

Type: mkSimplePlugin :: Attrs -> Attrs

Convenience wrapper for creating plugin modules. Note that this function simply returns a standard module, and as such is equivalent to you doing so.

structured function argument

: config

: The top-level config you have access to in your module.

plugin

: The plugin source (for instance a source produced by pkgs.fetchFromGitHub).

category

: The path to expose your module options under. Each element correspons to a level of nesting in the config. For instace, category = ["foo" "bar"] would expose the options: foo.bar = {...}. You may also pass a string where each nested level is separated by a /. For instance, "foo/bar" is equivalent to the example above.

derivePluginNameFunc

: A function to derive the plugin name from the plugin source. The default implementation uses the repo attribute from plugin (assumes structure similar to a source produced by fetchFromGitHub). The input to this function is plugin. The output must be a string.

moduleName

: The name of the plugin to use in the module options. By default, the implmentation uses the result of derivePluginNameFunc to derive the option namespace from the plugin source.

extraPluginConfig

: Extra options to pass to the lazy plugin spec. The function receives the plugin config at evaluation time as its only input. The output must be an attribute set, which is merged with the final spec. Any options which are accepted by layz's plugin spec should be valid.

noSetup

: Omit the opt options from the final module as well as the plugin spec. You may want to use this if the plugin which you specify does not support a conventional setup() function, for example a vimscript plugin which simply gets loaded.

extraModuleOpts

: Any extra module options to generate for this module. Standard option-conventions apply.

extraConfig

: Extra config to generate for this module if it is enabled. This is merged with the final config. You may, for example, use this to set additional pre/post-hooks or set keymaps, etc.

lib.vim.mkSimplePlugin usage example

myPluginSrc = pkgs.fetchFromGitHub {
  owner = "aUser";
  repo = "aRepo";
  # ...
}

# From inside a module, call mkSimplePlugin:

# myModule.nix
{pkgs, config, lib, ...}: lib.mkSimplePlugin {
  inherit config;
  plugin = myPluginSrc;
  category = [ "colorschemes" "myColorscheme"]
}

Modules

There are a number of pre-built modules offered by nvim-utils. Most of these are completely optional, although some are hard-coded to be included due to their primitive nature.

The following modules are builtin to mkNvimPkg. They cannot be omitted or overwritten.

All other modules are completely optional and need to be manually included as dependencies in mkNvimPkg. For instance, to add the optional treesitter module, you would add baseModules.treesitter to your list of modules.

nvim-utils.lib.mkNvimPkg {
  inherit pkgs;
  modules = with nvim-utils.lib.baseModules; [
    treesitter
    # other modules, for instance your own...
  ];
  # ...
}

plugins

Combined plugin spec passed to lazy.nvim startup function. You should pass your plugin specs generated in modules to this configuration value (see usage examples).

Type: list of (attribute set)

Default: [ ]

Declared by:

rtp

A list of paths to add to the runtimepath. The paths must be placed inside a parent folder named in accordance to where they should be in the runtimepath.

For instance, if you wish to have a lua module module.lua to be available in the rtp, you must place it inside a folder named lua, then add this folder to opt.rtp.

See :h rtp for more information.

Type: list of path

Default: [ ]

Declared by:

preHooks

Lua statements to be executed before lazy startup, newline separated.

Type: strings concatenated with “\n”

Default: ""

Example:

''
  print('hello world')
''

Declared by:

postHooks

Lua statements to be executed after lazy startup, newline separated.

Type: strings concatenated with “\n”

Default: ""

Example:

''
  print('hello world')
''

Declared by:

extraPackages

Extra packages to be included in the wrapped program’s $PATH.

Type: list of package

Default: [ ]

Example:

[ pkgs.hello ]

Declared by:

autocmds

List of autocmds to set. Refer to vim.api.nvim_create_autocmd for usage and option documentation.

Type: list of (submodule)

Default: [ ]

Declared by:

autocmds.*.callback

lua / vimscript function to execute on trigger. Mutually exclusive with command.

Type: null or (function that evaluates to a(n) string) or string

Default: null

Declared by:

autocmds.*.command

The (vim) command to run on trigger. Mutually exclusive with callback

Type: null or string

Default: null

Declared by:

autocmds.*.description

Description of the autocommand.

Type: null or string

Default: null

Declared by:

autocmds.*.event

Event(s) to trigger the autocommand on.

Type: (list of ((function that evaluates to a(n) string) or string)) or (function that evaluates to a(n) string) or string

Default: [ ]

Declared by:

autocmds.*.group

Group of the autocommand.

Type: null or (function that evaluates to a(n) string) or string

Default: null

Declared by:

autocmds.*.nested

Run any further nested autocommands.

Type: boolean

Default: false

Declared by:

autocmds.*.once

Run the autocommand only once.

Type: boolean

Default: false

Declared by:

autocmds.*.pattern

Pattern(s) to match against.

Type: (list of ((function that evaluates to a(n) string) or string)) or (function that evaluates to a(n) string) or string

Default: [ ]

Declared by:

keymaps

List of keymaps to set. Refer to nvim’s documentation on vim.keymap.set for usage and option documentation. Also see lib.vim.mkKeymap.

Type: list of ((function that evaluates to a(n) (attribute set)) or (submodule))

Default: [ ]

Example:

[
  # syntactic sugar for setting a (non recursive) normal-mode keymap.
  (vim.nnoremap "<leader>p" (rawLua "function() print('hello world') end"))
  # note that you can also (but do not have to) pass additional keymap options
  (vim.nnoremap 'j'  "v:count == 0 ? 'gj' : 'j'"  "Move down"  { expr = true; silent = true; })
  # you can also just use raw attrsets if you prefer
  {
    mode = "n";
    lhs = "<leader>r";
    rhs = rawLua "function() print('hello world 2') end";
    opts = {desc = "print another cool message";};
  }
]

Declared by:

lazy.opts

Options passed to lazy.nvim startup function.

Consult the project’s readme for all currently available options.

Note that some options, notably root are hard-coded inside the derivation and are not overridable.

Type: attribute set of unspecified value

Default: { }

Example:

{
  dev.path = "~/dev";
  defaults = {
    lazy = true;
  };
};

Declared by:

lazy.src

Source to use for this plugin. This allows you to swap out the pinned version with a newer revision/fork or add patches by creating a wrapper derivation.

Type: package

Default: <derivation source>

Declared by:

vim.g

Values to set under the vim.g namespace.

Run :help vim.o for from inside the nvim process more information.

Type: attribute set

Default: { }

Declared by:

vim.opt

Values to set under the vim.opt namespace.

Run :help vim.o for from inside the nvim process more information.

Type: attribute set

Default: { }

Declared by:

Adding Telescope Extensions

Since everyone has different needs in their workflow, we have opted not to pre-configure any telescope extensions. You can, however, quite easily add your own in only a couple lines of code.

Let's use the very popular telescope-fzf-native.nvim extension as an example. From your configuration, simple declare the extension source. Registration with telescope will be handled automatically.

{ pkgs, ... }: {
  telescope.extensions.fzf-native = {
    # you can optionally specify `module` to override the lua module which is #
    # called during `telescope.load_extension(<module>)`. By default, the name of
    # the attribute set is used (in this case `fzf-native`, but since we
    # specified a module name `fzf` will be used instead)
    module = "fzf";
    src =
      pkgs.vimPlugins.telescope-fzf-native-nvim
      // {
        owner = "nvim-telescope";
        repo = "fzf-native.nvim";
      };
  };
}

You can, of course, use any source type for src, so fetchers such as pkgs.fetchFromGithub will work as well.

{pkgs, ... }: {
  telescope.extensions.terraform_doc = {
    enable = true;
    src = pkgs.fetchFromGitHub {
      owner = "ANGkeith";
      repo = "telescope-terraform-doc.nvim";
      rev = "4b539fc9a9b647dddebe6b0ccc3eac2a23e3ddcf";
      hash = "sha256-8ry5Og/JLk0n3Ayx1YWUsQSJnA+FBXjilb3f1tKaE/4=";
    };
  };
  # these options are passed to `extensions` in `telescope.setup()`
  opts = {
    wrap = "wrap";
  };
}

Options

telescope.enable

Whether to enable telescope.

Type: boolean

Default: false

Example: true

Declared by:

telescope.extensions

The set of telescope extensions to make available.

Type: attribute set of (submodule)

Default: { }

Declared by:

telescope.extensions.<name>.module

The name of the lua module to load for this extension. If not set, the attribute’s name is used.

Type: null or string

Default: null

Declared by:

telescope.extensions.<name>.opts

Options to use for this extension. These are passed into telescope’s extension opts during setup.

Type: attribute set

Default: { }

Declared by:

telescope.extensions.<name>.src

Source to use for this plugin. This allows you to swap out the pinned version with a newer revision/fork or add patches by creating a wrapper derivation.

Type: package

Declared by:

telescope.keys

A list of keybindings to set up for telescope. follows standard lazy keymap spec.

Type: list of (attribute set)

Default: [ ]

Declared by:

telescope.opts

Options to pass to telescope.

Type: attribute set

Default: { }

Declared by:

telescope.src

Source to use for this plugin. This allows you to swap out the pinned version with a newer revision/fork or add patches by creating a wrapper derivation.

Type: package

Default: <derivation source>

Declared by:

Adding Treesitter Extensions

Since everyone has different needs in their workflow, we have opted not to pre-configure any treesitter extensions. You can, however, quite easily add your own in only a couple lines of code.

Let's use the very popular treesitter playground extension as an example. All you have to to is declare the extension source from your configuration. Registration with treesitter will be handled automatically.

{ pkgs, ... }: {
  treesitter.extensions.treesitter-playground = {
    # you can optionally specify `module` to override the name of the table
    # entry which is passed to `telescope.opts`. By default, the name of
    # the attribute set is used (in this case `treesitter-playground`), but
    # since we specified the `module` parameter explicitly, `playground` will be used
    # instead.
    module = "playground"
    src = pkgs.fetchFromGitHub {
      owner = "nvim-treesitter";
      repo = "playground";
      rev = "2b81a018a49f8e476341dfcb228b7b808baba68b";
      hash = "sha256-2wSTVSkuEvTAq3tB5yLw13WWpp1lAycCL4U1BKMm8Kw=";
    };
    # these values are passed under `opts.playground` in `treesitter.setup()`
    opts.enable = true;
  };
}

Options

treesitter.enable

Whether to enable treesitter.

Type: boolean

Default: false

Example: true

Declared by:

treesitter.extensions

The set of treesitter extensions to make available.

Type: attribute set of (submodule)

Default: { }

Declared by:

treesitter.extensions.<name>.module

The name of the lua module to load for this extension. If not set, the attribute’s name is used.

Type: null or string

Default: null

Declared by:

treesitter.extensions.<name>.opts

Options to use for this extension. These are passed into treesitter’s extension opts during setup.

Type: attribute set

Default: { }

Declared by:

treesitter.extensions.<name>.src

Source to use for this plugin. This allows you to swap out the pinned version with a newer revision/fork or add patches by creating a wrapper derivation.

Type: package

Declared by:

treesitter.keys

A list of keybindings to set up for treesitter. follows standard lazy keymap spec.

Type: list of (attribute set)

Default: [ ]

Declared by:

treesitter.opts

Options to pass to treesitter.

Type: attribute set

Default: { }

Declared by:

treesitter.parsers

list of language parsers to install

Type: list of string

Default: [ ]

Example:

[ "c" "lua" ]

Declared by:

treesitter.src

Source to use for this plugin. This allows you to swap out the pinned version with a newer revision/fork or add patches by creating a wrapper derivation.

Type: package

Default: <derivation source>

Declared by:

lsp.completion.enable

Whether to enable completion support. Uses nvim-cmp under the hood.

Type: boolean

Default: false

Example: true

Declared by:

lsp.completion.opts

Additional options to pass to cmp.setup(). Note that for simple setups (ex: keybindings and sources), you do not need to pass anything to this option and should instead use the keys and sources options respectively (in fact, default keymaps are already set, although they may be overwritten using this option).

The nvim-cmp module is made available in this scope under the variable name cmp.

Type: attribute set

Default: { }

Example:

window = {
  completion = rawLua "cmp.config.window.bordered()";
  documentation = rawLua "cmp.config.window.bordered()";
};

Declared by:

lsp.completion.sources

Extra cmp sources to make available during cmp.setup().

Type: attribute set of (submodule)

Default: { }

Declared by:

lsp.completion.sources.<name>.name

The name of the completion source module. If not set, the attribute’s name is used.

Type: null or string

Default: null

Declared by:

lsp.completion.sources.<name>.opts

Options to use for this completion source. Consult the nvim-cmp documentation for available options.

Type: attribute set

Default: { }

Example:

{
  keyword_length = 5;
}

Declared by:

lsp.completion.sources.<name>.src

The source of the completion module.

Type: package

Declared by:

lsp.completion.src

Source to use for this plugin (note this source refers to the nvim-cmp package to use, although you could swap this out for whatever you like (at the cost of functionality).

Type: package

Default: <derivation source>

Declared by:

lsp.lsp-config.enable

Whether to enable lsp-config.

Type: boolean

Default: false

Example: true

Declared by:

lsp.lsp-config.capabilities

A stringified lua table which is inserted into each language server’s setup function as the capabilities parameter.

Type: string

Default: "vim.lsp.protocol.make_client_capabilities()"

Declared by:

lsp.lsp-config.onAttach

A stringified lua function which is inserted into each language server’s setup function as the on_attach parameter.

Type: string

Default:

''
  function(_, bufnr)
    local opts = { silent = true, buffer = bufnr }
    vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, opts)
    vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts)
    vim.keymap.set('n', 'K', vim.lsp.buf.hover, opts)
    vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, opts)
    vim.keymap.set('n', '<C-k>', vim.lsp.buf.signature_help, opts)
    vim.keymap.set('n', '<space>wa', vim.lsp.buf.add_workspace_folder, opts)
    vim.keymap.set('n', '<space>wr', vim.lsp.buf.remove_workspace_folder, opts)
    vim.keymap.set('n', '<space>wl', function() print(vim.inspect(vim.lsp.buf.list_workspace_folders())) end, opts)
    vim.keymap.set('n', '<space>D', vim.lsp.buf.type_definition, opts)
    vim.keymap.set('n', '<space>rn', vim.lsp.buf.rename, opts)
    vim.keymap.set({ 'n', 'v' }, '<space>ca', vim.lsp.buf.code_action, opts)
    vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts)
    vim.keymap.set('n', '<space>f', function() vim.lsp.buf.format { async = true } end, opts)
  end
''

Declared by:

lsp.lsp-config.servers

A map of server names to their configuration. The configuration is passed to the setup function of the server.

Type: attribute set of (submodule)

Default: { }

Declared by:

lsp.lsp-config.servers.<name>.cmd

The command used to start the language server. Each argv should be a separate list entry.

If you want to use the default lspconfig ‘cmd’ value, set this value to null (this is the default).

Type: null or (list of string)

Default: null

Example:

cmd = [ "${pkgs.myLanguageServer}/bin/my-lsp" "--stdio"];

Declared by:

lsp.lsp-config.servers.<name>.extraOpts

Additional options to pass to the lsp server setup in require('lspconfig')[<name>].setup(<opts>).

Refer to the LSPconfig server configuration documentation for all available options.

Type: attribute set

Default: { }

Declared by:

lsp.lsp-config.src

Source to use for this plugin (note this source refers to the nvim-lspconfig package to use, although you could swap this out for whatever you like (at the cost of functionality).

Type: package

Default: <derivation source>

Declared by:

lsp.snippets.enable

Whether to enable snippet support. Uses luasnip under the hood.

Type: boolean

Default: false

Example: true

Declared by:

lsp.snippets.keys

A list of keybindings to set up for Luasnip. Follows standard lazy keymap spec.

Type: list of (attribute set)

Default: [ ]

Declared by:

lsp.snippets.src

Source to use for this plugin (note this source refers to the luasnip package to use, although you could swap this out for whatever you like (at the cost of functionality).

Type: package

Default: <derivation vimplugin-luasnip-2023-07-26>

Declared by:

languages.lua.enable

Whether to enable lua LSP features / additional language tooling…

Type: boolean

Default: false

Example: true

Declared by:

languages.lua.lspPkg

Lua language server package to use

Type: package

Default: <derivation lua-language-server-3.6.25>

Declared by:

languages.lua.settings

server-configuration settings to pass to the lsp-config setup.

Type: attribute set

Default:

{
  Lua = {
    diagnostics = {
      globals = [
        "vim"
      ];
      unusedLocalExclude = [
        "_*"
      ];
    };
    semantic = {
      enable = false;
    };
    workspace = {
      library = [
        "/nix/store/bn7q02pqq0cjsj239dg1h7s2f3h818jc-rtp"
      ];
    };
  };
  single_file_support = true;
}

Declared by:

languages.nix.enable

Whether to enable nix LSP features / additional language tooling…

Type: boolean

Default: false

Example: true

Declared by:

languages.nix.settings

Additional options passed to nix-lsp.

Consult the project’s documentation for all available options.

Type: attribute set

Default: { }

Declared by:

languages.rust.enable

Whether to enable rust LSP features / additional language tooling…

Type: boolean

Default: false

Example: true

Declared by:

languages.rust.settings

Additional options passed to rust-lsp.

Consult the project’s documentation for all available options.

Type: attribute set

Default: { }

Declared by: