diff --git a/pack/acp/opt/nvim-lspconfig/.codespellignorewords b/pack/acp/opt/nvim-lspconfig/.codespellignorewords new file mode 100644 index 0000000..2666892 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.codespellignorewords @@ -0,0 +1,3 @@ +als +edn +esy diff --git a/pack/acp/opt/nvim-lspconfig/.editorconfig b/pack/acp/opt/nvim-lspconfig/.editorconfig new file mode 100644 index 0000000..489c20c --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.editorconfig @@ -0,0 +1,17 @@ +root = true + +[*] +indent_style = space +indent_size = 2 +tab_width = 8 +end_of_line = lf +insert_final_newline = true +charset = utf-8 + +[*.lua] +indent_style = space +indent_size = 2 + +[{Makefile,**/Makefile,runtime/doc/*.txt}] +indent_style = tab +indent_size = 8 diff --git a/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/bug_report.yml b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/bug_report.yml new file mode 100644 index 0000000..0fe9c1f --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/bug_report.yml @@ -0,0 +1,77 @@ +name: Bug report +description: Report a problem in nvim-lspconfig +labels: [bug] +body: + - type: markdown + attributes: + value: | + Before reporting: search existing issues and ensure you are running the latest nightly of neovim and the latest version of nvim-lspconfig. Note that this repository implements configuration and initialization of language servers. Implementation of the language server spec itself is located in the neovim core repository. + - type: textarea + attributes: + label: "Description" + description: "A short description of the problem you are reporting." + validations: + required: true + - type: textarea + attributes: + label: "Neovim version" + description: "Output of `nvim --version`" + placeholder: | + NVIM v0.6.0-dev+209-g0603eba6e + Build type: Release + LuaJIT 2.1.0-beta3 + validations: + required: true + - type: input + attributes: + label: "Nvim-lspconfig version" + description: "Commit hash" + placeholder: 1344a859864d4e6d23d3f3adf56d49e6386ec0d2 + - type: input + attributes: + label: "Operating system and version" + placeholder: "macOS 11.5" + validations: + required: true + - type: input + attributes: + label: "Affected language servers" + description: "If this issue is specific to one or more language servers, list them here. If not, write 'all'." + placeholder: "clangd" + validations: + required: true + - type: textarea + attributes: + label: "Steps to reproduce" + description: "Steps to reproduce using the minimal config provided below." + placeholder: | + 1. `nvim -nu minimal.lua` + 2. ... + validations: + required: true + - type: textarea + attributes: + label: "Actual behavior" + description: "Observed behavior." + validations: + required: true + - type: textarea + attributes: + label: "Expected behavior" + description: "A description of the behavior you expected." + - type: textarea + attributes: + label: "Minimal config" + render: Lua + description: "You can download a minimal_init.lua via `curl -fLO https://raw.githubusercontent.com/neovim/nvim-lspconfig/master/test/minimal_init.lua`. Then edit it to include your language server and add necessary configuration and paste it here." + validations: + required: true + - type: input + attributes: + label: "LSP log" + description: "If not using the `minimal_init.lua`, add `vim.lsp.set_log_level('debug')` to your LSP setup, upload the log file at `$HOME/.cache/nvim/lsp.log` to https://gist.github.com, and paste the link here." + validations: + required: true + + + diff --git a/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/config.yml b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 0000000..a8893d7 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,6 @@ +blank_issues_enabled: false +contact_links: + - name: Question + url: https://neovim.discourse.group/c/language-server-protocol-lsp/7 + about: Usage questions and support requests are answered in the Neovim Discourse + diff --git a/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/feature_request.yml b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/feature_request.yml new file mode 100644 index 0000000..31f66c7 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/ISSUE_TEMPLATE/feature_request.yml @@ -0,0 +1,24 @@ +name: Feature request +description: Request a feature in nvim-lspconfig +labels: [enhancement] +body: + - type: markdown + attributes: + value: | + Before requesting a new feature, search existing issues. Implementation of the language server protocol itself is located in the neovim core repository, and general feature requests may be better suited for core. + - type: input + attributes: + label: "Language server" + description: "Is the feature specific to a language server? If so, which one(s)?" + placeholder: "clangd" + - type: textarea + attributes: + label: "Requested feature" + validations: + required: true + - type: input + attributes: + label: "Other clients which have this feature" + description: "Is the feature already implemented in another LSP client for (Neo)Vim? If so, which one(s)?" + placeholder: "vim-lsp" + diff --git a/pack/acp/opt/nvim-lspconfig/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md b/pack/acp/opt/nvim-lspconfig/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md new file mode 100644 index 0000000..6e450d7 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/PULL_REQUEST_TEMPLATE/pull_request_template.md @@ -0,0 +1,11 @@ +--- +name: Pull Request +about: Submit a pull request +title: '' +--- + + diff --git a/pack/acp/opt/nvim-lspconfig/.github/ci/run_sanitizer.sh b/pack/acp/opt/nvim-lspconfig/.github/ci/run_sanitizer.sh new file mode 100644 index 0000000..4098d8a --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/ci/run_sanitizer.sh @@ -0,0 +1,16 @@ +#!/usr/bin/env bash +set -e + +REF_BRANCH="$1" +PR_BRANCH="$2" + +# checks for added lines that contain search pattern and prints them +SEARCH_PATTERN="(dirname|fn\.cwd)" + +if git diff --pickaxe-all -U0 -G "${SEARCH_PATTERN}" "${REF_BRANCH}" "${PR_BRANCH}" -- '*.lua' | grep -Ev '(configs|utils)\.lua$' | grep -E "^\+.*${SEARCH_PATTERN}" ; then + echo + echo 'String "dirname" found. There is a high risk that this might contradict the directive:' + echo '"Do not add vim.fn.cwd or util.path.dirname in root_dir".' + echo "see: https://github.com/neovim/nvim-lspconfig/blob/master/CONTRIBUTING.md#adding-a-server-to-lspconfig." + exit 1 +fi diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/close-config-changes.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/close-config-changes.yml new file mode 100644 index 0000000..b45a755 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/close-config-changes.yml @@ -0,0 +1,21 @@ +name: "Close changes to config" +on: [pull_request_target] +jobs: + close-changes: + runs-on: ubuntu-latest + permissions: + pull-requests: write + env: + PR_NUMBER: ${{ github.event.pull_request.number }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + ref: ${{ github.event.pull_request.head.sha }} + - run: | + if ! git diff origin/$GITHUB_BASE_REF...$(git branch --show-current) --exit-code -- doc/server_configurations.md doc/server_configurations.txt; then + gh pr close $PR_NUMBER + gh pr comment $PR_NUMBER --body "This pull request has been automatically closed. Changes to server_configurations.md aren't allowed - edit the lua source file instead. Consult https://github.com/neovim/nvim-lspconfig/blob/master/CONTRIBUTING.md#generating-docs." + exit 1 + fi diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/codespell.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/codespell.yml new file mode 100644 index 0000000..e287638 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/codespell.yml @@ -0,0 +1,21 @@ +name: codespell +on: [pull_request] +jobs: + codespell: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + fetch-depth: 0 + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install codespell + - name: Use codespell + run: | + codespell --quiet-level=2 --check-hidden --skip=./doc/server_configurations.md,./doc/server_configurations.txt --ignore-words=.codespellignorewords || exit diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/commit_lint.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/commit_lint.yml new file mode 100644 index 0000000..0029793 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/commit_lint.yml @@ -0,0 +1,12 @@ +on: [pull_request] +jobs: + lint-commits: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - run: npm install --save-dev @commitlint/{cli,config-conventional} + - run: | + echo "module.exports = { extends: ['@commitlint/config-conventional'] };" > commitlint.config.js + - run: npx commitlint --from HEAD~1 --to HEAD --verbose diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/docgen.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/docgen.yml new file mode 100644 index 0000000..a0fdeaa --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/docgen.yml @@ -0,0 +1,32 @@ +name: docgen + +on: + push: + branches: + - master + +jobs: + docgen: + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/checkout@v2 + - uses: rhysd/action-setup-vim@v1 + with: + neovim: true + version: nightly + - name: Run docgen + run: | + scripts/docgen.sh + - name: Commit changes + env: + COMMIT_MSG: | + docs: update server_configurations.md + skip-checks: true + run: | + git config user.name github-actions + git config user.email github-actions@github.com + git add doc/server_configurations.md doc/server_configurations.txt + # Only commit and push if we have changes + git diff --quiet && git diff --staged --quiet || (git commit -m "${COMMIT_MSG}"; git push) diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/feature-branch-check.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/feature-branch-check.yml new file mode 100644 index 0000000..7e5b460 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/feature-branch-check.yml @@ -0,0 +1,28 @@ +name: Close Non-Feature Branches + +on: + pull_request_target: + branches: + - master + +jobs: + close-master-branch: + runs-on: ubuntu-latest + permissions: + pull-requests: write + env: + PR_NUMBER: ${{ github.event.pull_request.number }} + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + ref: ${{ github.event.pull_request.head.sha }} + + - name: Close if master branch + if: ${{ github.head_ref == 'master' }} + run: | + gh pr close $PR_NUMBER + gh pr comment $PR_NUMBER --body "This pull request has been automatically closed. Please develop on a feature branch. Thank you." + exit 1 diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/lint.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/lint.yml new file mode 100644 index 0000000..9ce8013 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/lint.yml @@ -0,0 +1,54 @@ +name: lint + +on: + pull_request: + branches: + - master + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - name: Checkout sources + uses: actions/checkout@v2 + + - name: Setup luacheck + run: | + sudo apt update + sudo apt install -y lua5.1 luarocks + sudo luarocks install luacheck + + - name: Setup selene + run: | + wget "https://github.com/Kampfkarren/selene/releases/download/$VERSION/selene-$VERSION-linux.zip" + echo "$SHA256_CHECKSUM selene-$VERSION-linux.zip" > "selene-$VERSION-linux.zip.checksum" + sha256sum --check "selene-$VERSION-linux.zip.checksum" + unzip "selene-$VERSION-linux.zip" + install -Dp selene "$HOME/.local/bin/selene" + + echo "::add-matcher::.github/workflows/problem_matchers/selene.json" + env: + VERSION: "0.15.0" + SHA256_CHECKSUM: "8ff9272170158fbd9c1af38206ecadc894dc456665dc9bd9f0d43a26e5e8f1af" + + - name: Add $HOME/.local/bin to $PATH + run: echo "$HOME/.local/bin" >> $GITHUB_PATH + + - name: Run luacheck + run: luacheck lua/* test/* + + - name: Run selene + run: selene --display-style=quiet . + + style-lint: + runs-on: ubuntu-latest + steps: + - name: Checkout sources + uses: actions/checkout@v2 + + - name: Lint with stylua + uses: JohnnyMorganz/stylua-action@1.0.0 + with: + token: ${{ secrets.GITHUB_TOKEN }} + # CLI arguments + args: --check . diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/problem_matchers/selene.json b/pack/acp/opt/nvim-lspconfig/.github/workflows/problem_matchers/selene.json new file mode 100644 index 0000000..4bbf24f --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/problem_matchers/selene.json @@ -0,0 +1,30 @@ +{ + "problemMatcher": [ + { + "owner": "selene-error", + "severity": "error", + "pattern": [ + { + "regexp": "^([^:]+):(\\d+):(\\d+):\\serror(.*)$", + "file": 1, + "line": 2, + "column": 3, + "message": 4 + } + ] + }, + { + "owner": "selene-warning", + "severity": "warning", + "pattern": [ + { + "regexp": "^([^:]+):(\\d+):(\\d+):\\swarning(.*)$", + "file": 1, + "line": 2, + "column": 3, + "message": 4 + } + ] + } + ] +} diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/sanitizer.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/sanitizer.yml new file mode 100644 index 0000000..afd7e92 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/sanitizer.yml @@ -0,0 +1,15 @@ +name: "Dirname Checker" +on: [pull_request] +jobs: + disallowed-root-checker: + runs-on: ubuntu-latest + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - run: | + if ! bash .github/ci/run_sanitizer.sh ${{ github.event.pull_request.base.sha }} ${{ github.event.pull_request.head.sha }}; then + exit 1 + fi diff --git a/pack/acp/opt/nvim-lspconfig/.github/workflows/test.yml b/pack/acp/opt/nvim-lspconfig/.github/workflows/test.yml new file mode 100644 index 0000000..d3a2149 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.github/workflows/test.yml @@ -0,0 +1,53 @@ +name: test + +on: + pull_request: + branches: + - master + +jobs: + ubuntu: + runs-on: ubuntu-latest + steps: + - name: Checkout sources + uses: actions/checkout@v2 + - name: Setup build dependencies + run: | + sudo apt update && + sudo apt install -y ninja-build \ + gettext \ + libtool \ + libtool-bin \ + autoconf \ + automake \ + cmake \ + g++ \ + pkg-config \ + unzip \ + gperf \ + libluajit-5.1-dev \ + libunibilium-dev \ + libmsgpack-dev \ + libtermkey-dev \ + libvterm-dev \ + libjemalloc-dev \ + lua5.1 \ + lua-lpeg \ + lua-mpack \ + lua-bitop + - name: Run test with building Nvim + run: | + make test + macos: + runs-on: macos-latest + steps: + - name: Checkout sources + uses: actions/checkout@v2 + - name: Setup build dependencies + run: | + /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)" && + brew install ninja libtool automake pkg-config gettext + - name: Run test with building Nvim + run: | + make test + diff --git a/pack/acp/opt/nvim-lspconfig/.gitignore b/pack/acp/opt/nvim-lspconfig/.gitignore new file mode 100644 index 0000000..a928eed --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.gitignore @@ -0,0 +1,3 @@ +.luacheckcache +neovim +doc/tags diff --git a/pack/acp/opt/nvim-lspconfig/.luacheckrc b/pack/acp/opt/nvim-lspconfig/.luacheckrc new file mode 100644 index 0000000..a0e81d6 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.luacheckrc @@ -0,0 +1,14 @@ +-- vim: ft=lua tw=80 + +-- Rerun tests only if their modification time changed. +cache = true + +ignore = { + "212", -- Unused argument, In the case of callback function, _arg_name is easier to understand than _, so this option is set to off. + "631", -- max_line_length, vscode pkg URL is too long +} + +-- Global objects defined by the C code +read_globals = { + "vim", +} diff --git a/pack/acp/opt/nvim-lspconfig/.stylua.toml b/pack/acp/opt/nvim-lspconfig/.stylua.toml new file mode 100644 index 0000000..e548311 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/.stylua.toml @@ -0,0 +1,6 @@ +column_width = 120 +line_endings = "Unix" +indent_type = "Spaces" +indent_width = 2 +quote_style = "AutoPreferSingle" +no_call_parentheses = true diff --git a/pack/acp/opt/nvim-lspconfig/CONFIG.md b/pack/acp/opt/nvim-lspconfig/CONFIG.md new file mode 100644 index 0000000..6aac655 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/CONFIG.md @@ -0,0 +1 @@ +Notice: CONFIG.md was moved to [doc/server_configurations.md](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md). This notice will be removed after the release of neovim 0.6. diff --git a/pack/acp/opt/nvim-lspconfig/CONTRIBUTING.md b/pack/acp/opt/nvim-lspconfig/CONTRIBUTING.md new file mode 100644 index 0000000..ff34e8b --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/CONTRIBUTING.md @@ -0,0 +1,109 @@ +## Requirements + +- [Neovim](https://neovim.io/) 0.6 or later +- Lint task requires [luacheck](https://github.com/luarocks/luacheck#installation) and [stylua](https://github.com/JohnnyMorganz/StyLua). If using nix, you can use `nix develop` to install these to a local nix shell. +- Documentation is generated by `scripts/docgen.lua`. + - Only works on linux and macOS + +## Scope of lspconfig + +The point of lspconfig is to provide the minimal configuration necessary for a server to act in compliance with the language server protocol. In general, if a server requires custom client-side commands or off-spec handlers, then the server configuration should be added *without* those in lspconfig and receive a dedicated plugin such as nvim-jdtls, nvim-metals, etc. + +## Pull requests (PRs) + +- To avoid duplicate work, create a draft pull request. +- Avoid cosmetic changes to unrelated files in the same commit. +- Use a [feature branch](https://www.atlassian.com/git/tutorials/comparing-workflows) instead of the master branch. +- Use a **rebase workflow** for small PRs. + - After addressing review comments, it's fine to rebase and force-push. + +## Adding a server to lspconfig + +The general form of adding a new language server is to start with a minimal skeleton. This includes populated the `config` table with a `default_config` and `docs` table. + +When choosing a server name, convert all dashes (`-`) to underscores (`_`) If the name of the server is a unique name (`pyright`, `clangd`) or a commonly used abbreviation (`zls`), prefer this as the server name. If the server instead follows the pattern x-language-server, prefer the convention `x_ls` (`jsonnet_ls`). + +`default_config` should include, at minimum the following: +* `cmd`: a list which includes the executable name as the first entry, with arguments constituting subsequent list elements (`--stdio` is common). +Note that Windows has a limitation when it comes to directly invoking a server that's installed by `npm` or `gem`, so it requires additional handling. + +```lua +local bin_name = 'typescript-language-server' +local cmd = { bin_name, '--stdio' } + +if vim.fn.has 'win32' == 1 then + cmd = { 'cmd.exe', '/C', bin_name, '--stdio' } +end +``` + +* `filetypes`: a list for filetypes a +* `root_dir`: a function (or function handle) which returns the root of the project used to determine if lspconfig should launch a new language server, or attach a previously launched server when you open a new buffer matching the filetype of the server. Note, lspconfig does not offer a dedicated single file mode (this is not codified in the spec). Do not add `vim.fn.cwd` or `util.path.dirname` in `root_dir`. A future version of lspconfig will provide emulation of a single file mode until this is formally codified in the specification. A good fallback is `util.find_git_ancestor`, see other configurations for examples. + +Additionally, the following options are often added: + +* `init_options`: a table sent during initialization, corresponding to initializationOptions sent in [initializeParams](https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#initializeParams) as part of the first request sent from client to server during startup. +* `settings`: a table sent during [`workspace/didChangeConfiguration`](https://microsoft.github.io/language-server-protocol/specifications/specification-3-17/#didChangeConfigurationParams) shortly after server initialization. This is an undocumented convention for most language servers. There is often some duplication with initOptions. + +A minimal example for adding a new language server is shown below for `pyright`, a python language server included in lspconfig: + +```lua +-- Only `configs` must be required, util is optional if you are using the root resolver functions, which is usually the case. +local configs = require 'lspconfig.configs' +local util = require 'lspconfig.util' + +-- Having server name defined here is the convention, this is often times also the first entry in the `cmd` table. +local server_name = 'pyright' + +configs[server_name] = { + default_config = { + -- This should be executable on the command line, arguments (such as `--stdio`) are additional entries in the list. + cmd = { 'pyright-langserver' }, + -- These are the filetypes that the server will either attach or start in response to opening. The user must have a filetype plugin matching the filetype, either via the built-in runtime files or installed via plugin. + filetypes = { 'python' }, + -- The root directory that lspconfig uses to determine if it should start a new language server, or attach the current buffer to a previously running language server. + root_dir = util.find_git_ancestor + end, + }, + docs = { + -- extremely important: the package.json that contains language server settings, not the package.json that contains javascript dependencies for the project, or the package.json that contains vscode specific settings + package_json = 'https://raw.githubusercontent.com/microsoft/pyright/master/packages/vscode-pyright/package.json', + + -- The description should include at minimum the link to the github project, and ideally the steps to install the language server. + description = [[ +https://github.com/microsoft/pyright + +`pyright`, a static type checker and language server for python + +`pyright` can be installed via `npm` +`npm install -g pyright` +]], + }, +} +``` + +## Commit style + +lspconfig, like neovim core, follows the [conventional commit style](https://www.conventionalcommits.org/en/v1.0.0-beta.2/) please submit your commits accordingly. Generally commits will be of the form: + +``` +feat: add lua-language-server support +fix(lua-language-server): update root directory pattern +docs: update README.md +``` + +with the commit body containing additional details. + +## Lint + +PRs are checked with [luacheck](https://github.com/mpeterv/luacheck), [StyLua](https://github.com/JohnnyMorganz/StyLua) and [selene](https://github.com/Kampfkarren/selene). Please run the linter locally before submitting a PR: + + make lint + +## Generating docs + +Github Actions automatically generates `server_configurations.md`. Only modify `scripts/README_template.md` or the `docs` table in the server config (the lua file). Do not modify `server_configurations.md` directly. + +To preview the generated `server_configurations.md` locally, run `scripts/docgen.lua` from +`nvim` (from the project root): + + nvim -R -Es +'set rtp+=$PWD' +'luafile scripts/docgen.lua' diff --git a/pack/acp/opt/nvim-lspconfig/LICENSE.md b/pack/acp/opt/nvim-lspconfig/LICENSE.md new file mode 100644 index 0000000..be03814 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/LICENSE.md @@ -0,0 +1,183 @@ +Copyright Neovim contributors. All rights reserved. + +nvim-lsp is licensed under the terms of the Apache 2.0 license. + +nvim-lsp's license follows: + +==== + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/pack/acp/opt/nvim-lspconfig/Makefile b/pack/acp/opt/nvim-lspconfig/Makefile new file mode 100644 index 0000000..15aa212 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/Makefile @@ -0,0 +1,12 @@ +test: + sh ./scripts/run_test.sh + +lint: + @printf "\nRunning luacheck\n" + luacheck lua/* test/* + @printf "\nRunning selene\n" + selene --display-style=quiet . + @printf "\nRunning stylua\n" + stylua --check . + +.PHONY: test lint diff --git a/pack/acp/opt/nvim-lspconfig/README.md b/pack/acp/opt/nvim-lspconfig/README.md new file mode 100644 index 0000000..603bd03 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/README.md @@ -0,0 +1,209 @@ +# lspconfig + +A [collection of common configurations](doc/server_configurations.md) for Neovim's built-in [language server client](https://neovim.io/doc/user/lsp.html). + +This plugin allows for declaratively configuring, launching, and initializing language servers you have installed on your system. +**Disclaimer: Language server configurations are provided on a best-effort basis and are community-maintained. See [contributions](#contributions).** + +`lspconfig` has extensive help documentation, see `:help lspconfig`. + +# LSP overview + +Neovim supports the Language Server Protocol (LSP), which means it acts as a client to language servers and includes a Lua framework `vim.lsp` for building enhanced LSP tools. LSP facilitates features like: + +- go-to-definition +- find-references +- hover +- completion +- rename +- format +- refactor + +Neovim provides an interface for all of these features, and the language server client is designed to be highly extensible to allow plugins to integrate language server features which are not yet present in Neovim core such as [**auto**-completion](https://github.com/neovim/nvim-lspconfig/wiki/Autocompletion) (as opposed to manual completion with omnifunc) and [snippet integration](https://github.com/neovim/nvim-lspconfig/wiki/Snippets). + +These features are not implemented in this repo, but in Neovim core. See `:help lsp` for more details. + +## Install + +* Requires [Neovim v0.6.0](https://github.com/neovim/neovim/releases/tag/v0.6.0) or [Nightly](https://github.com/neovim/neovim/releases/tag/nightly). Update Neovim and 'lspconfig' before reporting an issue. + +* Install 'lspconfig' like any other Vim plugin, e.g. with [vim-plug](https://github.com/junegunn/vim-plug): + + ```vim + Plug 'neovim/nvim-lspconfig' + ``` + +## Quickstart + +1. Install a language server, e.g. [pyright](doc/server_configurations.md#pyright) + + ```bash + npm i -g pyright + ``` + +2. Add the language server setup to your init.vim. The server name must match those found in the table of contents in [server_configurations.md](doc/server_configurations.md). This list is also accessible via `:help lspconfig-server-configurations`. + + ```lua + lua << EOF + require'lspconfig'.pyright.setup{} + EOF + ``` + +3. Create a project, this project must contain a file matching the root directory trigger. See [Automatically launching language servers](#Automatically-launching-language-servers) for additional info. + + ```bash + mkdir test_python_project + cd test_python_project + git init + touch main.py + ``` + +4. Launch neovim, the language server will now be attached and providing diagnostics (see `:LspInfo`) + + ``` + nvim main.py + ``` + +5. See [Keybindings and completion](#Keybindings-and-completion) for mapping useful functions and enabling omnifunc completion + +## Automatically launching language servers + +In order to automatically launch a language server, 'lspconfig' searches up the directory tree from your current buffer to find a file matching the `root_dir` pattern defined in each server's configuration. For [pyright](doc/server_configurations.md#pyright), this is any directory containing ".git", "setup.py", "setup.cfg", "pyproject.toml", or "requirements.txt"). + +Language servers require each project to have a `root` in order to provide completion and search across symbols that may not be defined in your current file, and to avoid having to index your entire filesystem on each startup. + +## Enabling additional language servers + +Enabling most language servers is as easy as installing the language server, ensuring it is on your PATH, and adding the following to your config: + +```vim +lua << EOF +require'lspconfig'.rust_analyzer.setup{} +EOF +``` + +For a full list of servers, see [server_configurations.md](doc/server_configurations.md) or `:help lspconfig-server-configurations`. This document contains installation instructions and additional, optional, customization suggestions for each language server. For some servers that are not on your system path (e.g., `jdtls`, `elixirls`), you will be required to manually add `cmd` as an entry in the table passed to `setup`. Most language servers can be installed in less than a minute. + +## Keybindings and completion + +'lspconfig' does not map keybindings or enable completion by default. Manual, triggered completion can be provided by neovim's built-in omnifunc. For autocompletion, a general purpose [autocompletion plugin](https://github.com/neovim/nvim-lspconfig/wiki/Autocompletion) is required. The following example configuration provides suggested keymaps for the most commonly used language server functions, and manually triggered completion with omnifunc (\\). +Note: **you must pass the defined `on_attach` as an argument to every `setup {}` call** and **the keybindings in `on_attach` only take effect after the language server has started (attached to the current buffer)**. + +```lua +lua << EOF +local nvim_lsp = require('lspconfig') + +-- Use an on_attach function to only map the following keys +-- after the language server attaches to the current buffer +local on_attach = function(client, bufnr) + local function buf_set_keymap(...) vim.api.nvim_buf_set_keymap(bufnr, ...) end + local function buf_set_option(...) vim.api.nvim_buf_set_option(bufnr, ...) end + + -- Enable completion triggered by + buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc') + + -- Mappings. + local opts = { noremap=true, silent=true } + + -- See `:help vim.lsp.*` for documentation on any of the below functions + buf_set_keymap('n', 'gD', 'lua vim.lsp.buf.declaration()', opts) + buf_set_keymap('n', 'gd', 'lua vim.lsp.buf.definition()', opts) + buf_set_keymap('n', 'K', 'lua vim.lsp.buf.hover()', opts) + buf_set_keymap('n', 'gi', 'lua vim.lsp.buf.implementation()', opts) + buf_set_keymap('n', '', 'lua vim.lsp.buf.signature_help()', opts) + buf_set_keymap('n', 'wa', 'lua vim.lsp.buf.add_workspace_folder()', opts) + buf_set_keymap('n', 'wr', 'lua vim.lsp.buf.remove_workspace_folder()', opts) + buf_set_keymap('n', 'wl', 'lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))', opts) + buf_set_keymap('n', 'D', 'lua vim.lsp.buf.type_definition()', opts) + buf_set_keymap('n', 'rn', 'lua vim.lsp.buf.rename()', opts) + buf_set_keymap('n', 'ca', 'lua vim.lsp.buf.code_action()', opts) + buf_set_keymap('n', 'gr', 'lua vim.lsp.buf.references()', opts) + buf_set_keymap('n', 'e', 'lua vim.diagnostic.open_float()', opts) + buf_set_keymap('n', '[d', 'lua vim.diagnostic.goto_prev()', opts) + buf_set_keymap('n', ']d', 'lua vim.diagnostic.goto_next()', opts) + buf_set_keymap('n', 'q', 'lua vim.diagnostic.setloclist()', opts) + buf_set_keymap('n', 'f', 'lua vim.lsp.buf.formatting()', opts) + +end + +-- Use a loop to conveniently call 'setup' on multiple servers and +-- map buffer local keybindings when the language server attaches +local servers = { 'pyright', 'rust_analyzer', 'tsserver' } +for _, lsp in ipairs(servers) do + nvim_lsp[lsp].setup { + on_attach = on_attach, + flags = { + debounce_text_changes = 150, + } + } +end +EOF +``` + +The `on_attach` hook is used to only activate the bindings after the language server attaches to the current buffer. + +## Debugging + +If you have an issue with 'lspconfig', the first step is to reproduce with a [minimal configuration](https://github.com/neovim/nvim-lspconfig/blob/master/test/minimal_init.lua). + +The most common reasons a language server does not start or attach are: + +1. The language server is not installed. 'lspconfig' does not install language servers for you. You should be able to run the `cmd` defined in each server's lua module from the command line and see that the language server starts. If the `cmd` is an executable name, ensure it is on your path. + +2. Not triggering root detection. The language server will only start if it is opened in a directory, or child directory, containing a file which signals the *root* of the project. Most of the time, this is a `.git` folder, but each server defines the root config in the lua file. See [server_configurations.md](doc/server_configurations.md) or the source for the list of root directories. + +3. Misconfiguration. You must pass `on_attach` and `capabilities` for **each** `setup {}` if you want these to take effect. You must also **not call `setup {}` twice for the same server**. The second call to `setup {}` will overwrite the first. + +:LspInfo provides a handy overview of your active and configured language servers. Note, that it will not report any configuration changes applied in `on_new_config`. + +Before reporting a bug, check your logs and the output of `:LspInfo`. Add the following to your init.vim to enable logging: + +```lua +lua << EOF +vim.lsp.set_log_level("debug") +EOF +``` +Attempt to run the language server, and open the log with: +``` +:lua vim.cmd('e'..vim.lsp.get_log_path()) +``` +Most of the time, the reason for failure is present in the logs. + +## Built-in commands + +* `:LspInfo` shows the status of active and configured language servers. + +The following support tab-completion for all arguments: + +* `:LspStart ` Start the requested server name. Will only successfully start if the command detects a root directory matching the current config. Pass `autostart = false` to your `.setup{}` call for a language server if you would like to launch clients solely with this command. Defaults to all servers matching current buffer filetype. +* `:LspStop ` Defaults to stopping all buffer clients. +* `:LspRestart ` Defaults to restarting all buffer clients. + +## The wiki + +Please see the [wiki](https://github.com/neovim/nvim-lspconfig/wiki) for additional topics, including: + +* [Installing language servers automatically](https://github.com/neovim/nvim-lspconfig/wiki/Installing-language-servers-automatically) +* [Snippets support](https://github.com/neovim/nvim-lspconfig/wiki/Snippets) +* [Project local settings](https://github.com/neovim/nvim-lspconfig/wiki/Project-local-settings) +* [Recommended plugins for enhanced language server features](https://github.com/neovim/nvim-lspconfig/wiki/Language-specific-plugins) + +## Contributions + +If you are missing a language server on the list in [server_configurations.md](doc/server_configurations.md), contributing +a new configuration for it would be appreciated. You can follow these steps: + +1. Read [CONTRIBUTING.md](CONTRIBUTING.md). + +2. Choose a language from [the coc.nvim wiki](https://github.com/neoclide/coc.nvim/wiki/Language-servers) or +[emacs-lsp](https://github.com/emacs-lsp/lsp-mode#supported-languages). + +3. Create a new file at `lua/lspconfig/SERVER_NAME.lua`. + + - Copy an [existing config](https://github.com/neovim/nvim-lspconfig/blob/master/lua/lspconfig/server_configurations/) + to get started. Most configs are simple. For an extensive example see + [texlab.lua](https://github.com/neovim/nvim-lspconfig/blob/master/lua/lspconfig/server_configurations/texlab.lua). + +4. Ask questions on our [Discourse](https://neovim.discourse.group/c/7-category/7) or in the [Neovim Gitter](https://gitter.im/neovim/neovim). + +You can also help out by testing [PRs with the `needs-testing`](https://github.com/neovim/nvim-lspconfig/issues?q=is%3Apr+is%3Aopen+label%3Aneeds-testing) label) that affect language servers you use regularly. diff --git a/pack/acp/opt/nvim-lspconfig/doc/lspconfig.txt b/pack/acp/opt/nvim-lspconfig/doc/lspconfig.txt new file mode 100644 index 0000000..05f6063 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/doc/lspconfig.txt @@ -0,0 +1,648 @@ +*lspconfig.txt* For Nvim version 0.5.1+ Last change: 2021 Nov 7 +============================================================================== +TABLE OF CONTENTS *lspconfig-toc* + +1. Introduction (|lspconfig|) +2. LSP overview (|lspconfig-lsp|) +3. Quickstart (|lspconfig-quickstart|) +4. Setup {} (|lspconfig-setup|) +5. Global defaults (|lspconfig-global-defaults|) +6. Server configurations (|lspconfig-configurations|) + 6a. Adding servers (|lspconfig-adding-servers|) +7. Root directories (|lspconfig-root-detection|) + 7a. Advanced detection (|lspconfig-root-advanced|) + 7b. Single file support (|lspconfig-single-file-support|) +8. Commands (|lspconfig-commands|) +9. Keybindings (|lspconfig-keybindings|) +10. Completion (|lspconfig-completion|) +11. Debugging (|lspconfig-debugging|) +12. Logging (|lspconfig-logging|) +13. Scope (|lspconfig-scope|) + +============================================================================== +INTRODUCTION *lspconfig* + +`lspconfig` is a collection of community contributed configurations for the +built-in language server client in Neovim core. This plugin provides four +primary functionalities: + + - default launch commands, initialization options, and settings for each + server + - a root directory resolver which attempts to detect the root of your project + - an autocommand mapping that either launches a new language server or + attempts to attach a language server to each opened buffer if it falls + under a tracked project + - utility commands such as LspInfo, LspStart, LspStop, and LspRestart for + managing language server instances + +`lspconfig` is not required to use the built-in client, it is only one front-end +interface for when a language server specific plugin is not available. + +See |lspconfig-server-configurations| by typing `K` over it for the complete +list of language servers configurations. + +============================================================================== +LSP OVERVIEW *lspconfig-lsp* + +Nvim supports the Language Server Protocol (LSP) via the built-in language +server client. LSP facilitates many features, some of which include: + +- go-to-definition +- find-references +- hover +- completion +- rename +- format +- refactor + +These features are implemented in Neovim core, not `lspconfig`. See `:help lsp` +for more details. + +NOTE: Feature availability depends on the implementation details of the +server. A server may implement only a subset of these features. Always +consult the server documentation before filing a bug report on a missing +feature. + +============================================================================== +QUICKSTART *lspconfig-quickstart* + +- ensure the server is installed and executable from the command line + +- enable the server in your Neovim configuration (Lua example): +> + require'lspconfig'.clangd.setup{} +< +- create a new project, ensure that it contains a root marker which matches the + server requirements specified in |lspconfig-server-configurations|. + +- open a file within that project, such as `main.c`. + +- If you need more information about a server configuration, read the corresponding + entry in |lspconfig-server-configurations|. + +============================================================================== +THE SETUP METAMETHOD *lspconfig-setup* + +`lspconfig` consists of a collection of language server configurations. Each +configuration exposes a `setup {}` metamethod which makes it easy to directly +use the default configuration or selectively override the defaults. +`setup {}` is the primary interface by which users interact with `lspconfig`. + +Using the default configuration for a server is simple: +> + require'lspconfig'.clangd.setup{} +< +The available server names are listed in |lspconfig-server-configurations| and +match the server name in `config.SERVER_NAME` defined in each configuration's +source file. + +The purpose of `setup{}` is to wrap the call to Nvim's built-in +`vim.lsp.start_client()` with an autocommand that automatically launch a +language server. + +This autocommand calls `start_client()` or `vim.lsp.buf_attach_client()` +depending on whether the current file belongs to a project with a currently +running client. See |lspconfig-root-detection| for more details. + +The `setup{}` function takes a table which contains a superset of the keys +listed in `:help vim.lsp.start_client()` with the following unique entries: + +- {root_dir} + + `function(filename, bufnr)` + + Returns either a filepath (string) or nil. The language server will only + start if the function returns a filepath. + + If a root directory (string) is returned which is unique from any + previously returned root_dir, a new server will be spawned with that + root directory. See |lspconfig-root-detection| for more details + +- {name} + + `string` + + Defaults to the server's name (`clangd`, `pyright`, etc.). + +- {filetypes} + + `list[string] | nil` + + Set of filetypes for which to attempt to resolve {root_dir}. + + May be empty, or server may specify a default value. + +- {autostart} + + `bool` (default: true) + + Controls if the `FileType` autocommand that launches a language server is + created. If `false`, allows for deferring language servers until manually + launched with `:LspStart` (|lspconfig-commands|). + +- {single_file_support} + + `bool` (default: nil) + + Determines if a server is started without a matching root directory. + See |lspconfig-single-file-support|. + +- {on_new_config} + + `function(new_config, new_root_dir)` + + Function executed after a root directory is detected. This is used to + modify the server configuration (including `cmd` itself). Most commonly, + this is used to inject additional arguments into `cmd`. + + If overriding `on_new_config`, ensure that you read the + `on_new_config` defined in the source file of the default configuration + in `lspconfig`. The original `on_new_config` snippet for a given server + should likely be included in your new override. Some configurations + use `on_new_config` to dynamically set or modify `cmd`. + +Note: all entries passed to `setup {}` override the entry in the default +configuration. There is no composition. + +All `config` elements described in `:help vim.lsp.start_client()` can +additionally be overridden via the `setup {}` call. The most commonly +passed overrides to `setup {}` are: + +- {capabilities} `table ` + + a table which represents the neovim client capabilities. Useful for + broadcasting to the server additional functionality (snippets, off-protocol + features) provided by plugins. + +- {cmd} `list[string]` + + a list where each entry corresponds to the blankspace delimited part of + the command that launches the server. The first entry is the binary used + to run the language server. Additional entries are passed as arguments. + + The equivalent `cmd` for: +> + foo --bar baz +< + is: +> + {'foo', '--bar', 'baz} +< +- {handlers} `list[functions]` + + a list of handlers which override the function used to process a response + from a given language server. Applied only to the server referenced by + setup. See |lsp-handler|. + +- {init_options} `table ` + + a table passed during the initialization notification after launching + a language server. Equivalent to the `initializationOptions` field found + in `InitializeParams` in the LSP specification. + + See upstream server documentation for available initialization + options. + +- {on_attach} `function(client, bufnr)` + + Callback invoked by Nvim's built-in client when attaching a buffer to a + language server. Often used to set Nvim (buffer or global) options or to + override the Nvim client properties (`resolved_capabilities`) after a + language server attaches. Most commonly used for settings buffer + local keybindings. See |lspconfig-keybindings| for a usage example. + +- {settings} `table ` + + The `settings` table is sent in `on_init` via a + `workspace/didChangeConfiguration` notification from the Nvim client to + the language server. These settings allow a user to change optional runtime + settings of the language server. + + The script that automatically generates `server_configurations.md` converts + the `package.json` referenced in a server configuration source file + into a list of optional settings listed in |lspconfig-server-configurations|. + + As an example, to set the following settings found in the pyright + documentation: + + `pyright.disableLanguageServices`: `boolean` + `pyright.disableOrganizeImports`: `boolean` + + Nested keys need to be translated into a nested table and passed to + the settings field in `setup {}` as follows: +> + require('lspconfig').pyright.setup{ + settings = { + pyright = { + disableLanguageServices = true, + disableOrganizeImports = true, + } + } + } +< + + Note that the autogenerated settings occasionally include VS code specific + settings. If a setting is not respected by a language server, consult + upstream documentation. + + +============================================================================== +OVERRIDING GLOBAL DEFAULTS *lspconfig-global-defaults* + +The global defaults for all servers can be overridden by extending the +`default_config` table. + +> + local lspconfig = require'lspconfig' + lspconfig.util.default_config = vim.tbl_extend( + "force", + lspconfig.util.default_config, + { + autostart = false, + handlers = { + ["window/logMessage"] = function(err, method, params, client_id) + if params and params.type <= vim.lsp.protocol.MessageType.Log then + vim.lsp.handlers["window/logMessage"](err, method, params, client_id) + end + end; + ["window/showMessage"] = function(err, method, params, client_id) + if params and params.type <= vim.lsp.protocol.MessageType.Warning.Error then + vim.lsp.handlers["window/showMessage"](err, method, params, client_id) + end + end; + } + } + ) +< +`setup {}` can additionally override these defaults in subsequent calls. + +============================================================================== +SERVER CONFIGURATIONS *lspconfig-configurations* + +See |lspconfig-server-configurations| by typing `K` over it for the complete +list of language servers configurations. + +While the `setup {}` function is the primary interface to `lspconfig`, for +servers for which there is not a configuration, it is necessary to define a +configuration directly. This can be useful if there is an outstanding PR that +is in review, or when developing a language server that is unavailable +publicly. This can be done through the `configs` module. + +The `configs` module is a singleton where configs are defined. The schema for +validating using `vim.validate` is: +> + configs.SERVER_NAME = { + default_config = {'t'}; + on_new_config = {'f', true}; + on_attach = {'f', true}; + commands = {'t', true}; + docs = {'t', true}; + } +< +where the structure of the docs table is as follows: +> + docs = { + description = {'s', true}; + default_config = {'t', true}; + } +< +`commands` is a map of `name:definition` key:value pairs, where `definition` +is a list whose first value is a function implementing the command, and the +rest are either array values which will be formed into flags for the command, +or special keys like `description`. Example: +> + commands = { + TexlabBuild = { + function() + buf_build(0) + end; + "-range"; + description = "Build the current buffer"; + }; + }; +< +The `configs.__newindex` metamethod consumes the config definition and returns +an object with a `setup()` method, to be invoked by users: +> + require'lspconfig'.SERVER_NAME.setup{} + +After you set `configs.SERVER_NAME` you can add arbitrary language-specific +functions to it if necessary. + +Example: + +> + configs.texlab.buf_build = buf_build +< +============================================================================== +ADDING NEW SERVERS *lspconfig-adding-servers* + +The three steps for adding and enabling a new server configuration are: + +- load the `lspconfig` module (note that this is a stylistic choice) +> + local lspconfig = require 'lspconfig' +< +- define the configuration + +> + local configs = require 'lspconfig.configs' + + -- Check if the config is already defined (useful when reloading this file) + if not configs.foo_lsp then + configs.foo_lsp = { + default_config = { + cmd = {'/home/neovim/lua-language-server/run.sh'}; + filetypes = {'lua'}; + root_dir = function(fname) + return lspconfig.util.find_git_ancestor(fname) + end; + settings = {}; + }; + } + end + +- call `setup()` to enable the FileType autocmd +> + lspconfig.foo_lsp.setup{} +< +============================================================================== +ROOT DETECTION *lspconfig-root-detection* + *lspconfig-root-dir* + +A project's `root_dir` is used by `lspconfig` to determine whether `lspconfig` +should start a new server, or attach a previous one, to the current file. + +`lspconfig` automatically launches language servers by defining a filetype +autocommand based on the `filetypes` specified in the default configuration of +each server, optionally overridable by the `filetypes` table passed to +`setup`. + +This autocommand triggers a search from the current file position in the +filesystem hierarchy up to the top level directory of your filesystem. The +`root_dir` entry of each configuration is a function that returns true if the +current directory in this traversal matches a given root pattern. + +The following utility functions are provided by `lspconfig`. Each function call +below returns a function that takes as its argument the current buffer path. + +- `util.root_pattern`: function which takes multiple arguments, each + corresponding to a different root pattern against which the contents of the + current directory are matched using |vim.fin.glob()| while traversing up the + filesystem. +> + root_dir = util.root_pattern('pyproject.toml', 'requirements.txt') +< +- `util.find_git_ancestor`: a function that locates the first parent directory + containing a `.git` directory. +> + root_dir = util.find_git_ancestor + +- `util.find_node_modules_ancestor`: a function that locates the first parent + directory containing a `node_modules` directory. +> + root_dir = util.find_node_modules_ancestor +< + +- `util.find_package_json_ancestor`: a function that locates the first parent + directory containing a `package.json`. +> + root_dir = util.find_json_ancestor +< +Note: On Windows, `lspconfig` always assumes forward slash normalized paths with +capitalized drive letters. + +============================================================================== +ADVANCED ROOT DIRECTORY DETECTION *lspconfig-root-advanced* + *lspconfig-root-composition* + +The `root_dir` key in `config` and `setup` can hold any function of the form +> + function custom_root_dir(filename, bufnr) + returns nil | string +> +This allows for rich composition of root directory patterns which is necessary +for some project structures. Example (for Kotlin): +> + local root_files = { + 'settings.gradle', -- Gradle (multi-project) + 'settings.gradle.kts', -- Gradle (multi-project) + 'build.xml', -- Ant + 'pom.xml', -- Maven + } + + local fallback_root_files = { + 'build.gradle', -- Gradle + 'build.gradle.kts', -- Gradle + } + root_dir = function(fname) + local primary = util.root_pattern(unpack(root_files))(fname) + local fallback = util.root_pattern(unpack(fallback_root_files))(fname) + return primary or fallback + end +< +Browsing the source of the default configurations is recommended. + +============================================================================== +SINGLE FILE SUPPORT *lspconfig-single-file-support* + +Language servers require each project to have a `root` in order to provide +features that require cross-file indexing. + +Some servers support not passing a root directory as a proxy for single file +mode under which cross-file features may be degraded. + +`lspconfig` offers limited support for an implicit single-file mode by: + +- first trying to resolve the root directory pattern +- then, if `single_file_support` is enabled for a given language server + configuration, starting the server without sending `rootDirectory` or + `workspaceFolders` during initialization. +- attaching subsequent files in the parent directory to the same server + instance, depending on filetype. + +Cross-file features (navigation, hover) may or may not work depending on the +language server. For a full feature-set, consider moving your files to a +directory with a project structure `lspconfig` can infer. + +Note that in the event that the LSP specification is extended to support a +standard for single-file mode, lspconfig will adopt that standard. + +============================================================================== +COMMANDS *lspconfig-commands* + +- `:LspInfo` shows the status of active and configured language servers. Note + that client id refers to the Nvim RPC instance connected to a given + language server. + +The following commands support tab-completion for all arguments. All commands +that require a client id can either leverage tab-completion or the info +contained in `:LspInfo`: + +- `:LspStart ` launches the requested (configured) client, but only + if it successfully resolves a root directory. Note: Defaults to all + configured servers matching the current buffer filetype. +- `:LspStop ` stops the server with the given client id. Defaults to + stopping all servers active on the current buffer. +- `:LspRestart ` restarts the client with the given client id, and + will attempt to reattach to all previously attached buffers. + +============================================================================== +EXAMPLE KEYBINDINGS *lspconfig-keybindings* + +`lspconfig`, and the core client, do not map any keybindings by default. The +following is an example Lua block which demonstrates how to leverage +`on-attach` to selectively apply keybindings after a language servers has +attached to a given buffer. +> + local nvim_lsp = require('lspconfig') + + -- Use an on_attach function to only map the following keys + -- after the language server attaches to the current buffer + local on_attach = function(client, bufnr) + local function buf_set_keymap(...) vim.api.nvim_buf_set_keymap(bufnr, ...) end + local function buf_set_option(...) vim.api.nvim_buf_set_option(bufnr, ...) end + + -- Enable completion triggered by + buf_set_option('omnifunc', 'v:lua.vim.lsp.omnifunc') + + -- Mappings. + local opts = { noremap=true, silent=true } + + -- See `:help vim.lsp.*` for documentation on any of the below functions + buf_set_keymap('n', 'gD', 'lua vim.lsp.buf.declaration()', opts) + buf_set_keymap('n', 'gd', 'lua vim.lsp.buf.definition()', opts) + buf_set_keymap('n', 'K', 'lua vim.lsp.buf.hover()', opts) + buf_set_keymap('n', 'gi', 'lua vim.lsp.buf.implementation()', opts) + buf_set_keymap('n', '', 'lua vim.lsp.buf.signature_help()', opts) + buf_set_keymap('n', 'wa', 'lua vim.lsp.buf.add_workspace_folder()', opts) + buf_set_keymap('n', 'wr', 'lua vim.lsp.buf.remove_workspace_folder()', opts) + buf_set_keymap('n', 'wl', 'lua print(vim.inspect(vim.lsp.buf.list_workspace_folders()))', opts) + buf_set_keymap('n', 'D', 'lua vim.lsp.buf.type_definition()', opts) + buf_set_keymap('n', 'rn', 'lua vim.lsp.buf.rename()', opts) + buf_set_keymap('n', 'ca', 'lua vim.lsp.buf.code_action()', opts) + buf_set_keymap('n', 'gr', 'lua vim.lsp.buf.references()', opts) + buf_set_keymap('n', 'e', 'lua vim.diagnostic.open_float()', opts) + buf_set_keymap('n', '[d', 'lua vim.diagnostic.goto_prev()', opts) + buf_set_keymap('n', ']d', 'lua vim.diagnostic.goto_next()', opts) + buf_set_keymap('n', 'q', 'lua vim.diagnostic.setloclist()', opts) + buf_set_keymap('n', 'f', 'lua vim.lsp.buf.formatting()', opts) + + end + + -- Use a loop to conveniently call 'setup' on multiple servers and + -- map buffer local keybindings when the language server attaches + local servers = { 'pyright', 'rust_analyzer', 'tsserver' } + for _, lsp in ipairs(servers) do + nvim_lsp[lsp].setup { + on_attach = on_attach, + flags = { + debounce_text_changes = 150, + } + } + end +< +Note: these keymappings are meant for illustration and override some +infrequently used default mappings. + +============================================================================== +COMPLETION SUPPORT *lspconfig-completion* + +Manually triggered completion can be provided by Nvim's built-in omnifunc. +See `:help omnifunc` for more details. + +For autocompletion, Nvim does not offer built-in functionality at this time. +Consult the `lspconfig` wiki, which provides configuration examples for using a +completion plugin with the built-in client + +============================================================================== +DEBUGGING *lspconfig-debugging* + +While using language servers should be easy, debugging issues can be +challenging. First, it is important to identify the source of the issue, which +is typically (in rough order): + +- the language server itself +- a plugin +- overrides in a user configuration +- the built-in client in Nvim core +- `lspconfig` + +The first step in debugging is to test with a minimal configuration (such as +`../test/minimal_init.lua`). Historically, many users problems are due to +plugins or misconfiguration. + +Should that fail, identifying which component is the culprit is challenging. +The following are the only categories of bugs that pertain to `lspconfig`. + +- The root directory inferred for your project is wrong, or it should be + detected but is not due to a bug in the `lspconfig` path utilities. +- The server is launching, but you believe that the default settings, + initialization options, or command arguments are suboptimal and should be + replaced based on your understanding of the server documentation. + +All bugs Nvim's built-in client should be reported to the Nvim core issue +tracker. All bugs pertaining to plugins should be reported to the respective +plugin. All missing features in a language server should be reported to the +upstream language server issue tracker. + +For debugging `lspconfig` issues, the most common hurdles users face are: + + - The language server is not installed or is otherwise not executable. + `lspconfig` does not install language servers for you. Ensure the `cmd` + defined in `server_configurations.md` is executable from the command + line. If the absolute path to the binary is not supplied in `cmd`, ensure + it is on your PATH. + - No root detected. `lspconfig` is built around the concept of projects. See + |lspconfig-root-detection| for more details. Most of the time, + initializing a git repo will suffice. + - Misconfiguration. Often users will override `cmd`, `on_init`, or + `handlers`. Ensure that you debug by using a stock configuration to ensure + your customizations are not introducing issues. + +|LspInfo| provides an overview of your active and configured language servers +which can be useful for debugging. + +Note that it will not report any configuration changes applied in +`on_new_config`. + +============================================================================== +LOGGING *lspconfig-logging* + +When debugging language servers, it is helpful to enable additional logging in +the built-in client, specifically considering the RPC logs. Example: +> + vim.lsp.set_log_level 'trace' + if vim.fn.has 'nvim-0.5.1' == 1 then + require('vim.lsp.log').set_format_func(vim.inspect) + end +< +Attempt to run the language server, and open the log with: + +> + :lua vim.cmd('e'..vim.lsp.get_log_path()) +< +Note that `ERROR` messages containing `stderr` only indicate that the log was +sent to `stderr`. Many servers counter-intuitively send harmless messages +via stderr. + +============================================================================== +SCOPE *lspconfig-scope* + +`lspconfig` is a community effort to create default configurations that fit +within the scope of an official plugin for Nvim. All features that are not +strictly providing default configurations for language servers will be removed +from `lspconfig` in time. The power of the Neovim LSP ecosystem is in the +composability and flexibility of integrating multiple plugins which maximizes +user choice and freedom. + +`lspconfig` also opts to adhere strictly to the LSP specification, with some +small allowances when small modifications to a server configuration are +necessary to enable features critical to its usability. For more featureful +options, the `lspconfig` wiki lists community created plugins that build upon +the built-in client to provide functionality tailored to specific language +servers. + +============================================================================== + +vim:tw=78:ts=8:ft=help:norl: diff --git a/pack/acp/opt/nvim-lspconfig/doc/server_configurations.md b/pack/acp/opt/nvim-lspconfig/doc/server_configurations.md new file mode 100644 index 0000000..fbfae77 --- /dev/null +++ b/pack/acp/opt/nvim-lspconfig/doc/server_configurations.md @@ -0,0 +1,8900 @@ +# Configurations + + +The following LSP configs are included. This documentation is autogenerated from the lua files. Follow a link to find documentation for +that config. This file is accessible in neovim via `:help lspconfig-server-configurations` + +- [als](#als) +- [angularls](#angularls) +- [ansiblels](#ansiblels) +- [arduino_language_server](#arduino_language_server) +- [bashls](#bashls) +- [beancount](#beancount) +- [bicep](#bicep) +- [bsl_ls](#bsl_ls) +- [ccls](#ccls) +- [clangd](#clangd) +- [clojure_lsp](#clojure_lsp) +- [cmake](#cmake) +- [codeqlls](#codeqlls) +- [crystalline](#crystalline) +- [csharp_ls](#csharp_ls) +- [cssls](#cssls) +- [cssmodules_ls](#cssmodules_ls) +- [cucumber_language_server](#cucumber_language_server) +- [dartls](#dartls) +- [denols](#denols) +- [dhall_lsp_server](#dhall_lsp_server) +- [diagnosticls](#diagnosticls) +- [dockerls](#dockerls) +- [dotls](#dotls) +- [efm](#efm) +- [elixirls](#elixirls) +- [elmls](#elmls) +- [ember](#ember) +- [emmet_ls](#emmet_ls) +- [erlangls](#erlangls) +- [esbonio](#esbonio) +- [eslint](#eslint) +- [flow](#flow) +- [flux_lsp](#flux_lsp) +- [foam_ls](#foam_ls) +- [fortls](#fortls) +- [fsautocomplete](#fsautocomplete) +- [fstar](#fstar) +- [gdscript](#gdscript) +- [ghcide](#ghcide) +- [golangci_lint_ls](#golangci_lint_ls) +- [gopls](#gopls) +- [grammarly](#grammarly) +- [graphql](#graphql) +- [groovyls](#groovyls) +- [haxe_language_server](#haxe_language_server) +- [hie](#hie) +- [hls](#hls) +- [html](#html) +- [idris2_lsp](#idris2_lsp) +- [intelephense](#intelephense) +- [java_language_server](#java_language_server) +- [jdtls](#jdtls) +- [jedi_language_server](#jedi_language_server) +- [jsonls](#jsonls) +- [jsonnet_ls](#jsonnet_ls) +- [julials](#julials) +- [kotlin_language_server](#kotlin_language_server) +- [lean3ls](#lean3ls) +- [leanls](#leanls) +- [lelwel_ls](#lelwel_ls) +- [lemminx](#lemminx) +- [ltex](#ltex) +- [metals](#metals) +- [mint](#mint) +- [nickel_ls](#nickel_ls) +- [nimls](#nimls) +- [ocamlls](#ocamlls) +- [ocamllsp](#ocamllsp) +- [omnisharp](#omnisharp) +- [pasls](#pasls) +- [perlls](#perlls) +- [perlpls](#perlpls) +- [phpactor](#phpactor) +- [powershell_es](#powershell_es) +- [prismals](#prismals) +- [psalm](#psalm) +- [puppet](#puppet) +- [purescriptls](#purescriptls) +- [pylsp](#pylsp) +- [pyre](#pyre) +- [pyright](#pyright) +- [quick_lint_js](#quick_lint_js) +- [r_language_server](#r_language_server) +- [racket_langserver](#racket_langserver) +- [remark_ls](#remark_ls) +- [rescriptls](#rescriptls) +- [rls](#rls) +- [rnix](#rnix) +- [robotframework_ls](#robotframework_ls) +- [rome](#rome) +- [rust_analyzer](#rust_analyzer) +- [scry](#scry) +- [serve_d](#serve_d) +- [sixtyfps](#sixtyfps) +- [solang](#solang) +- [solargraph](#solargraph) +- [solc](#solc) +- [solidity_ls](#solidity_ls) +- [sorbet](#sorbet) +- [sourcekit](#sourcekit) +- [spectral](#spectral) +- [sqlls](#sqlls) +- [sqls](#sqls) +- [stylelint_lsp](#stylelint_lsp) +- [sumneko_lua](#sumneko_lua) +- [svelte](#svelte) +- [svls](#svls) +- [tailwindcss](#tailwindcss) +- [taplo](#taplo) +- [terraform_lsp](#terraform_lsp) +- [terraformls](#terraformls) +- [texlab](#texlab) +- [tflint](#tflint) +- [theme_check](#theme_check) +- [tsserver](#tsserver) +- [typeprof](#typeprof) +- [vala_ls](#vala_ls) +- [vdmj](#vdmj) +- [verible](#verible) +- [vimls](#vimls) +- [vls](#vls) +- [volar](#volar) +- [vuels](#vuels) +- [yamlls](#yamlls) +- [zeta_note](#zeta_note) +- [zk](#zk) +- [zls](#zls) + +## als + +https://github.com/AdaCore/ada_language_server + +Installation instructions can be found [here](https://github.com/AdaCore/ada_language_server#Install). + +Can be configured by passing a "settings" object to `als.setup{}`: + +```lua +require('lspconfig').als.setup{ + settings = { + ada = { + projectFile = "project.gpr"; + scenarioVariables = { ... }; + } + } +} +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.als.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ada_language_server" } + filetypes = { "ada" } + root_dir = util.root_pattern("Makefile", ".git", "*.gpr", "*.adc") +``` + + +## angularls + +https://github.com/angular/vscode-ng-language-service + +`angular-language-server` can be installed via npm `npm install -g @angular/language-server`. + +Note, that if you override the default `cmd`, you must also update `on_new_config` to set `new_config.cmd` during startup. + +```lua +local project_library_path = "/path/to/project/lib" +local cmd = {"ngserver", "--stdio", "--tsProbeLocations", project_library_path , "--ngProbeLocations", project_library_path} + +require'lspconfig'.angularls.setup{ + cmd = cmd, + on_new_config = function(new_config,new_root_dir) + new_config.cmd = cmd + end, +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.angularls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ngserver", "--stdio", "--tsProbeLocations", "", "--ngProbeLocations", "" } + filetypes = { "typescript", "html", "typescriptreact", "typescript.tsx" } + root_dir = root_pattern("angular.json", ".git") +``` + + +## ansiblels + +https://github.com/ansible/ansible-language-server + +Language server for the ansible configuration management tool. + +`ansible-language-server` can be installed via `yarn`: +```sh +yarn global add ansible-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ansiblels.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ansible-language-server", "--stdio" } + filetypes = { "yaml", "yaml.ansible" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = { + ansible = { + ansible = { + path = "ansible" + }, + ansibleLint = { + enabled = true, + path = "ansible-lint" + }, + executionEnvironment = { + enabled = false + }, + python = { + interpreterPath = "python" + } + } + } + single_file_support = true +``` + + +## arduino_language_server + +https://github.com/arduino/arduino-language-server + +Language server for Arduino + +The `arduino-language-server` can be installed by running: + go get -u github.com/arduino/arduino-language-server + +The `arduino-cli` tools must also be installed. Follow these instructions for your distro: + https://arduino.github.io/arduino-cli/latest/installation/ + +After installing the `arduino-cli` tools, follow these instructions for generating +a configuration file: + https://arduino.github.io/arduino-cli/latest/getting-started/#create-a-configuration-file +and make sure you install any relevant platforms libraries: + https://arduino.github.io/arduino-cli/latest/getting-started/#install-the-core-for-your-board + +The language server also requires `clangd` be installed. It will look for `clangd` by default but +the binary path can be overridden if need be. + +After all dependencies are installed you'll need to override the lspconfig command for the +language server in your setup function with the necessary configurations: + +```lua +lspconfig.arduino_language_server.setup({ + cmd = { + -- Required + "arduino-language-server", + "-cli-config", "/path/to/arduino-cli.yaml", + -- Optional + "-cli", "/path/to/arduino-cli", + "-clangd", "/path/to/clangd" + } +}) +``` + +For further instruction about configuration options, run `arduino-language-server --help`. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.arduino_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "arduino-language-server" } + filetypes = { "arduino" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## bashls + +https://github.com/mads-hartmann/bash-language-server + +Language server for bash, written using tree sitter in typescript. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.bashls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "bash-language-server", "start" } + cmd_env = { + GLOB_PATTERN = "*@(.sh|.inc|.bash|.command)" + } + filetypes = { "sh" } + root_dir = util.find_git_ancestor + single_file_support = true +``` + + +## beancount + +https://github.com/polarmutex/beancount-language-server#installation + +See https://github.com/polarmutex/beancount-language-server#configuration for configuration options + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.beancount.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "beancount-langserver" } + filetypes = { "beancount" } + init_options = { + journalFile = "", + pythonPath = "python3" + } + root_dir = root_pattern("elm.json") + single_file_support = true +``` + + +## bicep + +https://github.com/azure/bicep +Bicep language server + +Bicep language server can be installed by downloading and extracting a release of bicep-langserver.zip from [Bicep GitHub releases](https://github.com/Azure/bicep/releases). + +Bicep language server requires the [dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. + +Neovim does not have built-in support for the bicep filetype which is required for lspconfig to automatically launch the language server. + +Filetype detection can be added via an autocmd: +```lua +vim.cmd [[ autocmd BufNewFile,BufRead *.bicep set filetype=bicep ]] +``` + +**By default, bicep language server does not have a `cmd` set.** This is because nvim-lspconfig does not make assumptions about your path. You must add the following to your init.vim or init.lua to set `cmd` to the absolute path ($HOME and ~ are not expanded) of the unzipped run script or binary. + +```lua +local bicep_lsp_bin = "/path/to/bicep-langserver/Bicep.LangServer.dll" +require'lspconfig'.bicep.setup{ + cmd = { "dotnet", bicep_lsp_bin }; + ... +} +``` + +To download the latest release and place in /usr/local/bin/bicep-langserver: +```bash +(cd $(mktemp -d) \ + && curl -fLO https://github.com/Azure/bicep/releases/latest/download/bicep-langserver.zip \ + && rm -rf /usr/local/bin/bicep-langserver \ + && unzip -d /usr/local/bin/bicep-langserver bicep-langserver.zip) +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.bicep.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "bicep" } + init_options = {} + root_dir = util.find_git_ancestor +``` + + +## bsl_ls + + https://github.com/1c-syntax/bsl-language-server + + Language Server Protocol implementation for 1C (BSL) - 1C:Enterprise 8 and OneScript languages. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.bsl_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "bsl", "os" } + root_dir = root_pattern(".git") +``` + + +## ccls + +https://github.com/MaskRay/ccls/wiki + +ccls relies on a [JSON compilation database](https://clang.llvm.org/docs/JSONCompilationDatabase.html) specified +as compile_commands.json or, for simpler projects, a .ccls. +For details on how to automatically generate one using CMake look [here](https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html). Alternatively, you can use [Bear](https://github.com/rizsotto/Bear). + +Customization options are passed to ccls at initialization time via init_options, a list of available options can be found [here](https://github.com/MaskRay/ccls/wiki/Customization#initialization-options). For example: + +```lua +local lspconfig = require'lspconfig' +lspconfig.ccls.setup { + init_options = { + compilationDatabaseDirectory = "build"; + index = { + threads = 0; + }; + clang = { + excludeArgs = { "-frounding-math"} ; + }; + } +} + +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ccls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ccls" } + filetypes = { "c", "cpp", "objc", "objcpp" } + root_dir = root_pattern("compile_commands.json", ".ccls", ".git") + single_file_support = false +``` + + +## clangd + +https://clangd.llvm.org/installation.html + +**NOTE:** Clang >= 9 is recommended! See [this issue for more](https://github.com/neovim/nvim-lsp/issues/23). + +clangd relies on a [JSON compilation database](https://clang.llvm.org/docs/JSONCompilationDatabase.html) specified +as compile_commands.json or, for simpler projects, a compile_flags.txt. +For details on how to automatically generate one using CMake look [here](https://cmake.org/cmake/help/latest/variable/CMAKE_EXPORT_COMPILE_COMMANDS.html). Alternatively, you can use [Bear](https://github.com/rizsotto/Bear). + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.clangd.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - ClangdSwitchSourceHeader: Switch between source/header + + Default Values: + capabilities = default capabilities, with offsetEncoding utf-8 + cmd = { "clangd" } + filetypes = { "c", "cpp", "objc", "objcpp" } + root_dir = root_pattern("compile_commands.json", "compile_flags.txt", ".git") or dirname + single_file_support = true +``` + + +## clojure_lsp + +https://github.com/snoe/clojure-lsp + +Clojure Language Server + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.clojure_lsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "clojure-lsp" } + filetypes = { "clojure", "edn" } + root_dir = root_pattern("project.clj", "deps.edn", "build.boot", "shadow-cljs.edn", ".git") +``` + + +## cmake + +https://github.com/regen100/cmake-language-server + +CMake LSP Implementation + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.cmake.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "cmake-language-server" } + filetypes = { "cmake" } + init_options = { + buildDirectory = "build" + } + root_dir = root_pattern(".git", "compile_commands.json", "build") or dirname + single_file_support = true +``` + + +## codeqlls + +Reference: +https://help.semmle.com/codeql/codeql-cli.html + +Binaries: +https://github.com/github/codeql-cli-binaries + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.codeqlls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + before_init = function(initialize_params) + initialize_params['workspaceFolders'] = { + { + name = 'workspace', + uri = initialize_params['rootUri'], + }, + } + end, + cmd = { "codeql", "execute", "language-server", "--check-errors", "ON_CHANGE", "-q" } + filetypes = { "ql" } + log_level = 2 + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = { + search_path = "list containing all search paths, eg: '~/codeql-home/codeql-repo'" + } +``` + + +## crystalline + +https://github.com/elbywan/crystalline + +Crystal language server. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.crystalline.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "crystalline" } + filetypes = { "crystal" } + root_dir = root_pattern('shard.yml', '.git') or dirname + single_file_support = true +``` + + +## csharp_ls + +https://github.com/razzmatazz/csharp-language-server + +Language Server for C#. + +csharp-ls requires the [dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. + +The preferred way to install csharp-ls is with `dotnet tool install --global csharp-ls`. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.csharp_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "csharp-ls" } + filetypes = { "cs" } + init_options = { + AutomaticWorkspaceInit = true + } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## cssls + + +https://github.com/hrsh7th/vscode-langservers-extracted + +`css-languageserver` can be installed via `npm`: + +```sh +npm i -g vscode-langservers-extracted +``` + +Neovim does not currently include built-in snippets. `vscode-css-language-server` only provides completions when snippet support is enabled. To enable completion, install a snippet plugin and add the following override to your language client capabilities during setup. + +```lua +--Enable (broadcasting) snippet capability for completion +local capabilities = vim.lsp.protocol.make_client_capabilities() +capabilities.textDocument.completion.completionItem.snippetSupport = true + +require'lspconfig'.cssls.setup { + capabilities = capabilities, +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.cssls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "vscode-css-language-server", "--stdio" } + filetypes = { "css", "scss", "less" } + root_dir = root_pattern("package.json", ".git") or bufdir + settings = { + css = { + validate = true + }, + less = { + validate = true + }, + scss = { + validate = true + } + } + single_file_support = true +``` + + +## cssmodules_ls + +https://github.com/antonk52/cssmodules-language-server + +Language server for autocompletion and go-to-definition functionality for CSS modules. + +You can install cssmodules-language-server via npm: +```sh +npm install -g cssmodules-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.cssmodules_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "cssmodules-language-server" } + filetypes = { "javascript", "javascriptreact", "typescript", "typescriptreact" } + root_dir = root_pattern("package.json") +``` + + +## cucumber_language_server + +https://cucumber.io +https://github.com/cucumber/common +https://www.npmjs.com/package/@cucumber/language-server + +Language server for Cucumber. + +`cucumber-language-server` can be installed via `npm`: +```sh +npm install -g @cucumber/language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.cucumber_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "cucumber-language-server", "--stdio" } + filetypes = { "cucumber" } + root_dir = util.find_git_ancestor +``` + + +## dartls + +https://github.com/dart-lang/sdk/tree/master/pkg/analysis_server/tool/lsp_spec + +Language server for dart. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.dartls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "dart", "./snapshots/analysis_server.dart.snapshot", "--lsp" } + filetypes = { "dart" } + init_options = { + closingLabels = true, + flutterOutline = true, + onlyAnalyzeProjectsWithOpenFiles = true, + outline = true, + suggestFromUnimportedLibraries = true + } + root_dir = root_pattern("pubspec.yaml") + settings = { + dart = { + completeFunctionCalls = true, + showTodos = true + } + } +``` + + +## denols + +https://github.com/denoland/deno + +Deno's built-in language server + +To approrpiately highlight codefences returned from denols, you will need to augment vim.g.markdown_fenced languages + in your init.lua. Example: + +```lua +vim.g.markdown_fenced_languages = { + "ts=typescript" +} +``` + + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`deno.cache`**: `string` + + Default: `vim.NIL` + + null + +- **`deno.codeLens.implementations`**: `boolean` + + null + +- **`deno.codeLens.references`**: `boolean` + + null + +- **`deno.codeLens.referencesAllFunctions`**: `boolean` + + null + +- **`deno.codeLens.test`**: `boolean` + + Default: `true` + + null + +- **`deno.codeLens.testArgs`**: `array` + + Default: `{ "--allow-all" }` + + Array items: `{type = "string"}` + + null + +- **`deno.config`**: `string` + + Default: `vim.NIL` + + null + +- **`deno.enable`**: `boolean` + + null + +- **`deno.importMap`**: `string` + + Default: `vim.NIL` + + null + +- **`deno.internalDebug`**: `boolean` + + null + +- **`deno.lint`**: `boolean` + + null + +- **`deno.path`**: `string` + + Default: `vim.NIL` + + null + +- **`deno.suggest.autoImports`**: `boolean` + + Default: `true` + + null + +- **`deno.suggest.completeFunctionCalls`**: `boolean` + + null + +- **`deno.suggest.imports.autoDiscover`**: `boolean` + + Default: `true` + + null + +- **`deno.suggest.imports.hosts`**: `object` + + Default: `{["https://crux.land"] = true,["https://deno.land"] = true,["https://x.nest.land"] = true}` + + null + +- **`deno.suggest.names`**: `boolean` + + Default: `true` + + null + +- **`deno.suggest.paths`**: `boolean` + + Default: `true` + + null + +- **`deno.unstable`**: `boolean` + + null + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.denols.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - DenolsCache: Cache a module and all of its dependencies. + + Default Values: + cmd = { "deno", "lsp" } + filetypes = { "javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx" } + handlers = { + ["textDocument/definition"] = , + ["textDocument/references"] = + } + init_options = { + enable = true, + lint = false, + unstable = false + } + root_dir = root_pattern("deno.json", "deno.jsonc", "tsconfig.json", ".git") +``` + + +## dhall_lsp_server + +https://github.com/dhall-lang/dhall-haskell/tree/master/dhall-lsp-server + +language server for dhall + +`dhall-lsp-server` can be installed via cabal: +```sh +cabal install dhall-lsp-server +``` +prebuilt binaries can be found [here](https://github.com/dhall-lang/dhall-haskell/releases). + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.dhall_lsp_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "dhall-lsp-server" } + filetypes = { "dhall" } + root_dir = root_pattern(".git") or dirname + single_file_support = true +``` + + +## diagnosticls + +https://github.com/iamcco/diagnostic-languageserver + +Diagnostic language server integrate with linters. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.diagnosticls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "diagnostic-languageserver", "--stdio" } + filetypes = Empty by default, override to add filetypes + root_dir = Vim's starting directory + single_file_support = true +``` + + +## dockerls + +https://github.com/rcjsuen/dockerfile-language-server-nodejs + +`docker-langserver` can be installed via `npm`: +```sh +npm install -g dockerfile-language-server-nodejs +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.dockerls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "docker-langserver", "--stdio" } + filetypes = { "dockerfile" } + root_dir = root_pattern("Dockerfile") + single_file_support = true +``` + + +## dotls + +https://github.com/nikeee/dot-language-server + +`dot-language-server` can be installed via `npm`: +```sh +npm install -g dot-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.dotls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "dot-language-server", "--stdio" } + filetypes = { "dot" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end + single_file_support = true +``` + + +## efm + +https://github.com/mattn/efm-langserver + +General purpose Language Server that can use specified error message format generated from specified command. + +Requires at minimum EFM version [v0.0.38](https://github.com/mattn/efm-langserver/releases/tag/v0.0.38) to support +launching the language server on single files. If on an older version of EFM, disable single file support: + +```lua +require('lspconfig')['efm'].setup{ + settings = ..., -- You must populate this according to the EFM readme + filetypes = ..., -- Populate this according to the note below + single_file_support = false, -- This is the important line for supporting older version of EFM +} +``` + +Note: In order for neovim's built-in language server client to send the appropriate `languageId` to EFM, **you must +specify `filetypes` in your call to `setup{}`**. Otherwise `lspconfig` will launch EFM on the `BufEnter` instead +of the `FileType` autocommand, and the `filetype` variable used to populate the `languageId` will not yet be set. + +```lua +require('lspconfig')['efm'].setup{ + settings = ..., -- You must populate this according to the EFM readme + filetypes = { 'python','cpp','lua' } +} +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.efm.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "efm-langserver" } + root_dir = util.root_pattern(".git") + single_file_support = true +``` + + +## elixirls + +https://github.com/elixir-lsp/elixir-ls + +`elixir-ls` can be installed by following the instructions [here](https://github.com/elixir-lsp/elixir-ls#building-and-running). + +```bash +curl -fLO https://github.com/elixir-lsp/elixir-ls/releases/latest/download/elixir-ls.zip +unzip elixir-ls.zip -d /path/to/elixir-ls +# Unix +chmod +x /path/to/elixir-ls/language_server.sh +``` + +**By default, elixir-ls doesn't have a `cmd` set.** This is because nvim-lspconfig does not make assumptions about your path. You must add the following to your init.vim or init.lua to set `cmd` to the absolute path ($HOME and ~ are not expanded) of your unzipped elixir-ls. + +```lua +require'lspconfig'.elixirls.setup{ + -- Unix + cmd = { "/path/to/elixir-ls/language_server.sh" }; + -- Windows + cmd = { "/path/to/elixir-ls/language_server.bat" }; + ... +} +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`elixirLS.additionalWatchedExtensions`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Additional file types capable of triggering a build on change + +- **`elixirLS.dialyzerEnabled`**: `boolean` + + Default: `true` + + Run ElixirLS\'s rapid Dialyzer when code is saved + +- **`elixirLS.dialyzerFormat`**: `enum { "dialyzer", "dialyxir_short", "dialyxir_long" }` + + Default: `"dialyxir_long"` + + Formatter to use for Dialyzer warnings + +- **`elixirLS.dialyzerWarnOpts`**: `array` + + Default: `{}` + + Array items: `{enum = { "error_handling", "no_behaviours", "no_contracts", "no_fail_call", "no_fun_app", "no_improper_lists", "no_match", "no_missing_calls", "no_opaque", "no_return", "no_undefined_callbacks", "no_unused", "underspecs", "unknown", "unmatched_returns", "overspecs", "specdiffs" },type = "string"}` + + Dialyzer options to enable or disable warnings\. See Dialyzer\'s documentation for options\. Note that the \"race\_conditions\" option is unsupported + +- **`elixirLS.enableTestLenses`**: `boolean` + + Show code lenses to run tests in terminal + +- **`elixirLS.envVariables`**: `object` + + Environment variables to use for compilation + +- **`elixirLS.fetchDeps`**: `boolean` + + Automatically fetch project dependencies when compiling + +- **`elixirLS.mixEnv`**: `string` + + Default: `"test"` + + Mix environment to use for compilation + +- **`elixirLS.mixTarget`**: `string` + + Mix target to use for compilation \(requires Elixir \>\= 1\.8\) + +- **`elixirLS.projectDir`**: `string` + + Default: `""` + + Subdirectory containing Mix project if not in the project root + +- **`elixirLS.signatureAfterComplete`**: `boolean` + + Default: `true` + + Show signature help after confirming autocomplete + +- **`elixirLS.suggestSpecs`**: `boolean` + + Default: `true` + + Suggest \@spec annotations inline using Dialyzer\'s inferred success typings \(Requires Dialyzer\) + +- **`elixirLS.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the Elixir language server\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.elixirls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "elixir", "eelixir" } + root_dir = root_pattern("mix.exs", ".git") or vim.loop.os_homedir() +``` + + +## elmls + +https://github.com/elm-tooling/elm-language-server#installation + +If you don't want to use Nvim to install it, then you can use: +```sh +npm install -g elm elm-test elm-format @elm-tooling/elm-language-server +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`elmLS.disableElmLSDiagnostics`**: `boolean` + + Disable linting diagnostics from the language server\. + +- **`elmLS.elmFormatPath`**: `string` + + Default: `""` + + The path to your elm\-format executable\. Should be empty by default\, in that case it will assume the name and try to first get it from a local npm installation or a global one\. If you set it manually it will not try to load from the npm folder\. + +- **`elmLS.elmPath`**: `string` + + Default: `""` + + The path to your elm executable\. Should be empty by default\, in that case it will assume the name and try to first get it from a local npm installation or a global one\. If you set it manually it will not try to load from the npm folder\. + +- **`elmLS.elmReviewDiagnostics`**: `enum { "off", "warning", "error" }` + + Default: `"off"` + + Set severity or disable linting diagnostics for elm\-review\. + +- **`elmLS.elmReviewPath`**: `string` + + Default: `""` + + The path to your elm\-review executable\. Should be empty by default\, in that case it will assume the name and try to first get it from a local npm installation or a global one\. If you set it manually it will not try to load from the npm folder\. + +- **`elmLS.elmTestPath`**: `string` + + Default: `""` + + The path to your elm\-test executable\. Should be empty by default\, in that case it will assume the name and try to first get it from a local npm installation or a global one\. If you set it manually it will not try to load from the npm folder\. + +- **`elmLS.elmTestRunner.showElmTestOutput`**: `boolean` + + Show output of elm\-test as terminal task + +- **`elmLS.onlyUpdateDiagnosticsOnSave`**: `boolean` + + Only update compiler diagnostics on save\, not on document change\. + +- **`elmLS.skipInstallPackageConfirmation`**: `boolean` + + Skips confirmation for the Install Package code action\. + +- **`elmLS.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the language server\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.elmls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "elm-language-server" } + filetypes = { "elm" } + init_options = { + elmAnalyseTrigger = "change", + elmFormatPath = "elm-format", + elmPath = "elm", + elmTestPath = "elm-test" + } + root_dir = root_pattern("elm.json") +``` + + +## ember + +https://github.com/lifeart/ember-language-server + +`ember-language-server` can be installed via `npm`: + +```sh +npm install -g @lifeart/ember-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ember.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ember-language-server", "--stdio" } + filetypes = { "handlebars", "typescript", "javascript" } + root_dir = root_pattern("ember-cli-build.js", ".git") +``` + + +## emmet_ls + +https://github.com/aca/emmet-ls + +Package can be installed via `npm`: +```sh +npm install -g emmet-ls +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.emmet_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "emmet-ls", "--stdio" } + filetypes = { "html", "css" } + root_dir = git root + single_file_support = true +``` + + +## erlangls + +https://erlang-ls.github.io + +Language Server for Erlang. + +Clone [erlang_ls](https://github.com/erlang-ls/erlang_ls) +Compile the project with `make` and copy resulting binaries somewhere in your $PATH eg. `cp _build/*/bin/* ~/local/bin` + +Installation instruction can be found [here](https://github.com/erlang-ls/erlang_ls). + +Installation requirements: + - [Erlang OTP 21+](https://github.com/erlang/otp) + - [rebar3 3.9.1+](https://github.com/erlang/rebar3) + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.erlangls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "erlang_ls" } + filetypes = { "erlang" } + root_dir = root_pattern('rebar.config', 'erlang.mk', '.git') + single_file_support = true +``` + + +## esbonio + +https://github.com/swyddfa/esbonio + +Esbonio is a language server for [Sphinx](https://www.sphinx-doc.org/en/master/) documentation projects. +The language server can be installed via pip + +``` +pip install esbonio +``` + +Since Sphinx is highly extensible you will get best results if you install the language server in the same +Python environment as the one used to build your documentation. To ensure that the correct Python environment +is picked up, you can either launch `nvim` with the correct environment activated. + +``` +source env/bin/activate +nvim +``` + +Or you can modify the default `cmd` to include the full path to the Python interpreter. + +```lua +require'lspconfig'.esbonio.setup { + cmd = { '/path/to/virtualenv/bin/python', '-m', 'esbonio' } +} +``` + +Esbonio supports a number of config values passed as `init_options` on startup, for example. + +```lua +require'lspconfig'.esbonio.setup { + init_options = { + server = { + logLevel = "debug" + }, + sphinx = { + confDir = "/path/to/docs", + srcDir = "${confDir}/../docs-src" + } +} +``` + +A full list and explanation of the available options can be found [here](https://swyddfa.github.io/esbonio/docs/lsp/editors/index.html) + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.esbonio.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "python3", "-m", "esbonio" } + filetypes = { "rst" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end +``` + + +## eslint + +https://github.com/hrsh7th/vscode-langservers-extracted + +vscode-eslint-language-server: A linting engine for JavaScript / Typescript + +`vscode-eslint-language-server` can be installed via `npm`: +```sh +npm i -g vscode-langservers-extracted +``` + +vscode-eslint-language-server provides an EslintFixAll command that can be used to format document on save +```vim +autocmd BufWritePre EslintFixAll +``` + +See [vscode-eslint](https://github.com/microsoft/vscode-eslint/blob/55871979d7af184bf09af491b6ea35ebd56822cf/server/src/eslintServer.ts#L216-L229) for configuration options. + +Additional messages you can handle: eslint/noConfig +Messages already handled in lspconfig: eslint/openDoc, eslint/confirmESLintExecution, eslint/probeFailed, eslint/noLibrary + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.eslint.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - EslintFixAll: Fix all eslint problems for this buffer + + Default Values: + cmd = { "vscode-eslint-language-server", "--stdio" } + filetypes = { "javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx", "vue" } + handlers = { + ["eslint/confirmESLintExecution"] = , + ["eslint/noLibrary"] = , + ["eslint/openDoc"] = , + ["eslint/probeFailed"] = + } + on_new_config = function(config, new_root_dir) + -- The "workspaceFolder" is a VSCode concept. It limits how far the + -- server will traverse the file system when locating the ESLint config + -- file (e.g., .eslintrc). + config.settings.workspaceFolder = { + uri = new_root_dir, + name = vim.fn.fnamemodify(new_root_dir, ':t'), + } + end, + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = { + codeAction = { + disableRuleComment = { + enable = true, + location = "separateLine" + }, + showDocumentation = { + enable = true + } + }, + codeActionOnSave = { + enable = false, + mode = "all" + }, + format = true, + nodePath = "", + onIgnoredFiles = "off", + packageManager = "npm", + quiet = false, + rulesCustomizations = {}, + run = "onType", + useESLintClass = false, + validate = "on", + workingDirectory = { + mode = "location" + } + } +``` + + +## flow + +https://flow.org/ +https://github.com/facebook/flow + +See below for how to setup Flow itself. +https://flow.org/en/docs/install/ + +See below for lsp command options. + +```sh +npx flow lsp --help +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`flow.coverageSeverity`**: `enum { "error", "warn", "info" }` + + Default: `"info"` + + Type coverage diagnostic severity + +- **`flow.enabled`**: `boolean` + + Default: `true` + + Is flow enabled + +- **`flow.lazyMode`**: `string` + + Default: `vim.NIL` + + Set value to enable flow lazy mode + +- **`flow.logLevel`**: `enum { "error", "warn", "info", "trace" }` + + Default: `"info"` + + Log level for output panel logs + +- **`flow.pathToFlow`**: `string` + + Default: `"flow"` + + Absolute path to flow binary\. Special var \$\{workspaceFolder\} or \$\{flowconfigDir\} can be used in path \(NOTE\: in windows you can use \'\/\' and can omit \'\.cmd\' in path\) + +- **`flow.runOnEdit`**: `boolean` + + Default: `true` + + If true will run flow on every edit\, otherwise will run only when changes are saved \(Note\: \'useLSP\: true\' only supports syntax errors\) + +- **`flow.showUncovered`**: `boolean` + + If true will show uncovered code by default + +- **`flow.stopFlowOnExit`**: `boolean` + + Default: `true` + + Stop Flow on Exit + +- **`flow.trace.server`** + + Default: `"off"` + + Traces the communication between VSCode and the flow lsp service\. + +- **`flow.useBundledFlow`**: `boolean` + + Default: `true` + + If true will use flow bundled with this plugin if nothing works + +- **`flow.useCodeSnippetOnFunctionSuggest`**: `boolean` + + Default: `true` + + Complete functions with their parameter signature\. + +- **`flow.useNPMPackagedFlow`**: `boolean` + + Default: `true` + + Support using flow through your node\_modules folder\, WARNING\: Checking this box is a security risk\. When you open a project we will immediately run code contained within it\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.flow.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "npx", "--no-install", "flow", "lsp" } + filetypes = { "javascript", "javascriptreact", "javascript.jsx" } + root_dir = root_pattern(".flowconfig") +``` + + +## flux_lsp + +https://github.com/influxdata/flux-lsp +`flux-lsp` can be installed via `cargo`: +```sh +cargo install --git https://github.com/influxdata/flux-lsp +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.flux_lsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "flux-lsp" } + filetypes = { "flux" } + root_dir = util.find_git_ancestor + single_file_support = true +``` + + +## foam_ls + +https://github.com/FoamScience/foam-language-server + +`foam-language-server` can be installed via `npm` +```sh +npm install -g foam-language-server +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.foam_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "foam-ls", "--stdio" } + filetypes = { "foam", "OpenFOAM" } + root_dir = function(path) + if util.path.exists(util.path.join(path, 'system', 'controlDict')) then + return path + end + end) + end, +``` + + +## fortls + +https://github.com/hansec/fortran-language-server + +Fortran Language Server for the Language Server Protocol + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`fortran-ls.autocompletePrefix`**: `boolean` + + Filter autocomplete suggestions with variable prefix + +- **`fortran-ls.disableDiagnostics`**: `boolean` + + Disable diagnostics \(requires v1\.12\.0+\)\. + +- **`fortran-ls.displayVerWarning`**: `boolean` + + Default: `true` + + Provides notifications when the underlying language server is out of date\. + +- **`fortran-ls.enableCodeActions`**: `boolean` + + Enable experimental code actions \(requires v1\.7\.0+\)\. + +- **`fortran-ls.executablePath`**: `string` + + Default: `"fortls"` + + Path to the Fortran language server \(fortls\)\. + +- **`fortran-ls.hoverSignature`**: `boolean` + + Show signature information in hover for argument \(also enables \'variableHover\'\)\. + +- **`fortran-ls.includeSymbolMem`**: `boolean` + + Default: `true` + + Include type members in document outline \(also used for \'Go to Symbol in File\'\) + +- **`fortran-ls.incrementalSync`**: `boolean` + + Default: `true` + + Use incremental synchronization for file changes\. + +- **`fortran-ls.lowercaseIntrinsics`**: `boolean` + + Use lowercase for intrinsics and keywords in autocomplete requests\. + +- **`fortran-ls.maxCommentLineLength`**: `number` + + Default: `-1` + + Maximum comment line length \(requires v1\.8\.0+\)\. + +- **`fortran-ls.maxLineLength`**: `number` + + Default: `-1` + + Maximum line length \(requires v1\.8\.0+\)\. + +- **`fortran-ls.notifyInit`**: `boolean` + + Notify when workspace initialization is complete \(requires v1\.7\.0+\)\. + +- **`fortran-ls.useSignatureHelp`**: `boolean` + + Default: `true` + + Use signature help instead of snippets when available\. + +- **`fortran-ls.variableHover`**: `boolean` + + Show hover information for variables\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.fortls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "fortls" } + filetypes = { "fortran" } + root_dir = root_pattern(".fortls") + settings = { + nthreads = 1 + } +``` + + +## fsautocomplete + +https://github.com/fsharp/FsAutoComplete + +Language Server for F# provided by FsAutoComplete (FSAC). + +FsAutoComplete requires the [dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. + +The preferred way to install FsAutoComplete is with `dotnet tool install --global fsautocomplete`. + +Instructions to compile from source are found on the main [repository](https://github.com/fsharp/FsAutoComplete). + +You may also need to configure the filetype as Vim defaults to Forth for `*.fs` files: + +`autocmd BufNewFile,BufRead *.fs,*.fsx,*.fsi set filetype=fsharp` + +This is automatically done by plugins such as [PhilT/vim-fsharp](https://github.com/PhilT/vim-fsharp), [fsharp/vim-fsharp](https://github.com/fsharp/vim-fsharp), and [adelarsq/neofsharp.vim](https://github.com/adelarsq/neofsharp.vim). + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.fsautocomplete.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "fsautocomplete", "--background-service-enabled" } + filetypes = { "fsharp" } + init_options = { + AutomaticWorkspaceInit = true + } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## fstar + +https://github.com/FStarLang/FStar + +LSP support is included in FStar. Make sure `fstar.exe` is in your PATH. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.fstar.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "fstar.exe", "--lsp" } + filetypes = { "fstar" } + root_dir = util.find_git_ancestor +``` + + +## gdscript + +https://github.com/godotengine/godot + +Language server for GDScript, used by Godot Engine. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.gdscript.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "nc", "localhost", "6008" } + filetypes = { "gd", "gdscript", "gdscript3" } + root_dir = util.root_pattern("project.godot", ".git") +``` + + +## ghcide + +https://github.com/digital-asset/ghcide + +A library for building Haskell IDE tooling. +"ghcide" isn't for end users now. Use "haskell-language-server" instead of "ghcide". + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ghcide.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ghcide", "--lsp" } + filetypes = { "haskell", "lhaskell" } + root_dir = root_pattern("stack.yaml", "hie-bios", "BUILD.bazel", "cabal.config", "package.yaml") +``` + + +## golangci_lint_ls + +Combination of both lint server and client + +https://github.com/nametake/golangci-lint-langserver +https://github.com/golangci/golangci-lint + + +Installation of binaries needed is done via + +``` +go install github.com/nametake/golangci-lint-langserver@latest +go install github.com/golangci/golangci-lint/cmd/golangci-lint@v1.42.1 +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.golangci_lint_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "golangci-lint-langserver" } + filetypes = { "go", "gomod" } + init_options = { + command = { "golangci-lint", "run", "--enable-all", "--disable", "lll", "--out-format", "json" } + } + root_dir = root_pattern('go.mod', '.git') +``` + + +## gopls + +https://github.com/golang/tools/tree/master/gopls + +Google's lsp server for golang. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.gopls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "gopls" } + filetypes = { "go", "gomod", "gotmpl" } + root_dir = root_pattern("go.mod", ".git") +``` + + +## grammarly + +https://github.com/emacs-grammarly/unofficial-grammarly-language-server + +`unofficial-grammarly-language-server` can be installed via `npm`: + +```sh +npm i -g @emacs-grammarly/unofficial-grammarly-language-server +``` + +WARNING: Since this language server uses Grammarly's API, any document you open with it running is shared with them. Please evaluate their [privacy policy](https://www.grammarly.com/privacy-policy) before using this. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.grammarly.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "unofficial-grammarly-language-server", "--stdio" } + filetypes = { "markdown" } + handlers = { + ["$/updateDocumentState"] = + } + root_dir = util.find_git_ancestor + single_file_support = true +``` + + +## graphql + +https://github.com/graphql/graphiql/tree/main/packages/graphql-language-service-cli + +`graphql-lsp` can be installed via `npm`: + +```sh +npm install -g graphql-language-service-cli +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.graphql.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "graphql-lsp", "server", "-m", "stream" } + filetypes = { "graphql", "typescriptreact", "javascriptreact" } + root_dir = root_pattern('.git', '.graphqlrc*', '.graphql.config.*') +``` + + +## groovyls + +https://github.com/prominic/groovy-language-server.git + +Requirements: + - Linux/macOS (for now) + - Java 11+ + +`groovyls` can be installed by following the instructions [here](https://github.com/prominic/groovy-language-server.git#build). + +If you have installed groovy language server, you can set the `cmd` custom path as follow: + +```lua +require'lspconfig'.groovyls.setup{ + -- Unix + cmd = { "java", "-jar", "path/to/groovyls/groovy-language-server-all.jar" }, + ... +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.groovyls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "java", "-jar", "groovy-language-server-all.jar" } + filetypes = { "groovy" } + root_dir = function(fname) + return util.root_pattern 'Jenkinsfile'(fname) or util.find_git_ancestor(fname) + end, +``` + + +## haxe_language_server + +https://github.com/vshaxe/haxe-language-server + +The Haxe language server can be built by running the following commands from +the project's root directory: + + npm install + npx lix run vshaxe-build -t language-server + +This will create `bin/server.js`. Note that the server requires Haxe 3.4.0 or +higher. + +After building the language server, set the `cmd` setting in your setup +function: + +```lua +lspconfig.haxe_language_server.setup({ + cmd = {"node", "path/to/bin/server.js"}, +}) +``` + +By default, an HXML compiler arguments file named `build.hxml` is expected in +your project's root directory. If your file is named something different, +specify it using the `init_options.displayArguments` setting. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.haxe_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "haxe-language-server" } + filetypes = { "haxe" } + init_options = { + displayArguments = { "build.hxml" } + } + root_dir = root_pattern("*.hxml") + settings = { + haxe = { + executable = "haxe" + } + } +``` + + +## hie + +https://github.com/haskell/haskell-ide-engine + +the following init_options are supported (see https://github.com/haskell/haskell-ide-engine#configuration): +```lua +init_options = { + languageServerHaskell = { + hlintOn = bool; + maxNumberOfProblems = number; + diagnosticsDebounceDuration = number; + liquidOn = bool (default false); + completionSnippetsOn = bool (default true); + formatOnImportOn = bool (default true); + formattingProvider = string (default "brittany", alternate "floskell"); + } +} +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`haskell.checkProject`**: `boolean` + + Default: `true` + + Whether to typecheck the entire project on load\. It could drive to bad perfomance in large projects\. + +- **`haskell.formattingProvider`**: `enum { "brittany", "floskell", "fourmolu", "ormolu", "stylish-haskell", "none" }` + + Default: `"ormolu"` + + The formatter to use when formatting a document or range\. Ensure the plugin is enabled\. + +- **`haskell.logFile`**: `string` + + Default: `""` + + If set\, redirects the logs to a file\. + +- **`haskell.maxCompletions`**: `integer` + + Default: `40` + + Maximum number of completions sent to the editor\. + +- **`haskell.openDocumentationInHackage`**: `boolean` + + Default: `true` + + When opening \'Documentation\' for external libraries\, open in hackage by default\. Set to false to instead open in vscode\. + +- **`haskell.openSourceInHackage`**: `boolean` + + Default: `true` + + When opening \'Source\' for external libraries\, open in hackage by default\. Set to false to instead open in vscode\. + +- **`haskell.plugin.class.globalOn`**: `boolean` + + Default: `true` + + Enables type class plugin + +- **`haskell.plugin.eval.globalOn`**: `boolean` + + Default: `true` + + Enables eval plugin + +- **`haskell.plugin.ghcide-completions.config.autoExtendOn`**: `boolean` + + Default: `true` + + null + +- **`haskell.plugin.ghcide-completions.config.snippetsOn`**: `boolean` + + Default: `true` + + null + +- **`haskell.plugin.ghcide-type-lenses.config.mode`**: `enum { "always", "exported", "diagnostics" }` + + Default: `true` + + Control how type lenses are shown + +- **`haskell.plugin.ghcide-type-lenses.globalOn`**: `boolean` + + Default: `true` + + Enables type lenses plugin + +- **`haskell.plugin.haddockComments.globalOn`**: `boolean` + + Default: `true` + + Enables haddock comments plugin + +- **`haskell.plugin.hlint.codeActionsOn`**: `boolean` + + Default: `true` + + Enables hlint code actions \(apply hints\) + +- **`haskell.plugin.hlint.config.flags`**: `array` + + Default: `{}` + + null + +- **`haskell.plugin.hlint.diagnosticsOn`**: `boolean` + + Default: `true` + + Enables hlint diagnostics + +- **`haskell.plugin.importLens.codeActionsOn`**: `boolean` + + Default: `true` + + Enables explicit imports code actions + +- **`haskell.plugin.importLens.codeLensOn`**: `boolean` + + Default: `true` + + Enables explicit imports code lenses + +- **`haskell.plugin.moduleName.globalOn`**: `boolean` + + Default: `true` + + Enables module name plugin + +- **`haskell.plugin.pragmas.codeActionsOn`**: `boolean` + + Default: `true` + + Enables pragmas code actions + +- **`haskell.plugin.pragmas.completionOn`**: `boolean` + + Default: `true` + + Enables pragmas completions + +- **`haskell.plugin.refineImports.globalOn`**: `boolean` + + Default: `true` + + Enables refine imports plugin + +- **`haskell.plugin.retrie.globalOn`**: `boolean` + + Default: `true` + + Enables retrie plugin + +- **`haskell.plugin.splice.globalOn`**: `boolean` + + Default: `true` + + Enables splice plugin \(expand template haskell definitions\) + +- **`haskell.plugin.tactics.config.auto_gas`**: `integer` + + Default: `4` + + null + +- **`haskell.plugin.tactics.config.hole_severity`**: `enum { 1, 2, 3, 4, vim.NIL }` + + Default: `vim.NIL` + + The severity to use when showing hole diagnostics\. + +- **`haskell.plugin.tactics.config.max_use_ctor_actions`**: `integer` + + Default: `5` + + null + +- **`haskell.plugin.tactics.config.proofstate_styling`**: `boolean` + + Default: `true` + + null + +- **`haskell.plugin.tactics.config.timeout_duration`**: `integer` + + Default: `2` + + null + +- **`haskell.plugin.tactics.globalOn`**: `boolean` + + Default: `true` + + Enables Wingman \(tactics\) plugin + +- **`haskell.releasesDownloadStoragePath`**: `string` + + Default: `""` + + null + +- **`haskell.releasesURL`**: `string` + + Default: `""` + + An optional URL to override where to check for haskell\-language\-server releases + +- **`haskell.serverEnvironment`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`haskell.serverExecutablePath`**: `string` + + Default: `""` + + null + +- **`haskell.serverExtraArgs`**: `string` + + Default: `""` + + null + +- **`haskell.trace.client`**: `enum { "off", "error", "info", "debug" }` + + Default: `"info"` + + Sets the log level in the client side\. + +- **`haskell.trace.server`**: `enum { "off", "messages" }` + + Default: `"off"` + + Traces the communication between VS Code and the language server\. + +- **`haskell.updateBehavior`**: `enum { "keep-up-to-date", "prompt", "never-check" }` + + Default: `"keep-up-to-date"` + + null + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.hie.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "hie-wrapper", "--lsp" } + filetypes = { "haskell" } + root_dir = root_pattern("stack.yaml", "package.yaml", ".git") +``` + + +## hls + +https://github.com/haskell/haskell-language-server + +Haskell Language Server + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.hls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "haskell-language-server-wrapper", "--lsp" } + filetypes = { "haskell", "lhaskell" } + lspinfo = function on_stdout(_, data, _) + local version = data[1] + table.insert(extra, 'version: ' .. version) + end + + local opts = { + cwd = cfg.cwd, + stdout_buffered = true, + on_stdout = on_stdout, + } + local chanid = vim.fn.jobstart({ cfg.cmd[1], '--version' }, opts) + vim.fn.jobwait { chanid } + return extra + end, + root_dir = root_pattern("*.cabal", "stack.yaml", "cabal.project", "package.yaml", "hie.yaml") + settings = { + haskell = { + formattingProvider = "ormolu" + } + } +``` + + +## html + +https://github.com/hrsh7th/vscode-langservers-extracted + +`vscode-html-language-server` can be installed via `npm`: +```sh +npm i -g vscode-langservers-extracted +``` + +Neovim does not currently include built-in snippets. `vscode-html-language-server` only provides completions when snippet support is enabled. +To enable completion, install a snippet plugin and add the following override to your language client capabilities during setup. + +```lua +--Enable (broadcasting) snippet capability for completion +local capabilities = vim.lsp.protocol.make_client_capabilities() +capabilities.textDocument.completion.completionItem.snippetSupport = true + +require'lspconfig'.html.setup { + capabilities = capabilities, +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.html.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "vscode-html-language-server", "--stdio" } + filetypes = { "html" } + init_options = { + configurationSection = { "html", "css", "javascript" }, + embeddedLanguages = { + css = true, + javascript = true + } + } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} + single_file_support = true +``` + + +## idris2_lsp + +https://github.com/idris-community/idris2-lsp + +The Idris 2 language server. + +Plugins for the Idris 2 filetype include +[Idris2-Vim](https://github.com/edwinb/idris2-vim) (fewer features, stable) and +[Nvim-Idris2](https://github.com/ShinKage/nvim-idris2) (cutting-edge, +experimental). + +Idris2-Lsp requires a build of Idris 2 that includes the "Idris 2 API" package. +Package managers with known support for this build include the +[AUR](https://aur.archlinux.org/packages/idris2-api-git/) and +[Homebrew](https://formulae.brew.sh/formula/idris2#default). + +If your package manager does not support the Idris 2 API, you will need to build +Idris 2 from source. Refer to the +[the Idris 2 installation instructions](https://github.com/idris-lang/Idris2/blob/main/INSTALL.md) +for details. Steps 5 and 8 are listed as "optional" in that guide, but they are +necessary in order to make the Idris 2 API available. + +You need to install a version of Idris2-Lsp that is compatible with your +version of Idris 2. There should be a branch corresponding to every released +Idris 2 version after v0.4.0. Use the latest commit on that branch. For example, +if you have Idris v0.5.1, you should use the v0.5.1 branch of Idris2-Lsp. + +If your Idris 2 version is newer than the newest Idris2-Lsp branch, use the +latest commit on the `master` branch, and set a reminder to check the Idris2-Lsp +repo for the release of a compatible versioned branch. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.idris2_lsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "idris2-lsp" } + filetypes = { "idris2" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## intelephense + +https://intelephense.com/ + +`intelephense` can be installed via `npm`: +```sh +npm install -g intelephense +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.intelephense.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "intelephense", "--stdio" } + filetypes = { "php" } + root_dir = root_pattern("composer.json", ".git") +``` + + +## java_language_server + +https://github.com/georgewfraser/java-language-server + +Java language server + +Point `cmd` to `lang_server_linux.sh` or the equivalent script for macOS/Windows provided by java-language-server + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`java.addExports`**: `array` + + Array items: `{type = "string"}` + + List of modules to allow access to\, for example \[\"jdk\.compiler\/com\.sun\.tools\.javac\.api\"\] + +- **`java.classPath`**: `array` + + Array items: `{type = "string"}` + + Relative paths from workspace root to \.jar files\, \.zip files\, or folders that should be included in the Java class path + +- **`java.debugTestMethod`**: `array` + + Array items: `{type = "string"}` + + Command to debug one test method\, for example \[\"mvn\"\, \"test\"\, \"\-Dmaven\.surefire\.debug\"\, \"\-Dtest\=\$\{class\}\#\$\{method\}\"\. The test should start paused\, listening for the debugger on port 5005\. + +- **`java.externalDependencies`**: `array` + + Array items: `{pattern = "^[^:]+:[^:]+:[^:]+(:[^:]+:[^:]+)?$",type = "string"}` + + External dependencies of the form groupId\:artifactId\:version or groupId\:artifactId\:packaging\:version\:scope + +- **`java.home`**: `string` + + Absolute path to your Java home directory + +- **`java.testClass`**: `array` + + Array items: `{type = "string"}` + + Command to run all tests in a class\, for example \[\"mvn\"\, \"test\"\, \"\-Dtest\=\$\{class\}\" + +- **`java.testMethod`**: `array` + + Array items: `{type = "string"}` + + Command to run one test method\, for example \[\"mvn\"\, \"test\"\, \"\-Dtest\=\$\{class\}\#\$\{method\}\" + +- **`java.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VSCode and the language server\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.java_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "java" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} +``` + + +## jdtls + +https://projects.eclipse.org/projects/eclipse.jdt.ls + +Language server for Java. + +IMPORTANT: If you want all the features jdtls has to offer, [nvim-jdtls](https://github.com/mfussenegger/nvim-jdtls) +is highly recommended. If all you need is diagnostics, completion, imports, gotos and formatting and some code actions +you can keep reading here. + +For manual installation you can download precompiled binaries from the +[official downloads site](http://download.eclipse.org/jdtls/snapshots/?d) + +Due to the nature of java, settings cannot be inferred. Please set the following +environmental variables to match your installation. If you need per-project configuration +[direnv](https://github.com/direnv/direnv) is highly recommended. + +```bash +# Mandatory: +# .bashrc +export JDTLS_HOME=/path/to/jdtls_root # Directory with the plugin and configs directories + +# Optional: +export JAVA_HOME=/path/to/java_home # In case you don't have java in path or want to use a version in particular +export WORKSPACE=/path/to/workspace # Defaults to $HOME/workspace +``` +```lua + -- init.lua + require'lspconfig'.jdtls.setup{} +``` + +For automatic installation you can use the following unofficial installers/launchers under your own risk: + - [jdtls-launcher](https://github.com/eruizc-dev/jdtls-launcher) (Includes lombok support by default) + ```lua + -- init.lua + require'lspconfig'.jdtls.setup{ cmd = { 'jdtls' } } + ``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`java.autobuild.enabled`**: `boolean` + + Default: `true` + + Enable\/disable the \'auto build\' + +- **`java.codeGeneration.generateComments`**: `boolean` + + Generate method comments when generating the methods\. + +- **`java.codeGeneration.hashCodeEquals.useInstanceof`**: `boolean` + + Use \'instanceof\' to compare types when generating the hashCode and equals methods\. + +- **`java.codeGeneration.hashCodeEquals.useJava7Objects`**: `boolean` + + Use Objects\.hash and Objects\.equals when generating the hashCode and equals methods\. This setting only applies to Java 7 and higher\. + +- **`java.codeGeneration.insertionLocation`**: `enum { "afterCursor", "beforeCursor", "lastMember" }` + + Default: `"afterCursor"` + + Specifies the insertion location of the code generated by source actions\. + +- **`java.codeGeneration.toString.codeStyle`**: `enum { "STRING_CONCATENATION", "STRING_BUILDER", "STRING_BUILDER_CHAINED", "STRING_FORMAT" }` + + Default: `"STRING_CONCATENATION"` + + The code style for generating the toString method\. + +- **`java.codeGeneration.toString.limitElements`**: `integer` + + Default: `0` + + Limit number of items in arrays\/collections\/maps to list\, if 0 then list all\. + +- **`java.codeGeneration.toString.listArrayContents`**: `boolean` + + Default: `true` + + List contents of arrays instead of using native toString\(\)\. + +- **`java.codeGeneration.toString.skipNullValues`**: `boolean` + + Skip null values when generating the toString method\. + +- **`java.codeGeneration.toString.template`**: `string` + + Default: `"${object.className} [${member.name()}=${member.value}, ${otherMembers}]"` + + The template for generating the toString method\. + +- **`java.codeGeneration.useBlocks`**: `boolean` + + Use blocks in \'if\' statements when generating the methods\. + +- **`java.completion.enabled`**: `boolean` + + Default: `true` + + Enable\/disable code completion support + +- **`java.completion.favoriteStaticMembers`**: `array` + + Default: `{ "org.junit.Assert.*", "org.junit.Assume.*", "org.junit.jupiter.api.Assertions.*", "org.junit.jupiter.api.Assumptions.*", "org.junit.jupiter.api.DynamicContainer.*", "org.junit.jupiter.api.DynamicTest.*", "org.mockito.Mockito.*", "org.mockito.ArgumentMatchers.*", "org.mockito.Answers.*" }` + + Defines a list of static members or types with static members\. Content assist will propose those static members even if the import is missing\. + +- **`java.completion.filteredTypes`**: `array` + + Default: `{ "java.awt.*", "com.sun.*", "sun.*", "jdk.*", "org.graalvm.*", "io.micrometer.shaded.*" }` + + Defines the type filters\. All types whose fully qualified name matches the selected filter strings will be ignored in content assist or quick fix proposals and when organizing imports\. For example \'java\.awt\.\*\' will hide all types from the awt packages\. + +- **`java.completion.guessMethodArguments`**: `boolean` + + When set to true\, method arguments are guessed when a method is selected from as list of code assist proposals\. + +- **`java.completion.importOrder`**: `array` + + Default: `{ "java", "javax", "com", "org" }` + + Defines the sorting order of import statements\. A package or type name prefix \(e\.g\. \'org\.eclipse\'\) is a valid entry\. An import is always added to the most specific group\. + +- **`java.completion.maxResults`**: `integer` + + Default: `0` + + null + +- **`java.completion.overwrite`**: `boolean` + + Default: `true` + + When set to true\, code completion overwrites the current text\. When set to false\, code is simply added instead\. + +- **`java.configuration.checkProjectSettingsExclusions`**: `boolean` + + Default: `true` + + Controls whether to exclude extension\-generated project settings files \(\.project\, \.classpath\, \.factorypath\, \.settings\/\) from the file explorer\. + +- **`java.configuration.maven.globalSettings`**: `string` + + Default: `vim.NIL` + + Path to Maven\'s global settings\.xml + +- **`java.configuration.maven.notCoveredPluginExecutionSeverity`**: `enum { "ignore", "warning", "error" }` + + Default: `"warning"` + + Specifies severity if the plugin execution is not covered by Maven build lifecycle\. + +- **`java.configuration.maven.userSettings`**: `string` + + Default: `vim.NIL` + + Path to Maven\'s user settings\.xml + +- **`java.configuration.runtimes`**: `array` + + Default: `{}` + + Array items: `{additionalProperties = false,default = vim.empty_dict(),properties = {default = {description = "Is default runtime? Only one runtime can be default.",type = "boolean"},javadoc = {description = "JDK javadoc path.",type = "string"},name = {description = "Java Execution Environment name. Must be unique.",enum = { "J2SE-1.5", "JavaSE-1.6", "JavaSE-1.7", "JavaSE-1.8", "JavaSE-9", "JavaSE-10", "JavaSE-11", "JavaSE-12", "JavaSE-13", "JavaSE-14", "JavaSE-15", "JavaSE-16", "JavaSE-17" },type = "string"},path = {description = 'JDK home path. Should be the JDK installation directory, not the Java bin path.\n On Windows, backslashes must be escaped, i.e.\n"path":"C:\\\\Program Files\\\\Java\\\\jdk1.8.0_161".',pattern = ".*(?\` or \`\}\` + +- **`java.format.settings.profile`**: `string` + + Default: `vim.NIL` + + Optional formatter profile name from the Eclipse formatter settings\. + +- **`java.format.settings.url`**: `string` + + Default: `vim.NIL` + + null + +- **`java.home`**: `string|null` + + Default: `vim.NIL` + + Specifies the folder path to the JDK \(11 or more recent\) used to launch the Java Language Server\. + On Windows\, backslashes must be escaped\, i\.e\. + \"java\.home\"\:\"C\:\\\\Program Files\\\\Java\\\\jdk11\.0\_8\" + +- **`java.implementationsCodeLens.enabled`**: `boolean` + + Enable\/disable the implementations code lens\. + +- **`java.import.exclusions`**: `array` + + Default: `{ "**/node_modules/**", "**/.metadata/**", "**/archetype-resources/**", "**/META-INF/maven/**" }` + + Configure glob patterns for excluding folders\. Use \`\!\` to negate patterns to allow subfolders imports\. You have to include a parent directory\. The order is important\. + +- **`java.import.generatesMetadataFilesAtProjectRoot`**: `boolean` + + null + +- **`java.import.gradle.arguments`**: `string` + + Default: `vim.NIL` + + Arguments to pass to Gradle\. + +- **`java.import.gradle.enabled`**: `boolean` + + Default: `true` + + Enable\/disable the Gradle importer\. + +- **`java.import.gradle.home`**: `string` + + Default: `vim.NIL` + + Use Gradle from the specified local installation directory or GRADLE\_HOME if the Gradle wrapper is missing or disabled and no \'java\.import\.gradle\.version\' is specified\. + +- **`java.import.gradle.java.home`**: `string` + + Default: `vim.NIL` + + The location to the JVM used to run the Gradle daemon\. + +- **`java.import.gradle.jvmArguments`**: `string` + + Default: `vim.NIL` + + JVM arguments to pass to Gradle\. + +- **`java.import.gradle.offline.enabled`**: `boolean` + + Enable\/disable the Gradle offline mode\. + +- **`java.import.gradle.user.home`**: `string` + + Default: `vim.NIL` + + Setting for GRADLE\_USER\_HOME\. + +- **`java.import.gradle.version`**: `string` + + Default: `vim.NIL` + + Use Gradle from the specific version if the Gradle wrapper is missing or disabled\. + +- **`java.import.gradle.wrapper.enabled`**: `boolean` + + Default: `true` + + Use Gradle from the \'gradle\-wrapper\.properties\' file\. + +- **`java.import.maven.enabled`**: `boolean` + + Default: `true` + + Enable\/disable the Maven importer\. + +- **`java.imports.gradle.wrapper.checksums`**: `array` + + Default: `{}` + + Array items: `{additionalProperties = false,default = vim.empty_dict(),properties = {allowed = {default = true,label = "Is allowed?",type = "boolean"},sha256 = {label = "SHA-256 checksum.",type = "string"}},required = { "sha256" },type = "object",uniqueItems = true}` + + Defines allowed\/disallowed SHA\-256 checksums of Gradle Wrappers + +- **`java.jdt.ls.vmargs`**: `string|null` + + Default: `"-XX:+UseParallelGC -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -Dsun.zip.disableMemoryMapping=true -Xmx1G -Xms100m"` + + Specifies extra VM arguments used to launch the Java Language Server\. Eg\. use \`\-XX\:+UseParallelGC \-XX\:GCTimeRatio\=4 \-XX\:AdaptiveSizePolicyWeight\=90 \-Dsun\.zip\.disableMemoryMapping\=true \-Xmx1G \-Xms100m \` to optimize memory usage with the parallel garbage collector + +- **`java.maven.downloadSources`**: `boolean` + + Enable\/disable download of Maven source artifacts as part of importing Maven projects\. + +- **`java.maven.updateSnapshots`**: `boolean` + + Force update of Snapshots\/Releases\. + +- **`java.maxConcurrentBuilds`**: `integer` + + Default: `1` + + Max simultaneous project builds + +- **`java.progressReports.enabled`**: `boolean` + + Default: `true` + + \[Experimental\] Enable\/disable progress reports from background processes on the server\. + +- **`java.project.importHint`**: `boolean` + + Default: `true` + + Enable\/disable the server\-mode switch information\, when Java projects import is skipped on startup\. + +- **`java.project.importOnFirstTimeStartup`**: `enum { "disabled", "interactive", "automatic" }` + + Default: `"automatic"` + + Specifies whether to import the Java projects\, when opening the folder in Hybrid mode for the first time\. + +- **`java.project.outputPath`**: `string|null` + + Default: `""` + + null + +- **`java.project.referencedLibraries`**: `array|object` + + Default: `{ "lib/**/*.jar" }` + + Configure glob patterns for referencing local libraries to a Java project\. + +- **`java.project.resourceFilters`**: `array` + + Default: `{ "node_modules", ".git" }` + + Excludes files and folders from being refreshed by the Java Language Server\, which can improve the overall performance\. For example\, \[\"node\_modules\"\,\"\.git\"\] will exclude all files and folders named \'node\_modules\' or \'\.git\'\. Defaults to \[\"node\_modules\"\,\"\.git\"\]\. + +- **`java.project.sourcePaths`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`java.quickfix.showAt`**: `enum { "line", "problem" }` + + Default: `"line"` + + Show quickfixes at the problem or line level\. + +- **`java.recommendations.dependency.analytics.show`**: `boolean` + + Default: `true` + + Show the recommended Dependency Analytics extension\. + +- **`java.references.includeAccessors`**: `boolean` + + Default: `true` + + Include getter\, setter and builder\/constructor when finding references\. + +- **`java.references.includeDecompiledSources`**: `boolean` + + Default: `true` + + Include the decompiled sources when finding references\. + +- **`java.referencesCodeLens.enabled`**: `boolean` + + Enable\/disable the references code lens\. + +- **`java.saveActions.organizeImports`**: `boolean` + + Enable\/disable auto organize imports on save action + +- **`java.selectionRange.enabled`**: `boolean` + + Default: `true` + + Enable\/disable Smart Selection support for Java\. Disabling this option will not affect the VS Code built\-in word\-based and bracket\-based smart selection\. + +- **`java.server.launchMode`**: `enum { "Standard", "LightWeight", "Hybrid" }` + + Default: `"Hybrid"` + + The launch mode for the Java extension + +- **`java.settings.url`**: `string` + + Default: `vim.NIL` + + null + +- **`java.showBuildStatusOnStart.enabled`** + + Default: `"notification"` + + Automatically show build status on startup\. + +- **`java.signatureHelp.enabled`**: `boolean` + + Enable\/disable the signature help\. + +- **`java.sources.organizeImports.starThreshold`**: `integer` + + Default: `99` + + Specifies the number of imports added before a star\-import declaration is used\. + +- **`java.sources.organizeImports.staticStarThreshold`**: `integer` + + Default: `99` + + Specifies the number of static imports added before a star\-import declaration is used\. + +- **`java.symbols.includeSourceMethodDeclarations`**: `boolean` + + null + +- **`java.templates.fileHeader`**: `array` + + Default: `{}` + + null + +- **`java.templates.typeComment`**: `array` + + Default: `{}` + + null + +- **`java.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the Java language server\. + +- **`java.typeHierarchy.lazyLoad`**: `boolean` + + Enable\/disable lazy loading the content in type hierarchy\. Lazy loading could save a lot of loading time but every type should be expanded manually to load its content\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.jdtls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "/usr/lib/jvm/adoptopenjdk-11-hotspot-amd64/bin/java", "-Declipse.application=org.eclipse.jdt.ls.core.id1", "-Dosgi.bundles.defaultStartLevel=4", "-Declipse.product=org.eclipse.jdt.ls.core.product", "-Dlog.protocol=true", "-Dlog.level=ALL", "-Xms1g", "-Xmx2G", "--add-modules=ALL-SYSTEM", "--add-opens", "java.base/java.util=ALL-UNNAMED", "--add-opens", "java.base/java.lang=ALL-UNNAMED", "-jar", "/plugins/org.eclipse.equinox.launcher_*.jar", "-configuration", "config_linux", "-data", "/home/runner/workspace" } + filetypes = { "java" } + handlers = { + ["language/status"] = , + ["textDocument/codeAction"] = , + ["textDocument/rename"] = , + ["workspace/applyEdit"] = + } + init_options = { + jvm_args = {}, + workspace = "/home/runner/workspace" + } + root_dir = { + -- Single-module projects + { + 'build.xml', -- Ant + 'pom.xml', -- Maven + 'settings.gradle', -- Gradle + 'settings.gradle.kts', -- Gradle + }, + -- Multi-module projects + { 'build.gradle', 'build.gradle.kts' }, + } or vim.fn.getcwd() + single_file_support = true +``` + + +## jedi_language_server + +https://github.com/pappasam/jedi-language-server + +`jedi-language-server`, a language server for Python, built on top of jedi + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.jedi_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "jedi-language-server" } + filetypes = { "python" } + root_dir = vim's starting directory + single_file_support = true +``` + + +## jsonls + +https://github.com/hrsh7th/vscode-langservers-extracted + +vscode-json-language-server, a language server for JSON and JSON schema + +`vscode-json-language-server` can be installed via `npm`: +```sh +npm i -g vscode-langservers-extracted +``` + +Neovim does not currently include built-in snippets. `vscode-json-language-server` only provides completions when snippet support is enabled. To enable completion, install a snippet plugin and add the following override to your language client capabilities during setup. + +```lua +--Enable (broadcasting) snippet capability for completion +local capabilities = vim.lsp.protocol.make_client_capabilities() +capabilities.textDocument.completion.completionItem.snippetSupport = true + +require'lspconfig'.jsonls.setup { + capabilities = capabilities, +} +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`json.colorDecorators.enable`**: `boolean` + + Default: `true` + + \%json\.colorDecorators\.enable\.desc\% + +- **`json.format.enable`**: `boolean` + + Default: `true` + + \%json\.format\.enable\.desc\% + +- **`json.maxItemsComputed`**: `number` + + Default: `5000` + + \%json\.maxItemsComputed\.desc\% + +- **`json.schemaDownload.enable`**: `boolean` + + Default: `true` + + \%json\.enableSchemaDownload\.desc\% + +- **`json.schemas`**: `array` + + Array items: `{default = {fileMatch = { "/myfile" },url = "schemaURL"},properties = {fileMatch = {description = "%json.schemas.fileMatch.desc%",items = {default = "MyFile.json",description = "%json.schemas.fileMatch.item.desc%",type = "string"},minItems = 1,type = "array"},schema = {["$ref"] = "http://json-schema.org/draft-07/schema#",description = "%json.schemas.schema.desc%"},url = {default = "/user.schema.json",description = "%json.schemas.url.desc%",type = "string"}},type = "object"}` + + \%json\.schemas\.desc\% + +- **`json.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + \%json\.tracing\.desc\% + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.jsonls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "vscode-json-language-server", "--stdio" } + filetypes = { "json" } + init_options = { + provideFormatter = true + } + root_dir = util.find_git_ancestor + single_file_support = true +``` + + +## jsonnet_ls + +https://github.com/jdbaldry/jsonnet-language-server + +A Language Server Protocol (LSP) server for Jsonnet. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.jsonnet_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "jsonnet-language-server" } + filetypes = { "jsonnet", "libsonnet" } + on_new_config = function(new_config, root_dir) + new_config.cmd_env = { + JSONNET_PATH = jsonnet_path(root_dir), + } + end, + root_dir = root_pattern("jsonnetfile.json") +``` + + +## julials + +https://github.com/julia-vscode/julia-vscode + +LanguageServer.jl can be installed with `julia` and `Pkg`: +```sh +julia --project=~/.julia/environments/nvim-lspconfig -e 'using Pkg; Pkg.add("LanguageServer")' +``` +where `~/.julia/environments/nvim-lspconfig` is the location where +the default configuration expects LanguageServer.jl to be installed. + +To update an existing install, use the following command: +```sh +julia --project=~/.julia/environments/nvim-lspconfig -e 'using Pkg; Pkg.update()' +``` + +Note: In order to have LanguageServer.jl pick up installed packages or dependencies in a +Julia project, you must make sure that the project is instantiated: +```sh +julia --project=/path/to/my/project -e 'using Pkg; Pkg.instantiate()' +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`julia.NumThreads`**: `integer|null` + + Default: `vim.NIL` + + Number of threads to use for Julia processes\. + +- **`julia.additionalArgs`**: `array` + + Default: `{}` + + Additional Julia arguments\. + +- **`julia.cellDelimiters`**: `array` + + Default: `{ "^##(?!#)", "^#(\\s?)%%", "^#-" }` + + Cell delimiter regular expressions for Julia files\. + +- **`julia.completionmode`**: `enum { "exportedonly", "import", "qualify" }` + + Default: `"qualify"` + + Sets the mode for completions\. + +- **`julia.debuggerDefaultCompiled`**: `array` + + Default: `{ "Base.", "-Base.!", "-Base.all", "-Base.all!", "-Base.any", "-Base.any!", "-Base.cd", "-Base.iterate", "-Base.collect", "-Base.collect_similar", "-Base._collect", "-Base.collect_to!", "-Base.collect_to_with_first!", "-Base.filter", "-Base.filter!", "-Base.foreach", "-Base.findall", "-Base.findfirst", "-Base.findlast", "-Base.findnext", "-Base.findprev", "-Base.Generator", "-Base.map", "-Base.map!", "-Base.maximum!", "-Base.minimum!", "-Base.mktemp", "-Base.mktempdir", "-Base.open", "-Base.prod!", "-Base.redirect_stderr", "-Base.redirect_stdin", "-Base.redirect_stdout", "-Base.reenable_sigint", "-Base.setindex!", "-Base.setprecision", "-Base.setrounding", "-Base.show", "-Base.sprint", "-Base.sum", "-Base.sum!", "-Base.task_local_storage", "-Base.timedwait", "-Base.withenv", "-Base.Broadcast", "Core", "Core.Compiler.", "Core.IR", "Core.Intrinsics", "DelimitedFiles", "Distributed", "LinearAlgebra.", "Serialization", "Statistics", "-Statistics.mean", "SparseArrays", "Mmap" }` + + Functions or modules that are set to compiled mode when setting the defaults\. + +- **`julia.deleteJuliaCovFiles`**: `boolean` + + Default: `"true"` + + Delete Julia \.cov files when running tests with coverage\, leaving only a \.lcov file behind\. + +- **`julia.editor`**: `string|null` + + Default: `vim.NIL` + + null + +- **`julia.enableCrashReporter`**: `boolean|null` + + Default: `vim.NIL` + + Enable crash reports to be sent to the julia VS Code extension developers\. + +- **`julia.enableTelemetry`**: `boolean|null` + + Default: `vim.NIL` + + Enable usage data and errors to be sent to the julia VS Code extension developers\. + +- **`julia.environmentPath`**: `string|null` + + Default: `vim.NIL` + + Path to a julia environment\. VS Code needs to be reloaded for changes to take effect\. + +- **`julia.executablePath`**: `string` + + Default: `""` + + Points to the julia executable\. + +- **`julia.execution.codeInREPL`**: `boolean` + + Print executed code in REPL and append it to the REPL history\. + +- **`julia.execution.inlineResults.colors`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`julia.execution.resultType`**: `enum { "REPL", "inline", "inline, errors in REPL", "both" }` + + Default: `"both"` + + Specifies how to show inline execution results + +- **`julia.focusPlotNavigator`**: `boolean` + + Whether to automatically show the plot navigator when plotting\. + +- **`julia.lint.call`**: `boolean` + + Default: `true` + + This compares call signatures against all known methods for the called function\. Calls with too many or too few arguments\, or unknown keyword parameters are highlighted\. + +- **`julia.lint.constif`**: `boolean` + + Default: `true` + + Check for constant conditionals in if statements that result in branches never being reached\.\. + +- **`julia.lint.datadecl`**: `boolean` + + Default: `true` + + Check variables used in type declarations are datatypes\. + +- **`julia.lint.disabledDirs`**: `array` + + Default: `{ "docs", "test" }` + + null + +- **`julia.lint.iter`**: `boolean` + + Default: `true` + + Check iterator syntax of loops\. Will identify\, for example\, attempts to iterate over single values\. + +- **`julia.lint.lazy`**: `boolean` + + Default: `true` + + Check for deterministic lazy boolean operators\. + +- **`julia.lint.missingrefs`**: `enum { "none", "symbols", "all" }` + + Default: `"none"` + + Highlight unknown symbols\. The \`symbols\` option will not mark unknown fields\. + +- **`julia.lint.modname`**: `boolean` + + Default: `true` + + Check submodule names do not shadow their parent\'s name\. + +- **`julia.lint.nothingcomp`**: `boolean` + + Default: `true` + + Check for use of \`\=\=\` rather than \`\=\=\=\` when comparing against \`nothing\`\. + +- **`julia.lint.pirates`**: `boolean` + + Default: `true` + + Check for type piracy \- the overloading of external functions with methods specified for external datatypes\. \'External\' here refers to imported code\. + +- **`julia.lint.run`**: `boolean` + + Default: `true` + + Run the linter on active files\. + +- **`julia.lint.typeparam`**: `boolean` + + Default: `true` + + Check parameters declared in \`where\` statements or datatype declarations are used\. + +- **`julia.lint.useoffuncargs`**: `boolean` + + Default: `true` + + Check that all declared arguments are used within the function body\. + +- **`julia.liveTestFile`**: `string` + + Default: `"test/runtests.jl"` + + A workspace relative path to a Julia file that contains the tests that should be run for live testing\. + +- **`julia.packageServer`**: `string` + + Default: `""` + + null + +- **`julia.persistentSession.enabled`**: `boolean` + + null + +- **`julia.persistentSession.shell`**: `string` + + Default: `"/bin/sh"` + + Shell used to start the persistent session\. + +- **`julia.persistentSession.shellExecutionArgument`**: `string` + + Default: `"-c"` + + null + +- **`julia.persistentSession.tmuxSessionName`**: `string` + + Default: `"julia_vscode"` + + null + +- **`julia.plots.path`**: `string` + + The output directory to save plots to + +- **`julia.runtimeCompletions`**: `boolean` + + Request runtime completions from the integrated REPL\. + +- **`julia.showRuntimeDiagnostics`**: `boolean` + + Default: `true` + + null + +- **`julia.symbolCacheDownload`**: `boolean|null` + + Default: `vim.NIL` + + Download symbol server cache files from GitHub\. + +- **`julia.symbolserverUpstream`**: `string` + + Default: `"https://www.julia-vscode.org/symbolcache"` + + Symbol server cache download URL\. + +- **`julia.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the language server\. + +- **`julia.useCustomSysimage`**: `boolean` + + Use an existing custom sysimage when starting the REPL + +- **`julia.usePlotPane`**: `boolean` + + Default: `true` + + Display plots within VS Code\. Might require a restart of the Julia process\. + +- **`julia.useProgressFrontend`**: `boolean` + + Default: `true` + + null + +- **`julia.useRevise`**: `boolean` + + Default: `true` + + Load Revise\.jl on startup of the REPL\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.julials.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "julia", "--startup-file=no", "--history-file=no", "-e", ' # Load LanguageServer.jl: attempt to load from ~/.julia/environments/nvim-lspconfig\n # with the regular load path as a fallback\n ls_install_path = joinpath(\n get(DEPOT_PATH, 1, joinpath(homedir(), ".julia")),\n "environments", "nvim-lspconfig"\n )\n pushfirst!(LOAD_PATH, ls_install_path)\n using LanguageServer\n popfirst!(LOAD_PATH)\n depot_path = get(ENV, "JULIA_DEPOT_PATH", "")\n project_path = let\n dirname(something(\n ## 1. Finds an explicitly set project (JULIA_PROJECT)\n Base.load_path_expand((\n p = get(ENV, "JULIA_PROJECT", nothing);\n p === nothing ? nothing : isempty(p) ? nothing : p\n )),\n ## 2. Look for a Project.toml file in the current working directory,\n ## or parent directories, with $HOME as an upper boundary\n Base.current_project(),\n ## 3. First entry in the load path\n get(Base.load_path(), 1, nothing),\n ## 4. Fallback to default global environment,\n ## this is more or less unreachable\n Base.load_path_expand("@v#.#"),\n ))\n end\n @info "Running language server" VERSION pwd() project_path depot_path\n server = LanguageServer.LanguageServerInstance(stdin, stdout, project_path, depot_path)\n server.runlinter = true\n run(server)\n ' } + filetypes = { "julia" } + root_dir = function(fname) + return util.root_pattern 'Project.toml'(fname) or util.find_git_ancestor(fname) + end, + single_file_support = true +``` + + +## kotlin_language_server + + A kotlin language server which was developed for internal usage and + released afterwards. Maintaining is not done by the original author, + but by fwcd. + + It is built via gradle and developed on github. + Source and additional description: + https://github.com/fwcd/kotlin-language-server + + This server requires vim to be aware of the kotlin-filetype. + You could refer for this capability to: + https://github.com/udalov/kotlin-vim (recommended) + Note that there is no LICENSE specified yet. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`kotlin.compiler.jvm.target`**: `string` + + Default: `"default"` + + Specifies the JVM target\, e\.g\. \"1\.6\" or \"1\.8\" + +- **`kotlin.completion.snippets.enabled`**: `boolean` + + Default: `true` + + Specifies whether code completion should provide snippets \(true\) or plain\-text items \(false\)\. + +- **`kotlin.debounceTime`**: `integer` + + Default: `250` + + \[DEPRECATED\] Specifies the debounce time limit\. Lower to increase responsiveness at the cost of possible stability issues\. + +- **`kotlin.debugAdapter.enabled`**: `boolean` + + Default: `true` + + \[Recommended\] Specifies whether the debug adapter should be used\. When enabled a debugger for Kotlin will be available\. + +- **`kotlin.debugAdapter.path`**: `string` + + Default: `""` + + Optionally a custom path to the debug adapter executable\. + +- **`kotlin.externalSources.autoConvertToKotlin`**: `boolean` + + Default: `true` + + Specifies whether decompiled\/external classes should be auto\-converted to Kotlin\. + +- **`kotlin.externalSources.useKlsScheme`**: `boolean` + + Default: `true` + + \[Recommended\] Specifies whether URIs inside JARs should be represented using the \'kls\'\-scheme\. + +- **`kotlin.indexing.enabled`**: `boolean` + + Default: `true` + + Whether global symbols in the project should be indexed automatically in the background\. This enables e\.g\. code completion for unimported classes and functions\. + +- **`kotlin.languageServer.debugAttach.autoSuspend`**: `boolean` + + \[DEBUG\] If enabled \(together with debugAttach\.enabled\)\, the language server will not immediately launch but instead listen on the specified attach port and wait for a debugger\. This is ONLY useful if you need to debug the language server ITSELF\. + +- **`kotlin.languageServer.debugAttach.enabled`**: `boolean` + + \[DEBUG\] Whether the language server should listen for debuggers\, i\.e\. be debuggable while running in VSCode\. This is ONLY useful if you need to debug the language server ITSELF\. + +- **`kotlin.languageServer.debugAttach.port`**: `integer` + + Default: `5005` + + \[DEBUG\] If transport is stdio this enables you to attach to the running language server with a debugger\. This is ONLY useful if you need to debug the language server ITSELF\. + +- **`kotlin.languageServer.enabled`**: `boolean` + + Default: `true` + + \[Recommended\] Specifies whether the language server should be used\. When enabled the extension will provide code completions and linting\, otherwise just syntax highlighting\. Might require a reload to apply\. + +- **`kotlin.languageServer.path`**: `string` + + Default: `""` + + Optionally a custom path to the language server executable\. + +- **`kotlin.languageServer.port`**: `integer` + + Default: `0` + + The port to which the client will attempt to connect to\. A random port is used if zero\. Only used if the transport layer is TCP\. + +- **`kotlin.languageServer.transport`**: `enum { "stdio", "tcp" }` + + Default: `"stdio"` + + The transport layer beneath the language server protocol\. Note that the extension will launch the server even if a TCP socket is used\. + +- **`kotlin.linting.debounceTime`**: `integer` + + Default: `250` + + \[DEBUG\] Specifies the debounce time limit\. Lower to increase responsiveness at the cost of possible stability issues\. + +- **`kotlin.snippetsEnabled`**: `boolean` + + Default: `true` + + \[DEPRECATED\] Specifies whether code completion should provide snippets \(true\) or plain\-text items \(false\)\. + +- **`kotlin.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VSCode and the Kotlin language server\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.kotlin_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "kotlin-language-server" } + filetypes = { "kotlin" } + root_dir = root_pattern("settings.gradle") +``` + + +## lean3ls + +https://github.com/leanprover/lean-client-js/tree/master/lean-language-server + +Lean installation instructions can be found +[here](https://leanprover-community.github.io/get_started.html#regular-install). + +Once Lean is installed, you can install the Lean 3 language server by running +```sh +npm install -g lean-language-server +``` + +Note: that if you're using [lean.nvim](https://github.com/Julian/lean.nvim), +that plugin fully handles the setup of the Lean language server, +and you shouldn't set up `lean3ls` both with it and `lspconfig`. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.lean3ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "lean-language-server", "--stdio", "--", "-M", "4096", "-T", "100000" } + filetypes = { "lean3" } + offset_encoding = "utf-32" + root_dir = root_pattern("leanpkg.toml") or root_pattern(".git") or path.dirname + single_file_support = true +``` + + +## leanls + +https://github.com/leanprover/lean4 + +Lean installation instructions can be found +[here](https://leanprover-community.github.io/get_started.html#regular-install). + +The Lean 4 language server is built-in with a Lean 4 install +(and can be manually run with, e.g., `lean --server`). + +Note: that if you're using [lean.nvim](https://github.com/Julian/lean.nvim), +that plugin fully handles the setup of the Lean language server, +and you shouldn't set up `leanls` both with it and `lspconfig`. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.leanls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "lean", "--server" } + filetypes = { "lean" } + on_new_config = function(config, root_dir) + -- add root dir as command-line argument for `ps aux` + table.insert(config.cmd, root_dir) + end, + root_dir = root_pattern("lakefile.lean", "lean-toolchain", "leanpkg.toml", ".git") + single_file_support = true +``` + + +## lelwel_ls + +https://github.com/0x2a-42/lelwel + +Language server for lelwel grammars. + +You can install `lelwel-ls` via cargo: +```sh +cargo install --features="lsp" lelwel +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.lelwel_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "lelwel-ls" } + filetypes = { "llw" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end +``` + + +## lemminx + +https://github.com/eclipse/lemminx + +The easiest way to install the server is to get a binary at https://download.jboss.org/jbosstools/vscode/stable/lemminx-binary/ and place it in your PATH. + +NOTE to macOS users: Binaries from unidentified developers are blocked by default. If you trust the downloaded binary from jboss.org, run it once, cancel the prompt, then remove the binary from Gatekeeper quarantine with `xattr -d com.apple.quarantine lemminx`. It should now run without being blocked. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.lemminx.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "lemminx" } + filetypes = { "xml", "xsd", "svg" } + root_dir = util.find_git_ancestor + single_file_support = true +``` + + +## ltex + +https://github.com/valentjn/ltex-ls + +LTeX Language Server: LSP language server for LanguageTool 🔍✔️ with support for LaTeX 🎓, Markdown 📝, and others + +To install, download the latest [release](https://github.com/valentjn/ltex-ls/releases) and ensure `ltex-ls` is on your path. + +To support org files or R sweave, users can define a custom filetype autocommand (or use a plugin which defines these filetypes): + +```lua +vim.cmd [[ autocmd BufRead,BufNewFile *.org set filetype=org ]] +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`ltex.additionalRules.enablePickyRules`**: `boolean` + + null + +- **`ltex.additionalRules.languageModel`**: `string` + + Default: `""` + + null + +- **`ltex.additionalRules.motherTongue`**: `enum { "", "ar", "ast-ES", "be-BY", "br-FR", "ca-ES", "ca-ES-valencia", "da-DK", "de", "de-AT", "de-CH", "de-DE", "de-DE-x-simple-language", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-NZ", "en-US", "en-ZA", "eo", "es", "es-AR", "fa", "fr", "ga-IE", "gl-ES", "it", "ja-JP", "km-KH", "nl", "nl-BE", "pl-PL", "pt", "pt-AO", "pt-BR", "pt-MZ", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv", "ta-IN", "tl-PH", "uk-UA", "zh-CN" }` + + Default: `""` + + null + +- **`ltex.additionalRules.neuralNetworkModel`**: `string` + + Default: `""` + + null + +- **`ltex.additionalRules.word2VecModel`**: `string` + + Default: `""` + + null + +- **`ltex.bibtex.fields`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.checkFrequency`**: `enum { "edit", "save", "manual" }` + + Default: `"edit"` + + null + +- **`ltex.clearDiagnosticsWhenClosingFile`**: `boolean` + + Default: `true` + + null + +- **`ltex.completionEnabled`**: `boolean` + + null + +- **`ltex.configurationTarget`**: `object` + + Default: `{dictionary = "workspaceFolderExternalFile",disabledRules = "workspaceFolderExternalFile",hiddenFalsePositives = "workspaceFolderExternalFile"}` + + null + +- **`ltex.diagnosticSeverity`** + + Default: `"information"` + + null + +- **`ltex.dictionary`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.disabledRules`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.enabled`** + + Default: `{ "bibtex", "context", "context.tex", "html", "latex", "markdown", "org", "restructuredtext", "rsweave" }` + + null + +- **`ltex.enabledRules`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.hiddenFalsePositives`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.java.initialHeapSize`**: `integer` + + Default: `64` + + null + +- **`ltex.java.maximumHeapSize`**: `integer` + + Default: `512` + + null + +- **`ltex.java.path`**: `string` + + Default: `""` + + null + +- **`ltex.language`**: `enum { "auto", "ar", "ast-ES", "be-BY", "br-FR", "ca-ES", "ca-ES-valencia", "da-DK", "de", "de-AT", "de-CH", "de-DE", "de-DE-x-simple-language", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-NZ", "en-US", "en-ZA", "eo", "es", "es-AR", "fa", "fr", "ga-IE", "gl-ES", "it", "ja-JP", "km-KH", "nl", "nl-BE", "pl-PL", "pt", "pt-AO", "pt-BR", "pt-MZ", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv", "ta-IN", "tl-PH", "uk-UA", "zh-CN" }` + + Default: `"en-US"` + + null + +- **`ltex.languageToolHttpServerUri`**: `string` + + Default: `""` + + null + +- **`ltex.languageToolOrg.apiKey`**: `string` + + Default: `""` + + null + +- **`ltex.languageToolOrg.username`**: `string` + + Default: `""` + + null + +- **`ltex.latex.commands`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.latex.environments`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.ltex-ls.languageToolHttpServerUri`**: `string` + + Default: `""` + + null + +- **`ltex.ltex-ls.languageToolOrgApiKey`**: `string` + + Default: `""` + + null + +- **`ltex.ltex-ls.languageToolOrgUsername`**: `string` + + Default: `""` + + null + +- **`ltex.ltex-ls.logLevel`**: `enum { "severe", "warning", "info", "config", "fine", "finer", "finest" }` + + Default: `"fine"` + + null + +- **`ltex.ltex-ls.path`**: `string` + + Default: `""` + + null + +- **`ltex.markdown.nodes`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`ltex.sentenceCacheSize`**: `integer` + + Default: `2000` + + null + +- **`ltex.statusBarItem`**: `boolean` + + null + +- **`ltex.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + null + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ltex.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ltex-ls" } + filetypes = { "bib", "gitcommit", "markdown", "org", "plaintex", "rst", "rnoweb", "tex" } + get_language_id = function(_, filetype) + local language_id = language_id_mapping[filetype] + if language_id then + return language_id + else + return filetype + end + end, + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end + single_file_support = true +``` + + +## metals + +https://scalameta.org/metals/ + +Scala language server with rich IDE features. + +See full instructions in the Metals documentation: + +https://scalameta.org/metals/docs/editors/vim.html#using-an-alternative-lsp-client + +Note: that if you're using [nvim-metals](https://github.com/scalameta/nvim-metals), that plugin fully handles the setup and installation of Metals, and you shouldn't set up Metals both with it and `lspconfig`. + +To install Metals, make sure to have [coursier](https://get-coursier.io/docs/cli-installation) installed, and once you do you can install the latest Metals with `cs install metals`. You can also manually bootstrap Metals with the following command. + +```bash +cs bootstrap \ + --java-opt -Xss4m \ + --java-opt -Xms100m \ + org.scalameta:metals_2.12: \ + -r bintray:scalacenter/releases \ + -r sonatype:snapshots \ + -o /usr/local/bin/metals -f +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.metals.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "metals" } + filetypes = { "scala" } + init_options = { + compilerOptions = { + snippetAutoIndent = false + }, + isHttpEnabled = true, + statusBarProvider = "show-message" + } + message_level = 4 + root_dir = util.root_pattern("build.sbt", "build.sc", "build.gradle", "pom.xml") +``` + + +## mint + +https://www.mint-lang.com + +Install Mint using the [instructions](https://www.mint-lang.com/install). +The language server is included since version 0.12.0. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.mint.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "mint", "ls" } + filetypes = { "mint" } + root_dir = function(fname) + return util.root_pattern 'mint.json'(fname) or util.find_git_ancestor(fname) + end, + single_file_support = true +``` + + +## nickel_ls + +Nickel Language Server + +https://github.com/tweag/nickel + +`nls` can be installed with nix, or cargo, from the Nickel repository. +```sh +git clone https://github.com/tweag/nickel.git +``` + +Nix: +```sh +cd nickel +nix-env -f . -i +``` + +cargo: +```sh +cd nickel/lsp/nls +cargo install --path . +``` + +In order to have lspconfig detect Nickel filetypes (a prequisite for autostarting a server), +install the [Nickel vim plugin](https://github.com/nickel-lang/vim-nickel). + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.nickel_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "nls" } + filetypes = { "ncl", "nickel" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end +``` + + +## nimls + +https://github.com/PMunch/nimlsp +`nimlsp` can be installed via the `nimble` package manager: +```sh +nimble install nimlsp +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.nimls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "nimlsp" } + filetypes = { "nim" } + root_dir = function(fname) + return util.root_pattern '*.nimble'(fname) or util.find_git_ancestor(fname) + end, + single_file_support = true +``` + + +## ocamlls + +https://github.com/ocaml-lsp/ocaml-language-server + +`ocaml-language-server` can be installed via `npm` +```sh +npm install -g ocaml-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ocamlls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ocaml-language-server", "--stdio" } + filetypes = { "ocaml", "reason" } + root_dir = root_pattern("*.opam", "esy.json", "package.json") +``` + + +## ocamllsp + +https://github.com/ocaml/ocaml-lsp + +`ocaml-lsp` can be installed as described in [installation guide](https://github.com/ocaml/ocaml-lsp#installation). + +To install the lsp server in a particular opam switch: +```sh +opam pin add ocaml-lsp-server https://github.com/ocaml/ocaml-lsp.git +opam install ocaml-lsp-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.ocamllsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "ocamllsp" } + filetypes = { "ocaml", "ocaml.menhir", "ocaml.interface", "ocaml.ocamllex", "reason" } + get_language_id = function(_, ftype) + return language_id_of[ftype] + end + root_dir = root_pattern("*.opam", "esy.json", "package.json", ".git") +``` + + +## omnisharp + +https://github.com/omnisharp/omnisharp-roslyn +OmniSharp server based on Roslyn workspaces + +`omnisharp-roslyn` can be installed by downloading and extracting a release from [here](https://github.com/OmniSharp/omnisharp-roslyn/releases). +Omnisharp can also be built from source by following the instructions [here](https://github.com/omnisharp/omnisharp-roslyn#downloading-omnisharp). + +Omnisharp requires the [dotnet-sdk](https://dotnet.microsoft.com/download) to be installed. + +**By default, omnisharp-roslyn doesn't have a `cmd` set.** This is because nvim-lspconfig does not make assumptions about your path. You must add the following to your init.vim or init.lua to set `cmd` to the absolute path ($HOME and ~ are not expanded) of the unzipped run script or binary. + +```lua +local pid = vim.fn.getpid() +-- On linux/darwin if using a release build, otherwise under scripts/OmniSharp(.Core)(.cmd) +local omnisharp_bin = "/path/to/omnisharp-repo/run" +-- on Windows +-- local omnisharp_bin = "/path/to/omnisharp/OmniSharp.exe" +require'lspconfig'.omnisharp.setup{ + cmd = { omnisharp_bin, "--languageserver" , "--hostPID", tostring(pid) }; + ... +} +``` + +Note, if you download the executable for darwin you will need to strip the quarantine label to run: +```bash +find /path/to/omnisharp-osx | xargs xattr -r -d com.apple.quarantine +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.omnisharp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "cs", "vb" } + init_options = {} + on_new_config = function(new_config, new_root_dir) + if new_root_dir then + table.insert(new_config.cmd, '-s') + table.insert(new_config.cmd, new_root_dir) + end + end, + root_dir = root_pattern(".sln") or root_pattern(".csproj") +``` + + +## pasls + +https://github.com/genericptr/pascal-language-server + +An LSP server implementation for Pascal variants that are supported by Free Pascal, including Object Pascal. It uses CodeTools from Lazarus as backend. + +First set `cmd` to the Pascal lsp binary. + +Customization options are passed to pasls as environment variables for example in your `.bashrc`: +```bash +export FPCDIR='/usr/lib/fpc/src' # FPC source directory (This is the only required option for the server to work). +export PP='/usr/lib/fpc/3.2.2/ppcx64' # Path to the Free Pascal compiler executable. +export LAZARUSDIR='/usr/lib/lazarus' # Path to the Lazarus sources. +export FPCTARGET='' # Target operating system for cross compiling. +export FPCTARGETCPU='x86_64' # Target CPU for cross compiling. +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.pasls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "pasls" } + filetypes = { "pascal" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end + single_file_support = true +``` + + +## perlls + +https://github.com/richterger/Perl-LanguageServer/tree/master/clients/vscode/perl + +`Perl-LanguageServer`, a language server for Perl. + +To use the language server, ensure that you have Perl::LanguageServer installed and perl command is on your path. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`perl.cacheDir`**: `string` + + Default: `vim.NIL` + + directory for caching of parsed symbols\, if the directory does not exists\, it will be created\, defaults to \$\{workspace\}\/\.vscode\/perl\-lang\. This should be one unqiue directory per project and an absolute path\. + +- **`perl.debugAdapterPort`**: `string` + + Default: `"13603"` + + port to use for connection between vscode and debug adapter inside Perl\:\:LanguageServer\. On a multi user system every user must use a different port\. + +- **`perl.disableCache`**: `boolean` + + if true\, the LanguageServer will not cache the result of parsing source files on disk\, so it can be used within readonly directories + +- **`perl.enable`**: `boolean` + + Default: `true` + + enable\/disable this extension + +- **`perl.fileFilter`**: `array` + + Default: `vim.NIL` + + array for filtering perl file\, defaults to \*\.pm|\*\.pl + +- **`perl.ignoreDirs`**: `array` + + Default: `vim.NIL` + + directories to ignore\, defaults to \.vscode\, \.git\, \.svn + +- **`perl.logFile`**: `string` + + Default: `vim.NIL` + + If set\, log output is written to the given logfile\, instead of displaying it in the vscode output pane\. Log output is always appended so you are responsible for rotating the file\. + +- **`perl.logLevel`**: `integer` + + Default: `0` + + Log level 0\-2 + +- **`perl.pathMap`**: `array` + + Default: `vim.NIL` + + mapping of local to remote paths + +- **`perl.perlCmd`**: `string` + + Default: `vim.NIL` + + defaults to perl + +- **`perl.perlInc`**: `array` + + Default: `vim.NIL` + + array with paths to add to perl library path\. This setting is used by the syntax checker and for the debuggee and also for the LanguageServer itself\. perl\.perlInc should be absolute paths\. + +- **`perl.showLocalVars`**: `boolean` + + if true\, show also local variables in symbol view + +- **`perl.sshAddr`**: `string` + + Default: `vim.NIL` + + ip address of remote system + +- **`perl.sshArgs`**: `array` + + Default: `vim.NIL` + + optional arguments for ssh + +- **`perl.sshCmd`**: `string` + + Default: `vim.NIL` + + defaults to ssh on unix and plink on windows + +- **`perl.sshPort`**: `string` + + Default: `vim.NIL` + + optional\, port for ssh to remote system + +- **`perl.sshUser`**: `string` + + Default: `vim.NIL` + + user for ssh login + +- **`perl.sshWorkspaceRoot`**: `string` + + Default: `vim.NIL` + + path of the workspace root on remote system + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.perlls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "perl", "-MPerl::LanguageServer", "-e", "Perl::LanguageServer::run", "--", "--port 13603", "--nostdio 0", "--version 2.1.0" } + filetypes = { "perl" } + root_dir = vim's starting directory + settings = { + perl = { + fileFilter = { ".pm", ".pl" }, + ignoreDirs = ".git", + perlCmd = "perl", + perlInc = " " + } + } + single_file_support = true +``` + + +## perlpls + +https://github.com/FractalBoy/perl-language-server +https://metacpan.org/pod/PLS + +`PLS`, another language server for Perl. + +To use the language server, ensure that you have PLS installed and that it is in your path + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`perl.cwd`**: `string` + + Default: `"."` + + Current working directory to use + +- **`perl.inc`**: `array` + + Default: `{}` + + Paths to add to \@INC\. + +- **`perl.perlcritic.enabled`**: `boolean` + + Default: `true` + + Enable perlcritic + +- **`perl.perlcritic.perlcriticrc`**: `string` + + Default: `"~/.perlcriticrc"` + + Path to \.perlcriticrc + +- **`perl.perltidyrc`**: `string` + + Default: `"~/.perltidyrc"` + + Path to \.perltidyrc + +- **`perl.pls`**: `string` + + Default: `"pls"` + + Path to the pls executable script + +- **`perl.plsargs`**: `array` + + Default: `{}` + + Arguments to pass to the pls command + +- **`perl.syntax.enabled`**: `boolean` + + Default: `true` + + Enable syntax checking + +- **`perl.syntax.perl`**: `string` + + Default: `""` + + Path to the perl binary to use for syntax checking + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.perlpls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "pls" } + filetypes = { "perl" } + root_dir = util.find_git_ancestor + settings = { + perl = { + perlcritic = { + enabled = false + } + } + } + single_file_support = true +``` + + +## phpactor + +https://github.com/phpactor/phpactor + +Installation: https://phpactor.readthedocs.io/en/master/usage/standalone.html#global-installation + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.phpactor.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "phpactor", "language-server" } + filetypes = { "php" } + root_dir = root_pattern("composer.json", ".git") +``` + + +## powershell_es + +https://github.com/PowerShell/PowerShellEditorServices + +Language server for PowerShell. + +To install, download and extract PowerShellEditorServices.zip +from the [releases](https://github.com/PowerShell/PowerShellEditorServices/releases). +To configure the language server, set the property `bundle_path` to the root +of the extracted PowerShellEditorServices.zip. + +The default configuration doesn't set `cmd` unless `bundle_path` is specified. + +```lua +require'lspconfig'.powershell_es.setup{ + bundle_path = 'c:/w/PowerShellEditorServices', +} +``` + +By default the languageserver is started in `pwsh` (PowerShell Core). This can be changed by specifying `shell`. + +```lua +require'lspconfig'.powershell_es.setup{ + bundle_path = 'c:/w/PowerShellEditorServices', + shell = 'powershell.exe', +} +``` + +Note that the execution policy needs to be set to `Unrestricted` for the languageserver run under PowerShell + +If necessary, specific `cmd` can be defined instead of `bundle_path`. +See [PowerShellEditorServices](https://github.com/PowerShell/PowerShellEditorServices#stdio) +to learn more. + +```lua +require'lspconfig'.powershell_es.setup{ + cmd = {'pwsh', '-NoLogo', '-NoProfile', '-Command', "c:/PSES/Start-EditorServices.ps1 ..."} +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.powershell_es.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "ps1" } + on_new_config = function(new_config, _) + -- Don't overwrite cmd if already set + if not new_config.cmd then + new_config.cmd = make_cmd(new_config) + end + end, + root_dir = git root or current directory + shell = "pwsh" + single_file_support = true +``` + + +## prismals + +npm install -g @prisma/language-server + +'prismals, a language server for the prisma javascript and typescript orm' + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.prismals.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "prisma-language-server", "--stdio" } + filetypes = { "prisma" } + root_dir = root_pattern(".git", "package.json") + settings = { + prisma = { + prismaFmtBinPath = "" + } + } +``` + + +## psalm + +https://github.com/vimeo/psalm + +Can be installed with composer. +```sh +composer global require vimeo/psalm +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.psalm.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "psalm-language-server" } + filetypes = { "php" } + root_dir = root_pattern("psalm.xml", "psalm.xml.dist") +``` + + +## puppet + +LSP server for Puppet. + +Installation: + +- Clone the editor-services repository: + https://github.com/puppetlabs/puppet-editor-services + +- Navigate into that directory and run: `bundle install` + +- Install the 'puppet-lint' gem: `gem install puppet-lint` + +- Add that repository to $PATH. + +- Ensure you can run `puppet-languageserver` from outside the editor-services directory. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`puppet.editorService.debugFilePath`**: `string` + + Default: `""` + + The absolute filepath where the Puppet Editor Service will output the debugging log\. By default no logfile is generated + +- **`puppet.editorService.enable`**: `boolean` + + Default: `true` + + Enable\/disable advanced Puppet Language Features + +- **`puppet.editorService.featureFlags`**: `array` + + Default: `{}` + + An array of strings of experimental features to enable in the Puppet Editor Service + +- **`puppet.editorService.foldingRange.enable`**: `boolean` + + Default: `true` + + Enable\/disable syntax aware code folding provider + +- **`puppet.editorService.foldingRange.showLastLine`**: `boolean` + + Show or hide the last line in code folding regions + +- **`puppet.editorService.formatOnType.enable`**: `boolean` + + Enable\/disable the Puppet document on\-type formatter\, for example hashrocket alignment + +- **`puppet.editorService.formatOnType.maxFileSize`**: `integer` + + Default: `4096` + + Sets the maximum file size \(in Bytes\) that document on\-type formatting will occur\. Setting this to zero \(0\) will disable the file size check\. Note that large file sizes can cause performance issues\. + +- **`puppet.editorService.hover.showMetadataInfo`**: `boolean` + + Default: `true` + + Enable or disable showing Puppet Module version information in the metadata\.json file + +- **`puppet.editorService.loglevel`**: `enum { "debug", "error", "normal", "warning", "verbose" }` + + Default: `"normal"` + + Set the logging verbosity level for the Puppet Editor Service\, with Debug producing the most output and Error producing the least + +- **`puppet.editorService.protocol`**: `enum { "stdio", "tcp" }` + + Default: `"stdio"` + + The protocol used to communicate with the Puppet Editor Service\. By default the local STDIO protocol is used\. + +- **`puppet.editorService.puppet.confdir`**: `string` + + Default: `""` + + The Puppet configuration directory\. See https\:\/\/puppet\.com\/docs\/puppet\/latest\/dirs\_confdir\.html for more information + +- **`puppet.editorService.puppet.environment`**: `string` + + Default: `""` + + The Puppet environment to use\. See https\:\/\/puppet\.com\/docs\/puppet\/latest\/config\_print\.html\#environments for more information + +- **`puppet.editorService.puppet.modulePath`**: `string` + + Default: `""` + + Additional module paths to use when starting the Editor Services\. On Windows this is delimited with a semicolon\, and on all other platforms\, with a colon\. For example C\:\\Path1\;C\:\\Path2 + +- **`puppet.editorService.puppet.vardir`**: `string` + + Default: `""` + + The Puppet cache directory\. See https\:\/\/puppet\.com\/docs\/puppet\/latest\/dirs\_vardir\.html for more information + +- **`puppet.editorService.puppet.version`**: `string` + + Default: `""` + + The version of Puppet to use\. For example \'5\.4\.0\'\. This is generally only applicable when using the PDK installation type\. If Puppet Editor Services is unable to use this version\, it will default to the latest available version of Puppet\. + +- **`puppet.editorService.tcp.address`**: `string` + + The IP address or hostname of the remote Puppet Editor Service to connect to\, for example \'computer\.domain\' or \'192\.168\.0\.1\'\. Only applicable when the editorService\.protocol is set to tcp + +- **`puppet.editorService.tcp.port`**: `integer` + + The TCP Port of the remote Puppet Editor Service to connect to\. Only applicable when the editorService\.protocol is set to tcp + +- **`puppet.editorService.timeout`**: `integer` + + Default: `10` + + The timeout to connect to the Puppet Editor Service + +- **`puppet.format.enable`**: `boolean` + + Default: `true` + + Enable\/disable the Puppet document formatter + +- **`puppet.installDirectory`**: `string` + + null + +- **`puppet.installType`**: `enum { "auto", "pdk", "agent" }` + + Default: `"auto"` + + null + +- **`puppet.notification.nodeGraph`**: `enum { "messagebox", "statusbar", "none" }` + + Default: `"messagebox"` + + The type of notification used when a node graph is being generated\. Default value of messagebox + +- **`puppet.notification.puppetResource`**: `enum { "messagebox", "statusbar", "none" }` + + Default: `"messagebox"` + + The type of notification used when a running Puppet Resouce\. Default value of messagebox + +- **`puppet.pdk.checkVersion`**: `boolean` + + Default: `true` + + Enable\/disable checking if installed PDK version is latest + +- **`puppet.titleBar.pdkNewModule.enable`**: `boolean` + + Default: `true` + + Enable\/disable the PDK New Module icon in the Editor Title Bar + +- **`puppet.validate.resolvePuppetfiles`**: `boolean` + + Default: `true` + + Enable\/disable using dependency resolution for Puppetfiles + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.puppet.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "puppet-languageserver", "--stdio" } + filetypes = { "puppet" } + root_dir = root_pattern("manifests", ".puppet-lint.rc", "hiera.yaml", ".git") + single_file_support = true +``` + + +## purescriptls + +https://github.com/nwolverson/purescript-language-server +`purescript-language-server` can be installed via `npm` +```sh +npm install -g purescript-language-server +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`purescript.addNpmPath`**: `boolean` + + Whether to add the local npm bin directory to the PATH for purs IDE server and build command\. + +- **`purescript.addPscPackageSources`**: `boolean` + + Whether to add psc\-package sources to the globs passed to the IDE server for source locations \(specifically the output of \`psc\-package sources\`\, if this is a psc\-package project\)\. Update due to adding packages\/changing package set requires psc\-ide server restart\. + +- **`purescript.addSpagoSources`**: `boolean` + + Default: `true` + + Whether to add spago sources to the globs passed to the IDE server for source locations \(specifically the output of \`spago sources\`\, if this is a spago project\)\. Update due to adding packages\/changing package set requires psc\-ide server restart\. + +- **`purescript.autoStartPscIde`**: `boolean` + + Default: `true` + + Whether to automatically start\/connect to purs IDE server when editing a PureScript file \(includes connecting to an existing running instance\)\. If this is disabled\, various features like autocomplete\, tooltips\, and other type info will not work until start command is run manually\. + +- **`purescript.autocompleteAddImport`**: `boolean` + + Default: `true` + + Whether to automatically add imported identifiers when accepting autocomplete result\. + +- **`purescript.autocompleteAllModules`**: `boolean` + + Default: `true` + + Whether to always autocomplete from all built modules\, or just those imported in the file\. Suggestions from all modules always available by explicitly triggering autocomplete\. + +- **`purescript.autocompleteGrouped`**: `boolean` + + Default: `true` + + Whether to group completions in autocomplete results\. Requires compiler 0\.11\.6 + +- **`purescript.autocompleteLimit`**: `null|integer` + + Default: `vim.NIL` + + Maximum number of results to fetch for an autocompletion request\. May improve performance on large projects\. + +- **`purescript.buildCommand`**: `string` + + Default: `"spago build --purs-args --json-errors"` + + Build command to use with arguments\. Not passed to shell\. eg \`spago build \-\-purs\-args \-\-json\-errors\` + +- **`purescript.buildOpenedFiles`**: `boolean` + + null + +- **`purescript.censorWarnings`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + The warning codes to censor\, both for fast rebuild and a full build\. Unrelated to any psa setup\. e\.g\.\: \[\"ShadowedName\"\,\"MissingTypeDeclaration\"\] + +- **`purescript.codegenTargets`**: `array` + + Default: `vim.NIL` + + Array items: `{type = "string"}` + + List of codegen targets to pass to the compiler for rebuild\. e\.g\. js\, corefn\. If not specified \(rather than empty array\) this will not be passed and the compiler will default to js\. Requires 0\.12\.1+ + +- **`purescript.declarationTypeCodeLens`**: `boolean` + + Default: `true` + + Enable declaration codelens to add types to declarations + +- **`purescript.exportsCodeLens`**: `boolean` + + Default: `true` + + Enable declaration codelenses for export management + +- **`purescript.fastRebuild`**: `boolean` + + Default: `true` + + Enable purs IDE server fast rebuild + +- **`purescript.formatter`**: `enum { "none", "purty", "purs-tidy", "pose" }` + + Default: `"purty"` + + Tool to use to for formatting\. Must be installed and on PATH \(or npm installed with addNpmPath set\) + +- **`purescript.fullBuildOnSave`**: `boolean` + + Whether to perform a full build on save with the configured build command \(rather than IDE server fast rebuild\)\. This is not generally recommended because it is slow\, but it does mean that dependent modules are rebuilt as necessary\. + +- **`purescript.importsPreferredModules`**: `array` + + Default: `{ "Prelude" }` + + Array items: `{type = "string"}` + + Module to prefer to insert when adding imports which have been re\-exported\. In order of preference\, most preferred first\. + +- **`purescript.outputDirectory`**: `string` + + Default: `"output/"` + + Override purs ide output directory \(output\/ if not specified\)\. This should match up to your build command + +- **`purescript.packagePath`**: `string` + + Default: `""` + + Path to installed packages\. Will be used to control globs passed to IDE server for source locations\. Change requires IDE server restart\. + +- **`purescript.preludeModule`**: `string` + + Default: `"Prelude"` + + Module to consider as your default prelude\, if an auto\-complete suggestion comes from this module it will be imported unqualified\. + +- **`purescript.pscIdePort`**: `integer|null` + + Default: `vim.NIL` + + Port to use for purs IDE server \(whether an existing server or to start a new one\)\. By default a random port is chosen \(or an existing port in \.psc\-ide\-port if present\)\, if this is specified no attempt will be made to select an alternative port on failure\. + +- **`purescript.pscIdelogLevel`**: `string` + + Default: `""` + + Log level for purs IDE server + +- **`purescript.pursExe`**: `string` + + Default: `"purs"` + + Location of purs executable \(resolved wrt PATH\) + +- **`purescript.sourcePath`**: `string` + + Default: `"src"` + + Path to application source root\. Will be used to control globs passed to IDE server for source locations\. Change requires IDE server restart\. + +- **`purescript.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VSCode and the PureScript language service\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.purescriptls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "purescript-language-server", "--stdio" } + filetypes = { "purescript" } + root_dir = root_pattern("spago.dhall, 'psc-package.json', bower.json") +``` + + +## pylsp + +https://github.com/python-lsp/python-lsp-server + +A Python 3.6+ implementation of the Language Server Protocol. + +The language server can be installed via `pipx install 'python-lsp-server[all]'`. +Further instructions can be found in the [project's README](https://github.com/python-lsp/python-lsp-server). + +Note: This is a community fork of `pyls`. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.pylsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "pylsp" } + filetypes = { "python" } + root_dir = function(fname) + local root_files = { + 'pyproject.toml', + 'setup.py', + 'setup.cfg', + 'requirements.txt', + 'Pipfile', + } + return util.root_pattern(unpack(root_files))(fname) or util.find_git_ancestor(fname) + end, + single_file_support = true +``` + + +## pyre + +https://pyre-check.org/ + +`pyre` a static type checker for Python 3. + +`pyre` offers an extremely limited featureset. It currently only supports diagnostics, +which are triggered on save. + +Do not report issues for missing features in `pyre` to `lspconfig`. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.pyre.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "pyre", "persistent" } + filetypes = { "python" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## pyright + +https://github.com/microsoft/pyright + +`pyright`, a static type checker and language server for python + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`pyright.disableLanguageServices`**: `boolean` + + Disables type completion\, definitions\, and references\. + +- **`pyright.disableOrganizeImports`**: `boolean` + + Disables the “Organize Imports” command\. + +- **`python.analysis.autoImportCompletions`**: `boolean` + + Default: `true` + + Offer auto\-import completions\. + +- **`python.analysis.autoSearchPaths`**: `boolean` + + Default: `true` + + Automatically add common search paths like \'src\'\? + +- **`python.analysis.diagnosticMode`**: `enum { "openFilesOnly", "workspace" }` + + Default: `"openFilesOnly"` + + null + +- **`python.analysis.diagnosticSeverityOverrides`**: `object` + + Default: `vim.empty_dict()` + + Allows a user to override the severity levels for individual diagnostics\. + +- **`python.analysis.extraPaths`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Additional import search resolution paths + +- **`python.analysis.logLevel`**: `enum { "Error", "Warning", "Information", "Trace" }` + + Default: `"Information"` + + Specifies the level of logging for the Output panel + +- **`python.analysis.stubPath`**: `string` + + Default: `"typings"` + + Path to directory containing custom type stub files\. + +- **`python.analysis.typeCheckingMode`**: `enum { "off", "basic", "strict" }` + + Default: `"basic"` + + Defines the default rule set for type checking\. + +- **`python.analysis.typeshedPaths`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Paths to look for typeshed modules\. + +- **`python.analysis.useLibraryCodeForTypes`**: `boolean` + + Use library implementations to extract type information when type stub is not present\. + +- **`python.pythonPath`**: `string` + + Default: `"python"` + + Path to Python\, you can use a custom version of Python\. + +- **`python.venvPath`**: `string` + + Default: `""` + + Path to folder with a list of Virtual Environments\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.pyright.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - PyrightOrganizeImports: Organize Imports + + Default Values: + cmd = { "pyright-langserver", "--stdio" } + filetypes = { "python" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = { + python = { + analysis = { + autoSearchPaths = true, + diagnosticMode = "workspace", + useLibraryCodeForTypes = true + } + } + } + single_file_support = true +``` + + +## quick_lint_js + +https://quick-lint-js.com/ + +quick-lint-js finds bugs in JavaScript programs. + +See installation [instructions](https://quick-lint-js.com/install/) + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.quick_lint_js.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "quick-lint-js", "--lsp-server" } + filetypes = { "javascript" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + single_file_support = true +``` + + +## r_language_server + +[languageserver](https://github.com/REditorSupport/languageserver) is an +implementation of the Microsoft's Language Server Protocol for the R +language. + +It is released on CRAN and can be easily installed by + +```R +install.packages("languageserver") +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`r.lsp.args`**: `array` + + Default: `{}` + + The command line arguments to use when launching R Language Server + +- **`r.lsp.debug`**: `boolean` + + Debug R Language Server + +- **`r.lsp.diagnostics`**: `boolean` + + Default: `true` + + Enable Diagnostics + +- **`r.lsp.lang`**: `string` + + Default: `""` + + Override default LANG environment variable + +- **`r.lsp.path`**: `string` + + Default: `""` + + Path to R binary for launching Language Server + +- **`r.lsp.use_stdio`**: `boolean` + + Use STDIO connection instead of TCP\. \(Unix\/macOS users only\) + +- **`r.rpath.linux`**: `string` + + Default: `""` + + Path to an R executable for Linux\. Must be \"vanilla\" R\, not radian etc\.\! + +- **`r.rpath.mac`**: `string` + + Default: `""` + + Path to an R executable for macOS\. Must be \"vanilla\" R\, not radian etc\.\! + +- **`r.rpath.windows`**: `string` + + Default: `""` + + Path to an R executable for Windows\. Must be \"vanilla\" R\, not radian etc\.\! + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.r_language_server.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "R", "--slave", "-e", "languageserver::run()" } + filetypes = { "r", "rmd" } + log_level = 2 + root_dir = root_pattern(".git") or os_homedir +``` + + +## racket_langserver + +[https://github.com/jeapostrophe/racket-langserver](https://github.com/jeapostrophe/racket-langserver) + +The Racket language server. This project seeks to use +[DrRacket](https://github.com/racket/drracket)'s public API to provide +functionality that mimics DrRacket's code tools as closely as possible. + +Install via `raco`: `raco pkg install racket-langserver` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.racket_langserver.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "racket", "--lib", "racket-langserver" } + filetypes = { "racket", "scheme" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end + single_file_support = true +``` + + +## remark_ls + +https://github.com/remarkjs/remark-language-server + +`remark-language-server` can be installed via `npm`: +```sh +npm install -g remark-language-server +``` + +`remark-language-server` uses the same +[configuration files](https://github.com/remarkjs/remark/tree/main/packages/remark-cli#example-config-files-json-yaml-js) +as `remark-cli`. + +This uses a plugin based system. Each plugin needs to be installed locally using `npm` or `yarn`. + +For example, given the following `.remarkrc.json`: + +```json +{ + "presets": [ + "remark-preset-lint-recommended" + ] +} +``` + +`remark-preset-lint-recommended` needs to be installed in the local project: + +```sh +npm install remark-preset-lint-recommended +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.remark_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "remark-language-server", "--stdio" } + filetypes = { "markdown" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end + single_file_support = true +``` + + +## rescriptls + +https://github.com/rescript-lang/rescript-vscode + +ReScript language server + +**By default, rescriptls doesn't have a `cmd` set.** This is because nvim-lspconfig does not make assumptions about your path. +You have to install the language server manually. + +You can use the bundled language server inside the [vim-rescript](https://github.com/rescript-lang/vim-rescript) repo. + +Clone the vim-rescript repo and point `cmd` to `server.js` inside `server/out` directory: + +```lua +cmd = {'node', '/server/out/server.js', '--stdio'} + +``` + +If you have vim-rescript installed you can also use that installation. for example if you're using packer.nvim you can set cmd to something like this: + +```lua +cmd = { + 'node', + '/home/username/.local/share/nvim/site/pack/packer/start/vim-rescript/server/out/server.js', + '--stdio' +} +``` + +Another option is to use vscode extension [release](https://github.com/rescript-lang/rescript-vscode/releases). +Take a look at [here](https://github.com/rescript-lang/rescript-vscode#use-with-other-editors) for instructions. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.rescriptls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = {} + filetypes = { "rescript" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} +``` + + +## rls + +https://github.com/rust-lang/rls + +rls, a language server for Rust + +See https://github.com/rust-lang/rls#setup to setup rls itself. +See https://github.com/rust-lang/rls#configuration for rls-specific settings. +All settings listed on the rls configuration section of the readme +must be set under settings.rust as follows: + +```lua +nvim_lsp.rls.setup { + settings = { + rust = { + unstable_features = true, + build_on_save = false, + all_features = true, + }, + }, +} +``` + +If you want to use rls for a particular build, eg nightly, set cmd as follows: + +```lua +cmd = {"rustup", "run", "nightly", "rls"} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.rls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "rls" } + filetypes = { "rust" } + root_dir = root_pattern("Cargo.toml") +``` + + +## rnix + +https://github.com/nix-community/rnix-lsp + +A language server for Nix providing basic completion and formatting via nixpkgs-fmt. + +To install manually, run `cargo install rnix-lsp`. If you are using nix, rnix-lsp is in nixpkgs. + +This server accepts configuration via the `settings` key. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.rnix.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "rnix-lsp" } + filetypes = { "nix" } + init_options = {} + root_dir = vim's starting directory + settings = {} +``` + + +## robotframework_ls + +https://github.com/robocorp/robotframework-lsp + +Language Server Protocol implementation for Robot Framework. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.robotframework_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "robotframework_ls" } + filetypes = { "robot" } + root_dir = util.root_pattern('robotidy.toml', 'pyproject.toml')(fname) or util.find_git_ancestor(fname) +``` + + +## rome + +https://rome.tools + +Language server for the Rome Frontend Toolchain. + +```sh +npm install [-g] rome +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.rome.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "rome", "lsp" } + filetypes = { "javascript", "javascriptreact", "json", "typescript", "typescript.tsx", "typescriptreact" } + root_dir = root_pattern('package.json', 'node_modules', '.git') or dirname + single_file_support = true +``` + + +## rust_analyzer + +https://github.com/rust-analyzer/rust-analyzer + +rust-analyzer (aka rls 2.0), a language server for Rust + +See [docs](https://github.com/rust-analyzer/rust-analyzer/tree/master/docs/user#settings) for extra settings. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`$generated-end`** + + null + +- **`$generated-start`** + + null + +- **`rust-analyzer.assist.allowMergingIntoGlobImports`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.assist.exprFillDefault`**: `enum { "todo", "default" }` + + Default: `"todo"` + + null + +- **`rust-analyzer.assist.importEnforceGranularity`**: `boolean` + + null + +- **`rust-analyzer.assist.importGranularity`**: `enum { "preserve", "crate", "module", "item" }` + + Default: `"crate"` + + null + +- **`rust-analyzer.assist.importGroup`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.assist.importPrefix`**: `enum { "plain", "self", "crate" }` + + Default: `"plain"` + + null + +- **`rust-analyzer.cache.warmup`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.callInfo.full`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.cargo.allFeatures`**: `boolean` + + null + +- **`rust-analyzer.cargo.autoreload`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.cargo.features`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.cargo.noDefaultFeatures`**: `boolean` + + null + +- **`rust-analyzer.cargo.noSysroot`**: `boolean` + + null + +- **`rust-analyzer.cargo.runBuildScripts`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.cargo.target`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.cargo.unsetTest`**: `array` + + Default: `{ "core" }` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.cargo.useRustcWrapperForBuildScripts`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.cargoRunner`**: `null|string` + + Default: `vim.NIL` + + Custom cargo runner extension ID\. + +- **`rust-analyzer.checkOnSave.allFeatures`**: `null|boolean` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.checkOnSave.allTargets`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.checkOnSave.command`**: `string` + + Default: `"check"` + + null + +- **`rust-analyzer.checkOnSave.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.checkOnSave.extraArgs`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.checkOnSave.features`**: `null|array` + + Default: `vim.NIL` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.checkOnSave.noDefaultFeatures`**: `null|boolean` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.checkOnSave.overrideCommand`**: `null|array` + + Default: `vim.NIL` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.checkOnSave.target`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.completion.addCallArgumentSnippets`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.completion.addCallParenthesis`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.completion.autoimport.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.completion.autoself.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.completion.postfix.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.completion.snippets`**: `object` + + Default: `{["Arc::new"] = {body = "Arc::new(${receiver})",description = "Put the expression into an `Arc`",postfix = "arc",requires = "std::sync::Arc",scope = "expr"},["Box::pin"] = {body = "Box::pin(${receiver})",description = "Put the expression into a pinned `Box`",postfix = "pinbox",requires = "std::boxed::Box",scope = "expr"},Err = {body = "Err(${receiver})",description = "Wrap the expression in a `Result::Err`",postfix = "err",scope = "expr"},Ok = {body = "Ok(${receiver})",description = "Wrap the expression in a `Result::Ok`",postfix = "ok",scope = "expr"},["Rc::new"] = {body = "Rc::new(${receiver})",description = "Put the expression into an `Rc`",postfix = "rc",requires = "std::rc::Rc",scope = "expr"},Some = {body = "Some(${receiver})",description = "Wrap the expression in an `Option::Some`",postfix = "some",scope = "expr"}}` + + null + +- **`rust-analyzer.debug.engine`**: `enum { "auto", "vadimcn.vscode-lldb", "ms-vscode.cpptools" }` + + Default: `"auto"` + + Preferred debug engine\. + +- **`rust-analyzer.debug.engineSettings`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`rust-analyzer.debug.openDebugPane`**: `boolean` + + null + +- **`rust-analyzer.debug.sourceFileMap`**: `object|string` + + Default: `{["/rustc/"] = "${env:USERPROFILE}/.rustup/toolchains//lib/rustlib/src/rust"}` + + Optional source file mappings passed to the debug engine\. + +- **`rust-analyzer.diagnostics.disabled`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.diagnostics.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.diagnostics.enableExperimental`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.diagnostics.remapPrefix`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`rust-analyzer.diagnostics.warningsAsHint`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.diagnostics.warningsAsInfo`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.experimental.procAttrMacros`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.files.excludeDirs`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.files.watcher`**: `string` + + Default: `"client"` + + null + +- **`rust-analyzer.highlightRelated.breakPoints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.highlightRelated.exitPoints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.highlightRelated.references`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.highlightRelated.yieldPoints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.highlighting.strings`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hover.documentation`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hover.linksInHover`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hoverActions.debug`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hoverActions.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hoverActions.gotoTypeDef`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hoverActions.implementations`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.hoverActions.references`**: `boolean` + + null + +- **`rust-analyzer.hoverActions.run`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.inlayHints.chainingHints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.inlayHints.enable`**: `boolean` + + Default: `true` + + Whether to show inlay hints\. + +- **`rust-analyzer.inlayHints.hideNamedConstructorHints`**: `boolean` + + null + +- **`rust-analyzer.inlayHints.maxLength`**: `null|integer` + + Default: `25` + + null + +- **`rust-analyzer.inlayHints.parameterHints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.inlayHints.smallerHints`**: `boolean` + + Default: `true` + + Whether inlay hints font size should be smaller than editor\'s font size\. + +- **`rust-analyzer.inlayHints.typeHints`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.joinLines.joinAssignments`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.joinLines.joinElseIf`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.joinLines.removeTrailingComma`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.joinLines.unwrapTrivialBlock`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.lens.debug`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.lens.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.lens.enumVariantReferences`**: `boolean` + + null + +- **`rust-analyzer.lens.forceCustomCommands`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.lens.implementations`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.lens.methodReferences`**: `boolean` + + null + +- **`rust-analyzer.lens.references`**: `boolean` + + null + +- **`rust-analyzer.lens.run`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.linkedProjects`**: `array` + + Default: `{}` + + Array items: `{type = { "string", "object" }}` + + null + +- **`rust-analyzer.lruCapacity`**: `null|integer` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.notifications.cargoTomlNotFound`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.procMacro.enable`**: `boolean` + + Default: `true` + + null + +- **`rust-analyzer.procMacro.ignored`**: `object` + + Default: `vim.empty_dict()` + + null + +- **`rust-analyzer.procMacro.server`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.runnableEnv`** + + Default: `vim.NIL` + + null + +- **`rust-analyzer.runnables.cargoExtraArgs`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.runnables.overrideCargo`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.rustcSource`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.rustfmt.enableRangeFormatting`**: `boolean` + + null + +- **`rust-analyzer.rustfmt.extraArgs`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.rustfmt.overrideCommand`**: `null|array` + + Default: `vim.NIL` + + Array items: `{type = "string"}` + + null + +- **`rust-analyzer.server.extraEnv`**: `null|object` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.server.path`**: `null|string` + + Default: `vim.NIL` + + null + +- **`rust-analyzer.trace.extension`**: `boolean` + + Enable logging of VS Code extensions itself\. + +- **`rust-analyzer.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Trace requests to the rust\-analyzer \(this is usually overly verbose and not recommended for regular users\)\. + +- **`rust-analyzer.workspace.symbol.search.kind`**: `enum { "only_types", "all_symbols" }` + + Default: `"only_types"` + + null + +- **`rust-analyzer.workspace.symbol.search.scope`**: `enum { "workspace", "workspace_and_dependencies" }` + + Default: `"workspace"` + + null + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.rust_analyzer.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - CargoReload: Reload current cargo workspace + + Default Values: + cmd = { "rust-analyzer" } + filetypes = { "rust" } + root_dir = root_pattern("Cargo.toml", "rust-project.json") + settings = { + ["rust-analyzer"] = {} + } +``` + + +## scry + +https://github.com/crystal-lang-tools/scry + +Crystal language server. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.scry.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "scry" } + filetypes = { "crystal" } + root_dir = root_pattern('shard.yml', '.git') or dirname + single_file_support = true +``` + + +## serve_d + + https://github.com/Pure-D/serve-d + + `Microsoft language server protocol implementation for D using workspace-d.` + Download a binary from https://github.com/Pure-D/serve-d/releases and put it in your $PATH. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.serve_d.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "serve-d" } + filetypes = { "d" } + root_dir = util.root_pattern("dub.json", "dub.sdl", ".git") +``` + + +## sixtyfps + +https://github.com/sixtyfpsui/sixtyfps +`SixtyFPS`'s language server + +You can build and install `sixtyfps-lsp` binary with `cargo`: +```sh +cargo install sixtyfps-lsp +``` + +Vim does not have built-in syntax for the `sixtyfps` filetype currently. + +This can be added via an autocmd: + +```lua +vim.cmd [[ autocmd BufRead,BufNewFile *.60 set filetype=sixtyfps ]] +``` + +or by installing a filetype plugin such as https://github.com/RustemB/sixtyfps-vim + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sixtyfps.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "sixtyfps-lsp" } + filetypes = { "sixtyfps" } + single_file_support = true +``` + + +## solang + +A language server for Solidity + +See the [documentation](https://solang.readthedocs.io/en/latest/installing.html) for installation instructions. + +The language server only provides the following capabilities: +* Syntax highlighting +* Diagnostics +* Hover + +There is currently no support for completion, goto definition, references, or other functionality. + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.solang.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "solang", "--language-server", "--target", "ewasm" } + filetypes = { "solidity" } + root_dir = util.find_git_ancestor +``` + + +## solargraph + +https://solargraph.org/ + +solargraph, a language server for Ruby + +You can install solargraph via gem install. + +```sh +gem install --user-install solargraph +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`solargraph.autoformat`**: `enum { true, false }` + + Enable automatic formatting while typing \(WARNING\: experimental\) + +- **`solargraph.bundlerPath`**: `string` + + Default: `"bundle"` + + Path to the bundle executable\, defaults to \'bundle\'\. Needs to be an absolute path for the \'bundle\' exec\/shim + +- **`solargraph.checkGemVersion`**: `enum { true, false }` + + Default: `true` + + Automatically check if a new version of the Solargraph gem is available\. + +- **`solargraph.commandPath`**: `string` + + Default: `"solargraph"` + + Path to the solargraph command\. Set this to an absolute path to select from multiple installed Ruby versions\. + +- **`solargraph.completion`**: `enum { true, false }` + + Default: `true` + + Enable completion + +- **`solargraph.definitions`**: `enum { true, false }` + + Default: `true` + + Enable definitions \(go to\, etc\.\) + +- **`solargraph.diagnostics`**: `enum { true, false }` + + Enable diagnostics + +- **`solargraph.externalServer`**: `object` + + Default: `{host = "localhost",port = 7658}` + + The host and port to use for external transports\. \(Ignored for stdio and socket transports\.\) + +- **`solargraph.folding`**: `boolean` + + Default: `true` + + Enable folding ranges + +- **`solargraph.formatting`**: `enum { true, false }` + + Enable document formatting + +- **`solargraph.hover`**: `enum { true, false }` + + Default: `true` + + Enable hover + +- **`solargraph.logLevel`**: `enum { "warn", "info", "debug" }` + + Default: `"warn"` + + Level of debug info to log\. \`warn\` is least and \`debug\` is most\. + +- **`solargraph.references`**: `enum { true, false }` + + Default: `true` + + Enable finding references + +- **`solargraph.rename`**: `enum { true, false }` + + Default: `true` + + Enable symbol renaming + +- **`solargraph.symbols`**: `enum { true, false }` + + Default: `true` + + Enable symbols + +- **`solargraph.transport`**: `enum { "socket", "stdio", "external" }` + + Default: `"socket"` + + The type of transport to use\. + +- **`solargraph.useBundler`**: `boolean` + + Use \`bundle exec\` to run solargraph\. \(If this is true\, the solargraph\.commandPath setting is ignored\.\) + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.solargraph.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "solargraph", "stdio" } + filetypes = { "ruby" } + init_options = { + formatting = true + } + root_dir = root_pattern("Gemfile", ".git") + settings = { + solargraph = { + diagnostics = true + } + } +``` + + +## solc + +https://docs.soliditylang.org/en/latest/installing-solidity.html + +solc is the native language server for the Solidity language. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.solc.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "solc", "--lsp" } + filetypes = { "solidity" } + root_dir = root_pattern(".git") +``` + + +## solidity_ls + +npm install -g solidity-language-server + +solidity-language-server is a language server for the solidity language ported from the vscode solidity extension + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.solidity_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "solidity-language-server", "--stdio" } + filetypes = { "solidity" } + root_dir = root_pattern(".git", "package.json") +``` + + +## sorbet + +https://sorbet.org + +Sorbet is a fast, powerful type checker designed for Ruby. + +You can install Sorbet via gem install. You might also be interested in how to set +Sorbet up for new projects: https://sorbet.org/docs/adopting. + +```sh +gem install sorbet +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sorbet.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "srb", "tc", "--lsp" } + filetypes = { "ruby" } + root_dir = root_pattern("Gemfile", ".git") +``` + + +## sourcekit + +https://github.com/apple/sourcekit-lsp + +Language server for Swift and C/C++/Objective-C. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`sourcekit-lsp.inlayHints.enabled`**: `boolean` + + \(experimental\) Render inlay type annotations in the editor\. + +- **`sourcekit-lsp.serverArguments`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Arguments to pass to sourcekit\-lsp\. Argument keys and values should be provided as separate entries in the array e\.g\. \[\'\-\-log\-level\'\, \'debug\'\] + +- **`sourcekit-lsp.serverPath`**: `string` + + Default: `"sourcekit-lsp"` + + The path of the sourcekit\-lsp executable + +- **`sourcekit-lsp.toolchainPath`**: `string` + + Default: `""` + + \(optional\) The path of the swift toolchain\. By default\, sourcekit\-lsp uses the toolchain it is installed in\. + +- **`sourcekit-lsp.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the SourceKit\-LSP language server\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sourcekit.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "sourcekit-lsp" } + filetypes = { "swift", "c", "cpp", "objective-c", "objective-cpp" } + root_dir = root_pattern("Package.swift", ".git") +``` + + +## spectral + +https://github.com/luizcorreia/spectral-language-server + `A flexible JSON/YAML linter for creating automated style guides, with baked in support for OpenAPI v2 & v3.` + +`spectral-language-server` can be installed via `npm`: +```sh +npm i -g spectral-language-server +``` +See [vscode-spectral](https://github.com/stoplightio/vscode-spectral#extension-settings) for configuration options. + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`spectral.enable`**: `boolean` + + Default: `true` + + Controls whether or not Spectral is enabled\. + +- **`spectral.rulesetFile`**: `string` + + Location of the ruleset file to use when validating\. If omitted\, the default is a \.spectral\.yml\/\.spectral\.json in the same folder as the document being validated\. Paths are relative to the workspace\. + +- **`spectral.run`**: `enum { "onSave", "onType" }` + + Default: `"onType"` + + Run the linter on save \(onSave\) or as you type \(onType\)\. + +- **`spectral.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Traces the communication between VS Code and the language server\. + +- **`spectral.validateFiles`**: `array` + + Array items: `{type = "string"}` + + An array of file globs \(e\.g\.\, \`\*\*\/\*\.yaml\`\) in minimatch glob format which should be validated by Spectral\. If language identifiers are also specified\, the file must match both in order to be validated\. + +- **`spectral.validateLanguages`**: `array` + + Default: `{ "json", "yaml" }` + + Array items: `{type = "string"}` + + An array of language IDs which should be validated by Spectral\. If file globs are also specified\, the file must match both in order to be validated\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.spectral.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "spectral-language-server", "--stdio" } + filetypes = { "yaml", "json", "yml" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = { + enable = true, + run = "onType", + validateLanguages = { "yaml", "json", "yml" } + } + single_file_support = true +``` + + +## sqlls + +https://github.com/joe-re/sql-language-server + +This LSP can be installed via `npm`. Find further instructions on manual installation of the sql-language-server at [joe-re/sql-language-server](https://github.com/joe-re/sql-language-server). +
+ + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sqlls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "sql-language-server", "up", "--method", "stdio" } + filetypes = { "sql", "mysql" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} +``` + + +## sqls + +https://github.com/lighttiger2505/sqls + +```lua +require'lspconfig'.sqls.setup{ + cmd = {"path/to/command", "-config", "path/to/config.yml"}; + ... +} +``` +Sqls can be installed via `go get github.com/lighttiger2505/sqls`. Instructions for compiling Sqls from the source can be found at [lighttiger2505/sqls](https://github.com/lighttiger2505/sqls). + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sqls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "sqls" } + filetypes = { "sql", "mysql" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} + single_file_support = true +``` + + +## stylelint_lsp + +https://github.com/bmatcuk/stylelint-lsp + +`stylelint-lsp` can be installed via `npm`: + +```sh +npm i -g stylelint-lsp +``` + +Can be configured by passing a `settings.stylelintplus` object to `stylelint_lsp.setup`: + +```lua +require'lspconfig'.stylelint_lsp.setup{ + settings = { + stylelintplus = { + -- see available options in stylelint-lsp documentation + } + } +} +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`stylelintplus.autoFixOnFormat`**: `boolean` + + Auto\-fix on format request\. + +- **`stylelintplus.autoFixOnSave`**: `boolean` + + Auto\-fix and format on save\. + +- **`stylelintplus.config`**: `object` + + Default: `vim.NIL` + + Stylelint config\. If config and configFile are unset\, stylelint will automatically look for a config file\. + +- **`stylelintplus.configFile`**: `string` + + Default: `vim.NIL` + + Stylelint config file\. If config and configFile are unset\, stylelint will automatically look for a config file\. + +- **`stylelintplus.configOverrides`**: `object` + + Default: `vim.NIL` + + Stylelint config overrides\. These will be applied on top of the config\, configFile\, or auto\-discovered config file loaded by stylelint\. + +- **`stylelintplus.cssInJs`**: `boolean` + + Run stylelint on javascript\/typescript files\. + +- **`stylelintplus.enable`**: `boolean` + + Default: `true` + + If false\, stylelint will not validate the file\. + +- **`stylelintplus.filetypes`**: `array` + + Default: `{ "css", "less", "postcss", "sass", "scss", "sugarss", "vue", "wxss" }` + + Array items: `{type = "string"}` + + Filetypes that coc\-stylelintplus will lint\. + +- **`stylelintplus.trace.server`**: `enum { "off", "messages", "verbose" }` + + Default: `"off"` + + Capture trace messages from the server\. + +- **`stylelintplus.validateOnSave`**: `boolean` + + Validate after saving\. Automatically enabled if autoFixOnSave is enabled\. + +- **`stylelintplus.validateOnType`**: `boolean` + + Default: `true` + + Validate after making changes\. + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.stylelint_lsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "stylelint-lsp", "--stdio" } + filetypes = { "css", "less", "scss", "sugarss", "vue", "wxss", "javascript", "javascriptreact", "typescript", "typescriptreact" } + root_dir = root_pattern('.stylelintrc', 'package.json') + settings = {} +``` + + +## sumneko_lua + +https://github.com/sumneko/lua-language-server + +Lua language server. + +`lua-language-server` can be installed by following the instructions [here](https://github.com/sumneko/lua-language-server/wiki/Build-and-Run). The default `cmd` assumes that the `lua-language-server` binary can be found in `$PATH`. + +```lua +local runtime_path = vim.split(package.path, ';') +table.insert(runtime_path, "lua/?.lua") +table.insert(runtime_path, "lua/?/init.lua") + +require'lspconfig'.sumneko_lua.setup { + settings = { + Lua = { + runtime = { + -- Tell the language server which version of Lua you're using (most likely LuaJIT in the case of Neovim) + version = 'LuaJIT', + -- Setup your lua path + path = runtime_path, + }, + diagnostics = { + -- Get the language server to recognize the `vim` global + globals = {'vim'}, + }, + workspace = { + -- Make the server aware of Neovim runtime files + library = vim.api.nvim_get_runtime_file("", true), + }, + -- Do not send telemetry data containing a randomized but unique identifier + telemetry = { + enable = false, + }, + }, + }, +} +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`Lua.IntelliSense.traceBeSetted`**: `boolean` + + null + +- **`Lua.IntelliSense.traceFieldInject`**: `boolean` + + null + +- **`Lua.IntelliSense.traceLocalSet`**: `boolean` + + null + +- **`Lua.IntelliSense.traceReturn`**: `boolean` + + null + +- **`Lua.color.mode`**: `enum { "Grammar", "Semantic", "SemanticEnhanced" }` + + Default: `"Semantic"` + + null + +- **`Lua.completion.autoRequire`**: `boolean` + + Default: `true` + + null + +- **`Lua.completion.callSnippet`**: `enum { "Disable", "Both", "Replace" }` + + Default: `"Disable"` + + null + +- **`Lua.completion.displayContext`**: `integer` + + Default: `0` + + null + +- **`Lua.completion.enable`**: `boolean` + + Default: `true` + + null + +- **`Lua.completion.keywordSnippet`**: `enum { "Disable", "Both", "Replace" }` + + Default: `"Replace"` + + null + +- **`Lua.completion.postfix`**: `string` + + Default: `"@"` + + null + +- **`Lua.completion.requireSeparator`**: `string` + + Default: `"."` + + null + +- **`Lua.completion.showParams`**: `boolean` + + Default: `true` + + null + +- **`Lua.completion.showWord`**: `enum { "Enable", "Fallback", "Disable" }` + + Default: `"Fallback"` + + null + +- **`Lua.completion.workspaceWord`**: `boolean` + + Default: `true` + + null + +- **`Lua.diagnostics.disable`**: `array` + + Array items: `{type = "string"}` + + null + +- **`Lua.diagnostics.enable`**: `boolean` + + Default: `true` + + null + +- **`Lua.diagnostics.globals`**: `array` + + Array items: `{type = "string"}` + + null + +- **`Lua.diagnostics.ignoredFiles`**: `enum { "Enable", "Opened", "Disable" }` + + Default: `"Opened"` + + null + +- **`Lua.diagnostics.libraryFiles`**: `enum { "Enable", "Opened", "Disable" }` + + Default: `"Opened"` + + null + +- **`Lua.diagnostics.neededFileStatus`**: `object` + + null + +- **`Lua.diagnostics.severity`**: `object` + + null + +- **`Lua.diagnostics.workspaceDelay`**: `integer` + + Default: `0` + + null + +- **`Lua.diagnostics.workspaceRate`**: `integer` + + Default: `100` + + null + +- **`Lua.hint.arrayIndex`**: `enum { "Enable", "Auto", "Disable" }` + + Default: `"Auto"` + + null + +- **`Lua.hint.enable`**: `boolean` + + null + +- **`Lua.hint.paramName`**: `enum { "All", "Literal", "Disable" }` + + Default: `"All"` + + null + +- **`Lua.hint.paramType`**: `boolean` + + Default: `true` + + null + +- **`Lua.hint.setType`**: `boolean` + + null + +- **`Lua.hover.enable`**: `boolean` + + Default: `true` + + null + +- **`Lua.hover.enumsLimit`**: `integer` + + Default: `5` + + null + +- **`Lua.hover.previewFields`**: `integer` + + Default: `20` + + null + +- **`Lua.hover.viewNumber`**: `boolean` + + Default: `true` + + null + +- **`Lua.hover.viewString`**: `boolean` + + Default: `true` + + null + +- **`Lua.hover.viewStringMax`**: `integer` + + Default: `1000` + + null + +- **`Lua.misc.parameters`**: `array` + + Array items: `{type = "string"}` + + null + +- **`Lua.runtime.builtin`**: `object` + + null + +- **`Lua.runtime.fileEncoding`**: `enum { "utf8", "ansi", "utf16le", "utf16be" }` + + Default: `"utf8"` + + null + +- **`Lua.runtime.nonstandardSymbol`**: `array` + + Array items: `{enum = { "//", "/**/", "`", "+=", "-=", "*=", "/=", "||", "&&", "!", "!=", "continue" },type = "string"}` + + null + +- **`Lua.runtime.path`**: `array` + + Default: `{ "?.lua", "?/init.lua" }` + + Array items: `{type = "string"}` + + null + +- **`Lua.runtime.pathStrict`**: `boolean` + + null + +- **`Lua.runtime.plugin`**: `string` + + Default: `""` + + null + +- **`Lua.runtime.special`**: `object` + + null + +- **`Lua.runtime.unicodeName`**: `boolean` + + null + +- **`Lua.runtime.version`**: `enum { "Lua 5.1", "Lua 5.2", "Lua 5.3", "Lua 5.4", "LuaJIT" }` + + Default: `"Lua 5.4"` + + null + +- **`Lua.signatureHelp.enable`**: `boolean` + + Default: `true` + + null + +- **`Lua.telemetry.enable`**: `boolean|null` + + Default: `vim.NIL` + + null + +- **`Lua.window.progressBar`**: `boolean` + + Default: `true` + + null + +- **`Lua.window.statusBar`**: `boolean` + + Default: `true` + + null + +- **`Lua.workspace.checkThirdParty`**: `boolean` + + Default: `true` + + null + +- **`Lua.workspace.ignoreDir`**: `array` + + Default: `{ ".vscode" }` + + Array items: `{type = "string"}` + + null + +- **`Lua.workspace.ignoreSubmodules`**: `boolean` + + Default: `true` + + null + +- **`Lua.workspace.library`**: `array` + + Array items: `{type = "string"}` + + null + +- **`Lua.workspace.maxPreload`**: `integer` + + Default: `1000` + + null + +- **`Lua.workspace.preloadFileSize`**: `integer` + + Default: `100` + + null + +- **`Lua.workspace.useGitIgnore`**: `boolean` + + Default: `true` + + null + +- **`Lua.workspace.userThirdParty`**: `array` + + Array items: `{type = "string"}` + + null + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.sumneko_lua.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "lua-language-server" } + filetypes = { "lua" } + log_level = 2 + root_dir = root_pattern(".git") or bufdir + settings = { + Lua = { + telemetry = { + enable = false + } + } + } + single_file_support = true +``` + + +## svelte + +https://github.com/sveltejs/language-tools/tree/master/packages/language-server + +`svelte-language-server` can be installed via `npm`: +```sh +npm install -g svelte-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.svelte.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "svelteserver", "--stdio" } + filetypes = { "svelte" } + root_dir = root_pattern("package.json", ".git") +``` + + +## svls + +https://github.com/dalance/svls + +Language server for verilog and SystemVerilog + +`svls` can be installed via `cargo`: + ```sh + cargo install svls + ``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.svls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "svls" } + filetypes = { "verilog", "systemverilog" } + root_dir = util.find_git_ancestor +``` + + +## tailwindcss + +https://github.com/tailwindlabs/tailwindcss-intellisense + +Tailwind CSS Language Server can be installed via npm: +```sh +npm install -g @tailwindcss/language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.tailwindcss.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "tailwindcss-language-server", "--stdio" } + filetypes = { "aspnetcorerazor", "astro", "astro-markdown", "blade", "django-html", "edge", "eelixir", "ejs", "erb", "eruby", "gohtml", "haml", "handlebars", "hbs", "html", "html-eex", "jade", "leaf", "liquid", "markdown", "mdx", "mustache", "njk", "nunjucks", "php", "razor", "slim", "twig", "css", "less", "postcss", "sass", "scss", "stylus", "sugarss", "javascript", "javascriptreact", "reason", "rescript", "typescript", "typescriptreact", "vue", "svelte" } + init_options = { + userLanguages = { + eelixir = "html-eex", + eruby = "erb" + } + } + on_new_config = function(new_config) + if not new_config.settings then + new_config.settings = {} + end + if not new_config.settings.editor then + new_config.settings.editor = {} + end + if not new_config.settings.editor.tabSize then + -- set tab size for hover + new_config.settings.editor.tabSize = vim.lsp.util.get_effective_tabstop() + end + end, + root_dir = root_pattern('tailwind.config.js', 'tailwind.config.ts', 'postcss.config.js', 'postcss.config.ts', 'package.json', 'node_modules', '.git') + settings = { + tailwindCSS = { + classAttributes = { "class", "className", "classList", "ngClass" }, + lint = { + cssConflict = "warning", + invalidApply = "error", + invalidConfigPath = "error", + invalidScreen = "error", + invalidTailwindDirective = "error", + invalidVariant = "error", + recommendedVariantOrder = "warning" + }, + validate = true + } + } +``` + + +## taplo + +https://taplo.tamasfe.dev/lsp/ + +Language server for Taplo, a TOML toolkit. + +`taplo-lsp` can be installed via `cargo`: +```sh +cargo install --locked taplo-lsp +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.taplo.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "taplo-lsp", "run" } + filetypes = { "toml" } + root_dir = root_pattern("*.toml", ".git") + single_file_support = true +``` + + +## terraform_lsp + +https://github.com/juliosueiras/terraform-lsp + +Terraform language server +Download a released binary from +https://github.com/juliosueiras/terraform-lsp/releases. + +From https://github.com/hashicorp/terraform-ls#terraform-ls-vs-terraform-lsp: + +Both HashiCorp and the maintainer of terraform-lsp expressed interest in +collaborating on a language server and are working towards a _long-term_ +goal of a single stable and feature-complete implementation. + +For the time being both projects continue to exist, giving users the +choice: + +- `terraform-ls` providing + - overall stability (by relying only on public APIs) + - compatibility with any provider and any Terraform >=0.12.0 currently + less features + - due to project being younger and relying on public APIs which may + not offer the same functionality yet + +- `terraform-lsp` providing + - currently more features + - compatibility with a single particular Terraform (0.12.20 at time of writing) + - configs designed for other 0.12 versions may work, but interpretation may be inaccurate + - less stability (due to reliance on Terraform's own internal packages) + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.terraform_lsp.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "terraform-lsp" } + filetypes = { "terraform", "hcl" } + root_dir = root_pattern(".terraform", ".git") +``` + + +## terraformls + +https://github.com/hashicorp/terraform-ls + +Terraform language server +Download a released binary from https://github.com/hashicorp/terraform-ls/releases. + +From https://github.com/hashicorp/terraform-ls#terraform-ls-vs-terraform-lsp: + +Both HashiCorp and the maintainer of terraform-lsp expressed interest in +collaborating on a language server and are working towards a _long-term_ +goal of a single stable and feature-complete implementation. + +For the time being both projects continue to exist, giving users the +choice: + +- `terraform-ls` providing + - overall stability (by relying only on public APIs) + - compatibility with any provider and any Terraform >=0.12.0 currently + less features + - due to project being younger and relying on public APIs which may + not offer the same functionality yet + +- `terraform-lsp` providing + - currently more features + - compatibility with a single particular Terraform (0.12.20 at time of writing) + - configs designed for other 0.12 versions may work, but interpretation may be inaccurate + - less stability (due to reliance on Terraform's own internal packages) + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`terraform-ls.excludeRootModules`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Per\-workspace list of module directories for the language server to exclude + +- **`terraform-ls.experimentalFeatures`**: `object` + + Experimental \(opt\-in\) terraform\-ls features + +- **`terraform-ls.ignoreDirectoryNames`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Per\-workspace list of directory names for the language server to ignore when indexing files + +- **`terraform-ls.rootModules`**: `array` + + Default: `{}` + + Array items: `{type = "string"}` + + Per\-workspace list of module directories for the language server to read + +- **`terraform-ls.terraformExecPath`**: `string` + + Path to the Terraform binary + +- **`terraform-ls.terraformExecTimeout`**: `string` + + Overrides Terraform execution timeout \(e\.g\. 30s\) + +- **`terraform-ls.terraformLogFilePath`**: `string` + + Path to a file for Terraform executions to be logged into \(TF\_LOG\_PATH\) with support for variables \(e\.g\. Timestamp\, Pid\, Ppid\) via Go template syntax \{\{\.VarName\}\} + +- **`terraform.codelens.referenceCount`**: `boolean` + + Display reference counts above top level blocks and attributes\. + +- **`terraform.languageServer`**: `object` + + Default: `{args = { "serve" },external = true,maxNumberOfProblems = 100,pathToBinary = "",["trace.server"] = "off"}` + + Language Server settings + +
+ + +**Snippet to enable the language server:** +```lua +require'lspconfig'.terraformls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "terraform-ls", "serve" } + filetypes = { "terraform" } + root_dir = root_pattern(".terraform", ".git") +``` + + +## texlab + +https://github.com/latex-lsp/texlab + +A completion engine built from scratch for (La)TeX. + +See https://github.com/latex-lsp/texlab/blob/master/docs/options.md for configuration options. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.texlab.setup{} +``` + +**Commands and default values:** +```lua + Commands: + - TexlabBuild: Build the current buffer + - TexlabForward: Forward search from current position + + Default Values: + cmd = { "texlab" } + filetypes = { "tex", "bib" } + root_dir = function(fname) + return util.root_pattern '.latexmkrc'(fname) or util.find_git_ancestor(fname) + end, + settings = { + texlab = { + auxDirectory = ".", + bibtexFormatter = "texlab", + build = { + args = { "-pdf", "-interaction=nonstopmode", "-synctex=1", "%f" }, + executable = "latexmk", + forwardSearchAfter = false, + onSave = false + }, + chktex = { + onEdit = false, + onOpenAndSave = false + }, + diagnosticsDelay = 300, + formatterLineLength = 80, + forwardSearch = { + args = {} + }, + latexFormatter = "latexindent", + latexindent = { + modifyLineBreaks = false + } + } + } + single_file_support = true +``` + + +## tflint + +https://github.com/terraform-linters/tflint + +A pluggable Terraform linter that can act as lsp server. +Installation instructions can be found in https://github.com/terraform-linters/tflint#installation. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.tflint.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "tflint", "--langserver" } + filetypes = { "terraform" } + root_dir = root_pattern(".terraform", ".git", ".tflint.hcl") +``` + + +## theme_check + +https://github.com/Shopify/shopify-cli + +`theme-check-language-server` is bundled with `shopify-cli` or it can also be installed via + +https://github.com/Shopify/theme-check#installation + +**NOTE:** +If installed via Homebrew, `cmd` must be set to 'theme-check-liquid-server' + +```lua +require lspconfig.theme_check.setup { + cmd = { 'theme-check-liquid-server' } +} +``` + + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.theme_check.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "theme-check-language-server", "--stdio" } + filetypes = { "liquid" } + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end + settings = {} +``` + + +## tsserver + +https://github.com/theia-ide/typescript-language-server + +`typescript-language-server` depends on `typescript`. Both packages can be installed via `npm`: +```sh +npm install -g typescript typescript-language-server +``` + +To configure type language server, add a +[`tsconfig.json`](https://www.typescriptlang.org/docs/handbook/tsconfig-json.html) or +[`jsconfig.json`](https://code.visualstudio.com/docs/languages/jsconfig) to the root of your +project. + +Here's an example that disables type checking in JavaScript files. + +```json +{ + "compilerOptions": { + "module": "commonjs", + "target": "es6", + "checkJs": false + }, + "exclude": [ + "node_modules" + ] +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.tsserver.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "typescript-language-server", "--stdio" } + filetypes = { "javascript", "javascriptreact", "javascript.jsx", "typescript", "typescriptreact", "typescript.tsx" } + init_options = { + hostInfo = "neovim" + } + root_dir = root_pattern("package.json", "tsconfig.json", "jsconfig.json", ".git") +``` + + +## typeprof + +https://github.com/ruby/typeprof + +`typeprof` is the built-in analysis and LSP tool for Ruby 3.1+. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.typeprof.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "typeprof", "--lsp", "--stdio" } + filetypes = { "ruby", "eruby" } + root_dir = root_pattern("Gemfile", ".git") +``` + + +## vala_ls + +https://github.com/Prince781/vala-language-server + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.vala_ls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "vala-language-server" } + filetypes = { "vala", "genie" } + root_dir = root_pattern("meson.build", ".git") + single_file_support = true +``` + + +## vdmj + +https://github.com/nickbattle/vdmj + +The VDMJ language server can be installed by cloning the VDMJ repository and +running `mvn clean install`. + +Various options are provided to configure the language server (see below). In +particular: +- `annotation_paths` is a list of folders and/or jar file paths for annotations +that should be used with the language server; +- any value of `debugger_port` less than zero will disable the debugger; note +that if a non-zero value is used, only one instance of the server can be active +at a time. + +More settings for VDMJ can be changed in a file called `vdmj.properties` under +`root_dir/.vscode`. For a description of the available settings, see +[Section 7 of the VDMJ User Guide](https://raw.githubusercontent.com/nickbattle/vdmj/master/vdmj/documentation/UserGuide.pdf). + +Note: proof obligations and combinatorial testing are not currently supported +by neovim. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.vdmj.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = Generated from the options given + filetypes = { "vdmsl", "vdmpp", "vdmrt" } + options = { + annotation_paths = {}, + debugger_port = -1, + high_precision = false, + java = "$JAVA_HOME/bin/java", + java_opts = { "-Xmx3000m", "-Xss1m" }, + logfile = "path.join(vim.fn.stdpath 'cache', 'vdm-lsp.log')", + mavenrepo = "$HOME/.m2/repository/com/fujitsu", + version = "The latest version installed in `mavenrepo`" + } + root_dir = util.find_git_ancestor(fname) or find_vscode_ancestor(fname) +``` + + +## verible + +https://github.com/chipsalliance/verible + +A linter and formatter for verilog and SystemVerilog files. + +Release binaries can be downloaded from [here](https://github.com/chipsalliance/verible/releases) +and placed in a directory on PATH. + +See https://github.com/chipsalliance/verible/tree/master/verilog/tools/ls/README.md for options. + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.verible.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "verible-verilog-ls" } + filetypes = { "systemverilog", "verilog" } + root_dir = function(path) + -- Support git directories and git files (worktrees) + if M.path.is_dir(M.path.join(path, '.git')) or M.path.is_file(M.path.join(path, '.git')) then + return path + end + end) + end +``` + + +## vimls + +https://github.com/iamcco/vim-language-server + +You can install vim-language-server via npm: +```sh +npm install -g vim-language-server +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.vimls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "vim-language-server", "--stdio" } + filetypes = { "vim" } + init_options = { + diagnostic = { + enable = true + }, + indexes = { + count = 3, + gap = 100, + projectRootPatterns = { "runtime", "nvim", ".git", "autoload", "plugin" }, + runtimepath = true + }, + iskeyword = "@,48-57,_,192-255,-#", + runtimepath = "", + suggest = { + fromRuntimepath = true, + fromVimruntime = true + }, + vimruntime = "" + } + root_dir = function(fname) + return util.find_git_ancestor(fname) or vim.fn.getcwd() + end, +``` + + +## vls + +https://github.com/vlang/vls + +V language server. + +`v-language-server` can be installed by following the instructions [here](https://github.com/vlang/vls#installation). + +**By default, v-language-server doesn't have a `cmd` set.** This is because nvim-lspconfig does not make assumptions about your path. You must add the following to your init.vim or init.lua to set `cmd` to the absolute path ($HOME and ~ are not expanded) of your unzipped and compiled v-language-server. + +```lua +-- set the path to the vls installation; +local vls_root_path = vim.fn.stdpath('cache')..'/lspconfig/vls' +local vls_binary = vls_root_path.."/cmd/vls/vls" + +require'lspconfig'.vls.setup { + cmd = {vls_binary}, +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.vls.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + filetypes = { "vlang" } + root_dir = root_pattern("v.mod", ".git") +``` + + +## volar + +https://github.com/johnsoncodehk/volar/tree/master/packages/server + +Volar language server for Vue + +Volar can be installed via npm: + +```sh +npm install -g @volar/server +``` + +Volar by default supports Vue 3 projects. Vue 2 projects need [additional configuration](https://github.com/johnsoncodehk/volar/blob/master/extensions/vscode-vue-language-features/README.md?plain=1#L28-L63). + +**Take Over Mode** +Volar can serve as a language server for both Vue and TypeScript via [Take Over Mode](https://github.com/johnsoncodehk/volar/discussions/471). + +To enable Take Over Mode, override the default filetypes in `setup{}` as follows: + +```lua +require'lspconfig'.volar.setup{ + filetypes = {'typescript', 'javascript', 'javascriptreact', 'typescriptreact', 'vue', 'json'} +} +``` + +**Overriding the default TypeScript Server used by Volar** +The default config looks for TS in the local node_modules. The alternatives are: + +- use a global TypeScript Server installation + +```lua +require'lspconfig'.volar.setup{ + init_options = { + typescript = { + serverPath = '/path/to/.npm/lib/node_modules/typescript/lib/tsserverlib.js' + } + } +} +``` + +- use a global TypeScript Server installation if a local server is not found + +```lua +local util = require 'lspconfig.util' + +local function get_typescript_server_path(root_dir) + local project_root = util.find_node_modules_ancestor(root_dir) + + local local_tsserverlib = project_root ~= nil and util.path.join(project_root, 'node_modules', 'typescript', 'lib', 'tsserverlibrary.js') + local global_tsserverlib = '/home/[yourusernamehere]/.npm/lib/node_modules/typescript/lib/tsserverlibrary.js' + + if local_tsserverlib and util.path.exists(local_tsserverlib) then + return local_tsserverlib + else + return global_tsserverlib + end +end + +require'lspconfig'.volar.setup{ + config = { + on_new_config = function(new_config, new_root_dir) + new_config.init_options.typescript.serverPath = get_typescript_server_path(new_root_dir) + end, + } +} +``` + + + +**Snippet to enable the language server:** +```lua +require'lspconfig'.volar.setup{} +``` + +**Commands and default values:** +```lua + Commands: + + Default Values: + cmd = { "volar-server", "--stdio" } + filetypes = { "vue" } + init_options = { + documentFeatures = { + documentColor = false, + documentFormatting = { + defaultPrintWidth = 100 + }, + documentSymbol = true, + foldingRange = true, + linkedEditingRange = true, + selectionRange = true + }, + languageFeatures = { + callHierarchy = true, + codeAction = true, + codeLens = true, + completion = { + defaultAttrNameCase = "kebabCase", + defaultTagNameCase = "both" + }, + definition = true, + diagnostics = true, + documentHighlight = true, + documentLink = true, + hover = true, + references = true, + rename = true, + renameFileRefactoring = true, + schemaRequestService = true, + semanticTokens = false, + signatureHelp = true, + typeDefinition = true + }, + typescript = { + serverPath = "" + } + } + on_new_config = function(new_config, new_root_dir) + if + new_config.init_options + and new_config.init_options.typescript + and new_config.init_options.typescript.serverPath == '' + then + new_config.init_options.typescript.serverPath = get_typescript_server_path(new_root_dir) + end + end, + root_dir = function(startpath) + return M.search_ancestors(startpath, matcher) + end +``` + + +## vuels + +https://github.com/vuejs/vetur/tree/master/server + +Vue language server(vls) +`vue-language-server` can be installed via `npm`: +```sh +npm install -g vls +``` + +This server accepts configuration via the `settings` key. +
Available settings: + +- **`vetur.completion.autoImport`**: `boolean` + + Default: `true` + + Include completion for module export and auto import them + +- **`vetur.completion.scaffoldSnippetSources`**: `object` + + Default: `{user = "🗒️",vetur = "✌",workspace = "💼"}` + + Where Vetur source Scaffold Snippets from and how to indicate them\. Set a source to \"\" to disable it\. + + \- workspace\: \`\\/\.vscode\/vetur\/snippets\`\. + \- user\: \`\\/User\/snippets\/vetur\`\. + \- vetur\: Bundled in Vetur\. + + The default is\: + \`\`\` + \"vetur\.completion\.scaffoldSnippetSources\"\: \{ + \"workspace\"\: \"💼\"\, + \"user\"\: \"🗒️\"\, + \"vetur\"\: \"✌\" + \} + \`\`\` + + Alternatively\, you can do\: + + \`\`\` + \"vetur\.completion\.scaffoldSnippetSources\"\: \{ + \"workspace\"\: \"\(W\)\"\, + \"user\"\: \"\(U\)\"\, + \"vetur\"\: \"\(V\)\" + \} + \`\`\` + + Read more\: https\:\/\/vuejs\.github\.io\/vetur\/snippet\.html\. + +- **`vetur.completion.tagCasing`**: `enum { "initial", "kebab" }` + + Default: `"kebab"` + + Casing conversion for tag completion + +- **`vetur.dev.logLevel`**: `enum { "INFO", "DEBUG" }` + + Default: `"INFO"` + + Log level for VLS + +- **`vetur.dev.vlsPath`**: `string` + + Path to vls for Vetur developers\. There are two ways of using it\. + + 1\. Clone vuejs\/vetur from GitHub\, build it and point it to the ABSOLUTE path of \`\/server\`\. + 2\. \`yarn global add vls\` and point Vetur to the installed location \(\`yarn global dir\` + node\_modules\/vls\) + +- **`vetur.dev.vlsPort`**: `number` + + Default: `-1` + + The port that VLS listens to\. Can be used for attaching to the VLS Node process for debugging \/ profiling\. + +- **`vetur.experimental.templateInterpolationService`**: `boolean` + + Enable template interpolation service that offers hover \/ definition \/ references in Vue interpolations\. + +- **`vetur.format.defaultFormatter.css`**: `enum { "none", "prettier" }` + + Default: `"prettier"` + + Default formatter for \ region + +- **`vetur.format.defaultFormatter.html`**: `enum { "none", "prettyhtml", "js-beautify-html", "prettier" }` + + Default: `"prettier"` + + Default formatter for \ region + +- **`vetur.format.defaultFormatter.js`**: `enum { "none", "prettier", "prettier-eslint", "vscode-typescript" }` + + Default: `"prettier"` + + Default formatter for \ region + +- **`vetur.format.defaultFormatter.less`**: `enum { "none", "prettier" }` + + Default: `"prettier"` + + Default formatter for \