X-Git-Url: https://git.madduck.net/etc/vim.git/blobdiff_plain/0ee596c5c5e11fc79598407eaf22f83d279f7e9e..5a4872f466ebd76ddd532bdf2798554421c53df4:/.vim/bundle/ale/doc/ale.txt?ds=sidebyside diff --git a/.vim/bundle/ale/doc/ale.txt b/.vim/bundle/ale/doc/ale.txt new file mode 100644 index 00000000..36b551d4 --- /dev/null +++ b/.vim/bundle/ale/doc/ale.txt @@ -0,0 +1,5355 @@ +*ale.txt* Plugin to lint and fix files asynchronously +*ale* + +ALE - Asynchronous Lint Engine + +=============================================================================== +CONTENTS *ale-contents* + + 1. Introduction.........................|ale-introduction| + 2. Supported Languages & Tools..........|ale-support| + 3. Linting..............................|ale-lint| + 3.1 Linting On Other Machines.........|ale-lint-other-machines| + 3.2 Adding Language Servers...........|ale-lint-language-servers| + 3.3 Other Sources.....................|ale-lint-other-sources| + 4. Fixing Problems......................|ale-fix| + 5. Language Server Protocol Support.....|ale-lsp| + 5.1 LSP Neovim Integration............|ale-lsp-neovim| + 5.2 Completion........................|ale-completion| + 5.3 Go To Definition..................|ale-go-to-definition| + 5.4 Go To Type Definition.............|ale-go-to-type-definition| + 5.5 Go To Implementation..............|ale-go-to-implementation| + 5.6 Find References...................|ale-find-references| + 5.7 Hovering..........................|ale-hover| + 5.8 Symbol Search.....................|ale-symbol-search| + 5.9 Refactoring: Rename, Actions......|ale-refactor| + 6. Global Options.......................|ale-options| + 6.1 Highlights........................|ale-highlights| + 7. Linter/Fixer Options.................|ale-integration-options| + 7.1 Options for alex..................|ale-alex-options| + 7.2 Options for cspell................|ale-cspell-options| + 7.3 Options for languagetool..........|ale-languagetool-options| + 7.4 Options for write-good............|ale-write-good-options| + 7.5 Other Linter/Fixer Options........|ale-other-integration-options| + 8. Commands/Keybinds....................|ale-commands| + 9. API..................................|ale-api| + 10. Special Thanks......................|ale-special-thanks| + 11. Contact.............................|ale-contact| + + +=============================================================================== +1. Introduction *ale-introduction* + +ALE provides the means to run linters asynchronously in Vim in a variety of +languages and tools. ALE sends the contents of buffers to linter programs +using the |job-control| features available in Vim 8 and NeoVim. For Vim 8, +Vim must be compiled with the |+job| and |+channel| and |+timers| features +as a minimum. + +ALE supports the following key features for linting: + +1. Running linters when text is changed. +2. Running linters when files are opened. +3. Running linters when files are saved. (When a global flag is set.) +4. Populating the |location-list| with warning and errors. +5. Setting |signs| with warnings and errors for error markers. +6. Using `:echo` to show error messages when the cursor moves. +7. Setting syntax highlights for errors. + +ALE can fix problems with files with the `:ALEFix` command, using the same job +control functionality used for checking for problems. Try using the +`:ALEFixSuggest` command for browsing tools that can be used to fix problems +for the current buffer. + +If you are interested in contributing to the development of ALE, read the +developer documentation. See |ale-development| + +For configuring ALE in Neovim, you can use the |ale.setup| function to +configure ALE globally in `init.vim`. > + + require("ale").setup({ + completion_enabled = true, + maximum_file_size = 1024 * 1024, + warn_about_trailing_whitespace = false, + }) +< +In |ftplugin| files you can customise behavior for different filetypes by +using the |ale.setup.buffer| function. > + + -- In ftplugin/python.lua in &runtimepath + require("ale").setup.buffer({ + linters = {"ruff", "pyright"}, + fixers = {"ruff"} + }) +< +Buffer local settings override global settings for that buffer. + + +=============================================================================== +2. Supported Languages & Tools *ale-support* + +ALE supports a wide variety of languages and tools. See |ale-supported-list| +for the full list. + + +=============================================================================== +3. Linting *ale-lint* + +ALE's primary focus is on checking for problems with your code with various +programs via some Vim code for integrating with those programs, referred to +as 'linters.' ALE supports a wide array of programs for linting by default, +but additional programs can be added easily by defining files in |runtimepath| +with the filename pattern `ale_linters//.vim`. For more +information on defining new linters, see the extensive documentation +for |ale#linter#Define()|. + +Without any configuration, ALE will attempt to check all of the code for every +file you open in Vim with all available tools by default. To see what ALE +is doing, and what options have been set, try using the `:ALEInfo` command. + +Most of the linters ALE runs will check the Vim buffer you are editing instead +of the file on disk. This allows you to check your code for errors before you +have even saved your changes. ALE will check your code in the following +circumstances, which can be configured with the associated options. + +* When you modify a buffer - |g:ale_lint_on_text_changed| +* On leaving insert mode - |g:ale_lint_on_insert_leave| +* When you open a new or modified buffer - |g:ale_lint_on_enter| +* When you save a buffer - |g:ale_lint_on_save| +* When the filetype changes for a buffer - |g:ale_lint_on_filetype_changed| +* If ALE is used to check code manually - |:ALELint| + + *ale-lint-settings-on-startup* + +It is worth reading the documentation for every option. You should configure +which events ALE will use before ALE is loaded, so it can optimize which +autocmd commands to run. You can force autocmd commands to be reloaded with +`:ALEDisable | ALEEnable` + +This also applies to the autocmd commands used for |g:ale_echo_cursor|. + + *ale-lint-file-linters* + +Some programs must be run against files which have been saved to disk, and +simply do not support reading temporary files or stdin, either of which are +required for ALE to be able to check for errors as you type. The programs +which behave this way are documented in the lists and tables of supported +programs. ALE will only lint files with these programs in the following +circumstances. + +* When you open a new or modified buffer - |g:ale_lint_on_enter| +* When you save a buffer - |g:ale_lint_on_save| +* When the filetype changes for a buffer - |g:ale_lint_on_filetype_changed| +* If ALE is used to check code manually - |:ALELint| + +ALE will report problems with your code in the following ways, listed with +their relevant options. + +* Via Neovim diagnostics (On in Neovim 0.7+) - |g:ale_use_neovim_diagnostics_api| +* By updating loclist (On by default) - |g:ale_set_loclist| +* By updating quickfix (Off by default) - |g:ale_set_quickfix| +* By setting error highlights - |g:ale_set_highlights| +* By creating signs in the sign column - |g:ale_set_signs| +* By echoing messages based on your cursor - |g:ale_echo_cursor| +* By showing virtual text at your cursor - |g:ale_virtualtext_cursor| +* By previewing details at your cursor - |g:ale_cursor_detail| +* By showing balloons for your mouse cursor - |g:ale_set_balloons| + +Please consult the documentation for each option, which can reveal some other +ways of tweaking the behavior of each way of displaying problems. You can +disable or enable whichever options you prefer. + +Most settings can be configured for each buffer. (|b:| instead of |g:|), +including disabling ALE for certain buffers with |b:ale_enabled|. The +|g:ale_pattern_options| setting can be used to configure files differently +based on regular expressions for filenames. For configuring entire projects, +the buffer-local options can be used with external plugins for reading Vim +project configuration files. Buffer-local settings can also be used in +ftplugin files for different filetypes. + +ALE offers several options for controlling which linters are run. + +* Selecting linters to run. - |g:ale_linters| +* Aliasing filetypes for linters - |g:ale_linter_aliases| +* Only running linters you asked for. - |g:ale_linters_explicit| +* Disabling only a subset of linters. - |g:ale_linters_ignore| +* Disabling LSP linters and `tsserver`. - |g:ale_disable_lsp| + +You can stop ALE any currently running linters with the `:ALELintStop` command. +Any existing problems will be kept. + + +------------------------------------------------------------------------------- +3.1 Linting On Other Machines *ale-lint-other-machines* + +ALE offers support for running linters or fixers on files you are editing +locally on other machines, so long as the other machine has access to the file +you are editing. This could be a linter or fixer run inside of a Docker image, +running in a virtual machine, running on a remote server, etc. + +In order to run tools on other machines, you will need to configure your tools +to run via scripts that execute commands on those machines, such as by setting +the ALE `_executable` options for those tools to a path for a script to run, +or by using |g:ale_command_wrapper| to specify a script to wrap all commands +that are run by ALE, before they are executed. For tools that ALE runs where +ALE looks for locally installed executables first, you may need to set the +`_use_global` options for those tools to `1`, or you can set +|g:ale_use_global_executables| to `1` before ALE is loaded to only use global +executables for all tools. + +In order for ALE to properly lint or fix files which are running on another +file system, you must provide ALE with |List|s of strings for mapping paths to +and from your local file system and the remote file system, such as the file +system of your Docker container. See |g:ale_filename_mappings| for all of the +different ways these filename mappings can be configured. + +For example, you might configure `pylint` to run via Docker by creating a +script like so. > + + #!/usr/bin/env bash + + exec docker run -i --rm -v "$(pwd):/data" cytopia/pylint "$@" +< +You will want to run Docker commands with `-i` in order to read from stdin. + +With the above script in mind, you might configure ALE to lint your Python +project with `pylint` by providing the path to the script to execute, and +mappings which describe how to change between the two file systems in your +`python.vim` |ftplugin| file, like so: > + + if expand('%:p') =~# '^/home/w0rp/git/test-pylint/' + let b:ale_linters = ['pylint'] + let b:ale_python_pylint_use_global = 1 + " This is the path to the script above. + let b:ale_python_pylint_executable = '/home/w0rp/git/test-pylint/pylint.sh' + " /data matches the path in Docker. + let b:ale_filename_mappings = { + \ 'pylint': [ + \ ['/home/w0rp/git/test-pylint', '/data'], + \ ], + \} + endif +< +You might consider using a Vim plugin for loading Vim configuration files +specific to each project, if you have a lot of projects to manage. + + +------------------------------------------------------------------------------- +3.2 Adding Language Servers *ale-lint-language-servers* + +ALE comes with many default configurations for language servers, so they can +be detected and run automatically. ALE can connect to other language servers +by defining a new linter for a filetype. New linters can be defined in |vimrc|, +in plugin files, or `ale_linters` directories in 'runtimepath'. + +See |ale-linter-loading-behavior| for more information on loading linters. + +A minimal configuration for a language server linter might look so. > + + call ale#linter#Define('filetype_here', { + \ 'name': 'any_name_you_want', + \ 'lsp': 'stdio', + \ 'executable': '/path/to/executable', + \ 'command': '%e run', + \ 'project_root': '/path/to/root_of_project', + \}) +< +For language servers that use a TCP or named pipe socket connection, you +should define the address to connect to instead. > + + call ale#linter#Define('filetype_here', { + \ 'name': 'any_name_you_want', + \ 'lsp': 'socket', + \ 'address': 'servername:1234', + \ 'project_root': '/path/to/root_of_project', + \}) +< +Most of the options for a language server can be replaced with a |Funcref| for +a function accepting a buffer number for dynamically computing values such as +the executable path, the project path, the server address, etc, most of which +can also be determined based on executing some other asynchronous task. See +|ale#command#Run()| for computing linter options based on asynchronous +results. + +See |ale#linter#Define()| for a detailed explanation of all of the options for +configuring linters. + + +------------------------------------------------------------------------------- +3.3 Other Sources *ale-lint-other-sources* + +Problems for a buffer can be taken from other sources and rendered by ALE. +This allows ALE to be used in combination with other plugins which also want +to display any problems they might find with a buffer. ALE's API includes the +following components for making this possible. + +* |ale#other_source#StartChecking()| - Tell ALE that a buffer is being checked. +* |ale#other_source#ShowResults()| - Show results from another source. +* |ALEWantResults| - A signal for when ALE wants results. + +Other resources can provide results for ALE to display at any time, following +ALE's loclist format. (See |ale-loclist-format|) For example: > + + " Tell ALE to show some results. + " This function can be called at any time. + call ale#other_source#ShowResults(bufnr(''), 'some-linter-name', [ + \ {'text': 'Something went wrong', 'lnum': 13}, + \]) +< +Other sources should use a unique name for identifying themselves. A single +linter name can be used for all problems from another source, or a series of +unique linter names can be used. Results can be cleared for that source by +providing an empty List. + +|ale#other_source#StartChecking()| should be called whenever another source +starts checking a buffer, so other tools can know that a buffer is being +checked by some plugin. The |ALEWantResults| autocmd event can be used to +start checking a buffer for problems every time that ALE does. When +|ALEWantResults| is signaled, |g:ale_want_results_buffer| will be set to the +number of the buffer that ALE wants to check. +|ale#other_source#StartChecking()| should be called synchronously, and other +sources should perform their checks on a buffer in the background +asynchronously, so they don't interrupt editing. + +|ale#other_source#ShowResults()| must not be called synchronously before +ALE's engine executes its code after the |ALEWantResults| event runs. If +there are immediate results to provide to ALE, a 0 millisecond timer with +|timer_start()| can be set instead up to call |ale#other_source#ShowResults()| +after ALE has first executed its engine code for its own sources. + +A plugin might integrate its own checks with ALE like so: > + + augroup SomeGroupName + autocmd! + autocmd User ALEWantResults call Hook(g:ale_want_results_buffer) + augroup END + + function! DoBackgroundWork(buffer) abort + " Start some work in the background here. + " ... + " Then call WorkDone(a:buffer, results) + endfunction + + function! Hook(buffer) abort + " Tell ALE we're going to check this buffer. + call ale#other_source#StartChecking(a:buffer, 'some-name') + call DoBackgroundWork(a:buffer) + endfunction + + function! WorkDone(buffer, results) abort + " Send results to ALE after they have been collected. + call ale#other_source#ShowResults(a:buffer, 'some-name', a:results) + endfunction +< + +=============================================================================== +4. Fixing Problems *ale-fix* + +ALE can fix problems with files with the `:ALEFix` command. `:ALEFix` +accepts names of fixers to be applied as arguments. Alternatively, +when no arguments are provided, the variable |g:ale_fixers| will be +read for getting a |List| of commands for filetypes, split on `.`, and +the functions named in |g:ale_fixers| will be executed for fixing the +errors. + +The `:ALEFixSuggest` command can be used to suggest tools that be used to +fix problems for the current buffer. + +The values for `g:ale_fixers` can be a list of |String|, |Funcref|, or +|lambda| values. String values must either name a function, or a short name +for a function set in the ALE fixer registry. + +Each function for fixing errors must accept either one argument `(buffer)` or +two arguments `(buffer, lines)`, representing the buffer being fixed and the +lines to fix. The functions must return either `0`, for changing nothing, a +|List| for new lines to set, a |Dictionary| for describing a command to be +run in the background, or the result of |ale#command#Run()|. + +Functions receiving a variable number of arguments will not receive the second +argument `lines`. Functions should name two arguments if the `lines` argument +is desired. This is required to avoid unnecessary copying of the lines of +the buffers being checked. + +When a |Dictionary| is returned for an `:ALEFix` callback, the following keys +are supported for running the commands. + + `cwd` An optional |String| for setting the working directory + for the command. + + If not set, or `v:null`, the `cwd` of the last command + that spawn this one will be used. + + `command` A |String| for the command to run. This key is required. + + When `%t` is included in a command string, a temporary + file will be created, containing the lines from the file + after previous adjustment have been done. + + See |ale-command-format-strings| for formatting options. + + `read_temporary_file` When set to `1`, ALE will read the contents of the + temporary file created for `%t`. This option can be used + for commands which need to modify some file on disk in + order to fix files. + + `process_with` An optional callback for post-processing. + + The callback must accept arguments `(bufnr, output)`: + the buffer number undergoing fixing and the fixer's + output as a |List| of |String|s. It must return a |List| + of |String|s that will be the new contents of the + buffer. + + This callback is useful to remove excess lines from the + command's output or apply additional changes to the + output. + + + `read_buffer` An optional key for disabling reading the buffer. + + When set to `0`, ALE will not pipe the buffer's data + into the command via stdin. This option is ignored and + the buffer is not read when `read_temporary_file` is + `1`. + + This option defaults to `1`. + + *ale-fix-configuration* + +Synchronous functions and asynchronous jobs will be run in a sequence for +fixing files, and can be combined. For example: +> + let g:ale_fixers = { + \ 'javascript': [ + \ 'DoSomething', + \ 'eslint', + \ {buffer, lines -> filter(lines, 'v:val !=~ ''^\s*//''')}, + \ ], + \} + + ALEFix +< +The above example will call a function called `DoSomething` which could act +upon some lines immediately, then run `eslint` from the ALE registry, and +then call a lambda function which will remove every single line comment +from the file. + +For buffer-local settings, such as in |g:ale_pattern_options| or in ftplugin +files, a |List| may be used for configuring the fixers instead. +> + " Same as the above, only a List can be used instead of a Dictionary. + let b:ale_fixers = [ + \ 'DoSomething', + \ 'eslint', + \ {buffer, lines -> filter(lines, 'v:val !=~ ''^\s*//''')}, + \] + + ALEFix +< +For convenience, a plug mapping is defined for `:ALEFix`, so you can set up a +keybind easily for fixing files. > + + " Bind F8 to fixing problems with ALE + nmap (ale_fix) +< +Files can be fixed automatically with the following options, which are all off +by default. + +|g:ale_fix_on_save| - Fix files when they are saved. + +Fixers can be disabled on save with |g:ale_fix_on_save_ignore|. They will +still be run when you manually run `:ALEFix`. + +Fixers can be run on another machines, just like linters, such as fixers run +from a Docker container, running in a virtual machine, running a remote +server, etc. See |ale-lint-other-machines|. + + +=============================================================================== +5. Language Server Protocol Support *ale-lsp* + +ALE integrates with Language Server Protocol (LSP) servers. LSP linters can be +used in combination with any other linter, and will automatically connect to +LSP servers when needed. ALE also supports `tsserver` for TypeScript, which +uses a different but very similar protocol. + +If you want to use another plugin for LSP features and tsserver, you can use +the |g:ale_disable_lsp| setting to disable ALE's own LSP integrations, or +ignore particular linters with |g:ale_linters_ignore|. In ALE's default +configuration ALE will attempt to avoid conflicting with `nvim-lspconfig`. + +ALE will integrate with Neovim's LSP client by default in Neovim 0.8+. This +functionality can be controlled with the |g:ale_use_neovim_lsp_api| setting. +See |ale-lsp-neovim| below for information about ALE's integration with +Neovim's LSP client. + +If for any reason you want to stop a language server ALE starts, such as when +a project configuration has significantly changed, or new files have been +added the language server isn't aware of, use either `:ALEStopLSP` or +`:ALEStopAllLSPs` to stop the server until ALE automatically starts it again. + + +------------------------------------------------------------------------------- +5.1 LSP Neovim Integration *ale-lsp-neovim* + +In Neovim 0.8+ ALE will integrate with Neovim's native LSP client by default, +unless disabled by setting |g:ale_use_neovim_lsp_api| to `0`. All built in +functionality for Neovim's LSP client should work as expected, and this +ensures ALE integrates well with other plugins that rely on Neovim's LSP +client. + +NOTE: Neovim versions below `0.11.0` do not support socket connections to +language servers when the `address` defined in ALE uses a hostname instead of +an IP address. To work around this, configure language clients with an IP +address instead of a hostname, or revert back to ALE's custom LSP client. + +See |lsp| for information on Neovim's built in LSP client. + +For diagnostics, for computing problems to show via ALE, ALE overrides the +diagnostics handler for the LSP client launched by ALE, so all of the +functionality in ALE will work as expected. By default ALE will send +diagnostics back to Neovim's diagnostics API, which can be configured with the +|g:ale_use_neovim_diagnostics_api| setting. This ensures that all of the +functionality ALE adds on top for diagnostics will function, and that problems +from linters that don't use LSP can be combined with LSP servers. See the +diagram below. > + + +-------------------+ + | Language Server | (Sends diagnostics) + +-------------------+ + | + +-------------------+ + | Neovim LSP Client | (Receives diagnostics) + +-------------------+ + | + +-------------------+ + | ALE Processing | (Intercepts and processes diagnostics) + +-------------------+ + | + +-------------------+ + | Diagnostic engine | (Either Neovim's diagnostics or ALE's custom code) + +-------------------+ + | + +-------------------+ + | Neovim | (User sees formatted diagnostics) + +-------------------+ +< +For LSP functionality executed via ALE's own functions, commands, and +keybinds, ALE will intercept requests and handle them in an entirely custom +way, ensuring ALE functionality should work largely the same between +different Vim versions. See the diagram below. > + + +-------------------+ + | Neovim | (User triggers LSP request via ALE) + +-------------------+ + | + +-------------------+ + | ALE | (ALE sends request to Neovim client) + +-------------------+ + | + +-------------------+ + | Neovim LSP Client | (Forwards request to language server) + +-------------------+ + | + +-------------------+ + | Language Server | (Processes request and sends response) + +-------------------+ + | + +-------------------+ + | Neovim LSP Client | (Receives response) + +-------------------+ + | + +-------------------+ + | ALE | (ALE Handles "raw" LSP response) + +-------------------+ + | + +-------------------+ + | Neovim | (User sees result) + +-------------------+ +< +For LSP functionality built-in to Neovim, such as the |gd| keybind for jumping +to a definition, Neovim will bypass ALE entirely, ensuring that ALE does not +interfere with LSP functionality as expected by built-in Neovim tools or other +plugins. See the diagram below. > + + +-------------------+ + | Neovim | (User triggers LSP request) + +-------------------+ + | + +-------------------+ + | Neovim LSP Client | (Directly handles the request) + +-------------------+ + | + +-------------------+ + | Language Server | (Processes request and sends response) + +-------------------+ + | + +-------------------+ + | Neovim LSP Client | (Receives response and shows result) + +-------------------+ + | + +-------------------+ + | Neovim | (User sees result) + +-------------------+ +< + +------------------------------------------------------------------------------- +5.2 Completion *ale-completion* + +In Neovim 0.8+ ALE's integration with its native LSP client will make it +possible to use other plugins that rely on Neovim's LSP client as a basis. +`nvim-cmp` is recommended as a completion plugin worth trying in Neovim. +See: https://github.com/hrsh7th/nvim-cmp + +ALE offers support for automatic completion of code while you type. +Completion is only supported while at least one LSP linter is enabled. ALE +will only suggest symbols provided by the LSP servers. + + *ale-deoplete-integration* + +ALE integrates with Deoplete for offering automatic completion data. ALE's +completion source for Deoplete is named `'ale'`, and should enabled +automatically if Deoplete is enabled and configured correctly. Deoplete +integration should not be combined with ALE's own implementation. + + *ale-asyncomplete-integration* + +ALE additionally integrates with asyncomplete.vim for offering automatic +completion data. ALE's asyncomplete source requires registration with +defaults provided by the |asyncomplete#sources#ale#get_source_options| function > + + " Use ALE's function for asyncomplete defaults + " Provide your own overrides here. + au User asyncomplete_setup call asyncomplete#register_source( + \ asyncomplete#sources#ale#get_source_options({ + \ 'priority': 10, + \ }) + \) +> +ALE also offers its own completion implementation, which does not require any +other plugins. Suggestions will be made while you type after completion is +enabled. ALE's own completion implementation can be enabled by setting +|g:ale_completion_enabled| to `true` or `1`. This setting must be set to +`true` or `1` before ALE is loaded. The delay for completion can be configured +with |g:ale_completion_delay|. This setting should not be enabled if you wish +to use ALE as a completion source for other plugins. + +ALE automatic completion will not work when 'paste' is active. Only set +'paste' when you are copy and pasting text into your buffers. + +ALE automatic completion will interfere with default insert completion with +`CTRL-N` and so on (|compl-vim|). You can write your own keybinds and a +function in your |vimrc| file to force insert completion instead, like so: > + + function! SmartInsertCompletion() abort + " Use the default CTRL-N in completion menus + if pumvisible() + return "\" + endif + + " Exit and re-enter insert mode, and use insert completion + return "\a\" + endfunction + + inoremap =SmartInsertCompletion() +< +ALE provides an 'omnifunc' function |ale#completion#OmniFunc| for triggering +completion manually with CTRL-X CTRL-O. |i_CTRL-X_CTRL-O| > + + " Use ALE's function for omnicompletion. + set omnifunc=ale#completion#OmniFunc +< + *ale-completion-fallback* + +You can write your own completion function and fallback on other methods of +completion by checking if there are no results that ALE can determine. For +example, for Python code, you could fall back on the `python3complete` +function. > + + function! TestCompletionFunc(findstart, base) abort + let l:result = ale#completion#OmniFunc(a:findstart, a:base) + + " Check if ALE couldn't find anything. + if (a:findstart && l:result is -3) + \|| (!a:findstart && empty(l:result)) + " Defer to another omnifunc if ALE couldn't find anything. + return python3complete#Complete(a:findstart, a:base) + endif + + return l:result + endfunction + + set omnifunc=TestCompletionFunc +< +See |complete-functions| for documentation on how to write completion +functions. + +ALE will only suggest so many possible matches for completion. The maximum +number of items can be controlled with |g:ale_completion_max_suggestions|. + +If you don't like some of the suggestions you see, you can filter them out +with |g:ale_completion_excluded_words| or |b:ale_completion_excluded_words|. + +The `:ALEComplete` command can be used to show completion suggestions manually, +even when |g:ale_completion_enabled| is set to `0`. For manually requesting +completion information with Deoplete, consult Deoplete's documentation. + +ALE supports automatic imports from external modules. This behavior can be +disabled by setting the |g:ale_completion_autoimport| variable to `0`. +Disabling automatic imports can drop some or all completion items from +some LSP servers (e.g. eclipselsp). + +You can manually request imports for symbols at the cursor with the +`:ALEImport` command. The word at the cursor must be an exact match for some +potential completion result which includes additional text to insert into the +current buffer, which ALE will assume is code for an import line. This command +can be useful when your code already contains something you need to import. + +You can execute other commands whenever ALE inserts some completion text with +the |ALECompletePost| event. + +When working with TypeScript files, ALE can remove warnings from your +completions by setting the |g:ale_completion_tsserver_remove_warnings| +variable to 1. + + *ale-completion-completeopt-bug* + +ALE Automatic completion implementation replaces |completeopt| before opening +the omnicomplete menu with . In some versions of Vim, the value set +for the option will not be respected. If you experience issues with Vim +automatically inserting text while you type, set the following option in +vimrc, and your issues should go away. > + + set completeopt=menu,menuone,preview,noselect,noinsert +< +Or alternatively, if you want to show documentation in popups: > + + set completeopt=menu,menuone,popup,noselect,noinsert +< + *ale-symbols* + +ALE provides a set of basic completion symbols. If you want to replace those +symbols with others, you can set the variable |g:ale_completion_symbols| with +a mapping of the type of completion to the symbol or other string that you +would like to use. An example here shows the available options for symbols > + + let g:ale_completion_symbols = { + \ 'text': '', + \ 'method': '', + \ 'function': '', + \ 'constructor': '', + \ 'field': '', + \ 'variable': '', + \ 'class': '', + \ 'interface': '', + \ 'module': '', + \ 'property': '', + \ 'unit': 'unit', + \ 'value': 'val', + \ 'enum': '', + \ 'keyword': 'keyword', + \ 'snippet': '', + \ 'color': 'color', + \ 'file': '', + \ 'reference': 'ref', + \ 'folder': '', + \ 'enum member': '', + \ 'constant': '', + \ 'struct': '', + \ 'event': 'event', + \ 'operator': '', + \ 'type_parameter': 'type param', + \ '': 'v' + \ } +< + +------------------------------------------------------------------------------- +5.3 Go To Definition *ale-go-to-definition* + +ALE supports jumping to the files and locations where symbols are defined +through any enabled LSP linters. The locations ALE will jump to depend on the +information returned by LSP servers. The `:ALEGoToDefinition` command will jump +to the definition of symbols under the cursor. See the documentation for the +command for configuring how the location will be displayed. + +ALE will update Vim's |tagstack| automatically unless |g:ale_update_tagstack| is +set to `0`. + + +------------------------------------------------------------------------------- +5.4 Go To Type Definition *ale-go-to-type-definition* + +ALE supports jumping to the files and locations where symbols' types are +defined through any enabled LSP linters. The locations ALE will jump to depend +on the information returned by LSP servers. The `:ALEGoToTypeDefinition` +command will jump to the definition of symbols under the cursor. See the +documentation for the command for configuring how the location will be +displayed. + + +------------------------------------------------------------------------------- +5.5 Go To Implementation *ale-go-to-implementation* + +ALE supports jumping to the files and locations where symbols are implemented +through any enabled LSP linters. The locations ALE will jump to depend on the +information returned by LSP servers. The `:ALEGoToImplementation` command will +jump to the implementation of symbols under the cursor. See the documentation +for the command for configuring how the location will be displayed. + + +------------------------------------------------------------------------------- +5.6 Find References *ale-find-references* + +ALE supports finding references for symbols though any enabled LSP linters +with the `:ALEFindReferences` command. See the documentation for the command +for a full list of options. + + +------------------------------------------------------------------------------- +5.7 Hovering *ale-hover* + +ALE supports "hover" information for printing brief information about symbols +at the cursor taken from LSP linters. The following commands are supported: + +`:ALEHover` - Print information about the symbol at the cursor. + +Truncated information will be displayed when the cursor rests on a symbol by +default, as long as there are no problems on the same line. You can disable +this behavior by setting |g:ale_hover_cursor| to `0`. + +If |g:ale_set_balloons| is set to `true` or `1` and your version of Vim +supports the |balloon_show()| function, then "hover" information also show up +when you move the mouse over a symbol in a buffer. Diagnostic information will +take priority over hover information for balloons. If a line contains a +problem, that problem will be displayed in a balloon instead of hover +information. + +Hover information can be displayed in the preview window instead by setting +|g:ale_hover_to_preview| to `true` or `1`. + +When using Neovim or Vim with |popupwin|, if |g:ale_hover_to_floating_preview| +or |g:ale_floating_preview| is set to `true` or `1`, the hover information +will show in a floating window. The borders of the floating preview window can +be customized by setting |g:ale_floating_window_border|. + +For Vim 8.1+ terminals, mouse hovering is disabled by default. Enabling +|balloonexpr| commands in terminals can cause scrolling issues in terminals, +so ALE will not attempt to show balloons unless |g:ale_set_balloons| is set to +`true` or `1` before ALE is loaded. + +For enabling mouse support in terminals, you may have to change your mouse +settings. For example: > + + " Example mouse settings. + " You will need to try different settings, depending on your terminal. + set mouse=a + set ttymouse=xterm +< + +Documentation for symbols at the cursor can be retrieved using the +`:ALEDocumentation` command. This command is only available for `tsserver`. + + +------------------------------------------------------------------------------- +5.8 Symbol Search *ale-symbol-search* + +ALE supports searching for workspace symbols via LSP linters with the +`:ALESymbolSearch` command. See the documentation for the command +for a full list of options. + + +------------------------------------------------------------------------------- +5.9 Refactoring: Rename, Actions *ale-refactor* + +ALE supports renaming symbols in code such as variables or class names with +the `:ALERename` command. + +`:ALEFileRename` will rename file and fix import paths (tsserver only). + +`:ALECodeAction` will execute actions on the cursor or applied to a visual +range selection, such as automatically fixing errors. + +Actions will appear in the right click mouse menu by default for GUI versions +of Vim, unless disabled by setting |g:ale_popup_menu_enabled| to `0`. + +Make sure to set your Vim to move the cursor position whenever you right +click, and enable the mouse menu: > + + set mouse=a + set mousemodel=popup_setpos +< +You may wish to remove some other menu items you don't want to see: > + + silent! aunmenu PopUp.Select\ Word + silent! aunmenu PopUp.Select\ Sentence + silent! aunmenu PopUp.Select\ Paragraph + silent! aunmenu PopUp.Select\ Line + silent! aunmenu PopUp.Select\ Block + silent! aunmenu PopUp.Select\ Blockwise + silent! aunmenu PopUp.Select\ All +< + +=============================================================================== +6. Global Options *ale-options* + +Options documented here can be configured either Vim variables, or via the +|ale.setup| and |ale.setup.buffer| functions in Lua. When configuring via +the Lua functions in Lua scripts, ALE will bridge types to Vim script in the +following ways. + +1. Strings, numbers, booleans, and `nil` will be represented exactly. +2. Tables with no or only number keys will become a |List| in Vim. +3. Keys other than strings and numbers in tables cannot be represented. +4. Tables with special |metatable| properties cannot be represented. +5. Options accepting functions as values will automatically have Vim functions + created that bridge the function calls to and from Lua code. + + *g:airline#extensions#ale#enabled* +g:airline#extensions#ale#enabled + Type: |Number| + Default: `1` + + Enables or disables the |airline|'s native extension for ale, which displays + warnings and errors in the status line, prefixed by + |airline#extensions#ale#error_symbol| and + |airline#extensions#ale#warning_symbol|. + + *ale-options.cache_executable_check_failures* + *g:ale_cache_executable_check_failures* +cache_executable_check_failures +g:ale_cache_executable_check_failures + Type: |Boolean| or |Number| + Default: `nil` + + When set to `true` or `1`, ALE will cache failing executable checks for + linters. By default, only executable checks which succeed will be cached. + + When this option is set to `true` or `1`, Vim will have to be restarted + after new executables are installed for ALE to be able to run linters for + those executables. + + *ale-options.change_sign_column_color* + *g:ale_change_sign_column_color* +change_sign_column_color +g:ale_change_sign_column_color + Type: |Boolean| or |Number| + Default: `false` + + When set to `true` or `1`, this option will set different highlights for the + sign column itself when ALE reports problems with a file. This option can be + combined with |g:ale_sign_column_always|. + + ALE uses the following highlight groups for highlighting the sign column: + + `:ALESignColumnWithErrors` - Links to `Error` by default. + `:ALESignColumnWithoutErrors` - Uses the value for `SignColumn` by default. + + The sign column color can only be changed globally in Vim. The sign column + might produce unexpected results if editing different files in split + windows. + + *ale-options.close_preview_on_insert* + *g:ale_close_preview_on_insert* +close_preview_on_insert +g:ale_close_preview_on_insert + Type: |Boolean| or |Number| + Default: `false` + + When this option is set to `true` or `1`, ALE's |preview-window| will be + automatically closed upon entering Insert Mode. This option can be used in + combination with |g:ale_cursor_detail| for automatically displaying the + preview window on problem lines, and automatically closing it again when + editing text. + + This setting must be set to `true` or `1` before ALE is loaded for this + behavior to be enabled. See |ale-lint-settings-on-startup|. + + *ale-options.command_wrapper* + *g:ale_command_wrapper* + *b:ale_command_wrapper* +command_wrapper +g:ale_command_wrapper + Type: |String| + Default: `''` + + An option for wrapping all commands that ALE runs, for linters, fixers, + and LSP commands. This option can be set globally, or for specific buffers. + + This option can be used to apply nice to all commands. For example: > + + " Prefix all commands with nice. + let g:ale_command_wrapper = 'nice -n5' +< + Use the `:ALEInfo` command to view the commands that are run. All of the + arguments for commands will be put on the end of the wrapped command by + default. A `%*` marker can be used to spread the arguments in the wrapped + command. > + + " Has the same effect as the above. + let g:ale_command_wrapper = 'nice -n5 %*' +< + For passing all of the arguments for a command as one argument to a wrapper, + `%@` can be used instead. > + + " Will result in say: /bin/bash -c 'other-wrapper -c "some command" -x' + let g:ale_command_wrapper = 'other-wrapper -c %@ -x' +< + For commands including `&&` or `;`, only the last command in the list will + be passed to the wrapper. `&&` is most commonly used in ALE to change the + working directory before running a command. + + *ale-options.completion_delay* + *g:ale_completion_delay* +completion_delay +g:ale_completion_delay + Type: |Number| + Default: `100` + + The number of milliseconds before ALE will send a request to a language + server for completions after you have finished typing. + + See |ale-completion| + + *ale-options.completion_enabled* + *g:ale_completion_enabled* + *b:ale_completion_enabled* +completion_enabled +g:ale_completion_enabled + Type: |Boolean| or |Number| + Default: `false` + + When this option is set to `true` or `1`, completion support will be enabled. + + This setting must be set to `true` or `1` before ALE is loaded for this behavior + to be enabled. + + This setting should not be enabled if you wish to use ALE as a completion + source for other completion plugins. + + ALE automatic completion will not work when 'paste' is active. Only set + 'paste' when you are copy and pasting text into your buffers. + + A buffer-local version of this setting `b:ale_completion_enabled` can be set + to `0` to disable ALE's automatic completion support for a single buffer. + ALE's completion support must be enabled globally to be enabled locally. + + See |ale-completion| + + *ale-options.completion_tsserver_remove_warnings* + *g:ale_completion_tsserver_remove_warnings* +completion_tsserver_remove_warnings +g:ale_completion_tsserver_remove_warnings + Type: |Boolean| or |Number| + Default: `false` + + When this option is set to `false` or `0`, ALE will return all completion + items from its built in completion engine, including those that are a + warning. Warnings can be excluded from completed items by setting it to + `true` or `1`. + + *ale-options.completion_autoimport* + *g:ale_completion_autoimport* +completion_autoimport +g:ale_completion_autoimport + Type: |Boolean| or |Number| + Default: `true` + + When this option is set to `1`, ALE will try to automatically import + completion results from external modules. It can be disabled by setting it + to `0`. Some LSP servers include auto imports on every completion item so + disabling automatic imports may drop some or all completion items returned + by it (e.g. eclipselsp). + + *ale-options.completion_excluded_words* + *g:ale_completion_excluded_words* + *b:ale_completion_excluded_words* +completion_excluded_words +g:ale_completion_excluded_words + Type: |List| + Default: `[]` + + This option can be set to a list of |String| values for "words" to exclude + from completion results, as in the words for |complete-items|. The strings + will be matched exactly in a case-sensitive manner. (|==#|) + + This setting can be configured in ftplugin files with buffer variables, so + that different lists can be used for different filetypes. For example: > + + " In ~/.vim/ftplugin/typescript.vim + + " Don't suggest `it` or `describe` so we can use snippets for those words. + let b:ale_completion_excluded_words = ['it', 'describe'] +< + *ale-options.completion_symbols* + *g:ale_completion_symbols* +completion_symbols +g:ale_completion_symbols + Type: |Dictionary| + Default: See `autoload/ale/completion.vim` + + A mapping from completion types to symbols for completions. See + |ale-symbols| for more information. + + By default, this mapping only uses built in Vim completion kinds, but it can + be updated to use any Unicode character for the completion kind. For + example: > + let g:ale_completion_symbols = { + \ 'text': '', + \ 'method': '', + \ 'function': '', + \ 'constructor': '', + \ 'field': '', + \ 'variable': '', + \ 'class': '', + \ 'interface': '', + \ 'module': '', + \ 'property': '', + \ 'unit': 'v', + \ 'value': 'v', + \ 'enum': 't', + \ 'keyword': 'v', + \ 'snippet': 'v', + \ 'color': 'v', + \ 'file': 'v', + \ 'reference': 'v', + \ 'folder': 'v', + \ 'enum_member': 'm', + \ 'constant': 'm', + \ 'struct': 't', + \ 'event': 'v', + \ 'operator': 'f', + \ 'type_parameter': 'p', + \ '': 'v' + \ }) +< + *ale-options.completion_max_suggestions* + *g:ale_completion_max_suggestions* +completion_max_suggestions +g:ale_completion_max_suggestions + Type: |Number| + Default: `50` + + The maximum number of items ALE will suggest in completion menus for + automatic completion. + + Setting this number higher will require more processing time, and may + suggest too much noise. Setting this number lower will require less + processing time, but some suggestions will not be included, so you might not + be able to see the suggestions you want. + + Adjust this option as needed, depending on the complexity of your codebase + and your available processing power. + + *ale-options.cursor_detail* + *g:ale_cursor_detail* +cursor_detail +g:ale_cursor_detail + Type: |Number| + Default: `false` + + When this option is set to `true` or `1`, ALE's |preview-window| will be + automatically opened when the cursor moves onto lines with problems. ALE + will search for problems using the same logic that |g:ale_echo_cursor| uses. + The preview window will be closed automatically when you move away from the + line. + + Messages are only displayed after a short delay. See |g:ale_echo_delay|. + + The preview window is opened without stealing focus, which means your cursor + will stay in the same buffer as it currently is. + + The preview window can be closed automatically upon entering Insert mode + by setting |g:ale_close_preview_on_insert| to `true` or `1`. + + Either this setting or |g:ale_echo_cursor| must be set to `true` or `1` + before ALE is loaded for messages to be displayed. + See |ale-lint-settings-on-startup|. + + *ale-options.default_navigation* + *g:ale_default_navigation* + *b:ale_default_navigation* +default_navigation +g:ale_default_navigation + Type: |String| + Default: `'buffer'` + + The default method for navigating away from the current buffer to another + buffer, such as for `:ALEFindReferences` or `:ALEGoToDefinition`. + + *ale-options.detail_to_floating_preview* + *g:ale_detail_to_floating_preview* + *b:ale_detail_to_floating_preview* +detail_to_floating_preview +g:ale_detail_to_floating_preview + Type: |Number| + Default: `0` + + When this option is set to `1`, Neovim or Vim with |popupwin| will use a + floating window for ALEDetail output. + + *ale-options.disable_lsp* + *g:ale_disable_lsp* + *b:ale_disable_lsp* +disable_lsp +g:ale_disable_lsp + Type: |Boolean| OR |Number| OR |String| + Default: `'auto'` + + When this option is set to `'auto'`, ALE will automatically disable linters + that it detects as having already been configured with the `nvim-lspconfig` + plugin. When this option is set to `true` or `1`, ALE ignores all linters + powered by LSP, and also `tsserver`. + + Any linters that are disabled will also not be usable for LSP functionality + other than just linting. + + Please see also |ale-lsp|. + + *ale-options.echo_cursor* + *g:ale_echo_cursor* +echo_cursor +g:ale_echo_cursor + Type: |Number| + Default: `1` + + When this option is set to `1`, a truncated message will be echoed when a + cursor is near a warning or error. ALE will attempt to find the warning or + error at a column nearest to the cursor when the cursor is resting on a line + which contains a warning or error. This option can be set to `0` to disable + this behavior. + + Messages are only displayed after a short delay. See |g:ale_echo_delay|. + + The format of the message can be customized with |g:ale_echo_msg_format|. + + Either this setting or |g:ale_cursor_detail| must be set to `true` or `1` + before ALE is loaded for messages to be displayed. See + |ale-lint-settings-on-startup|. + + *ale-options.echo_delay* + *g:ale_echo_delay* + *b:ale_echo_delay* +echo_delay +g:ale_echo_delay + Type: |Number| + Default: `10` + + Given any integer, this option controls the number of milliseconds before + ALE will echo or preview a message for a problem near the cursor. + + The value can be increased to decrease the amount of processing ALE will do + for files displaying a large number of problems. + + *ale-options.echo_msg_error_str* + *g:ale_echo_msg_error_str* +echo_msg_error_str +g:ale_echo_msg_error_str + Type: |String| + Default: `'Error'` + + The string used for `%severity%` for errors. See |g:ale_echo_msg_format| + + *ale-options.echo_msg_format* + *g:ale_echo_msg_format* + *b:ale_echo_msg_format* +echo_msg_format +g:ale_echo_msg_format + Type: |String| + Default: `'%code: %%s'` + + This variable defines a message format for echoed messages. The following + sequences of characters will be replaced. + + `%s` - replaced with the text for the problem + `%...code...% `- replaced with the error code + `%linter%` - replaced with the name of the linter + `%severity%` - replaced with the severity of the problem (e.g. `Error`) + `%type%` - replaced with the type of the problem (e.g. `E`) + + The strings for `%severity%` can be configured with the following options. + + |g:ale_echo_msg_error_str| - Defaults to `'Error'` + |g:ale_echo_msg_info_str| - Defaults to `'Info'` + |g:ale_echo_msg_warning_str| - Defaults to `'Warning'` + + `%code%` is replaced with the error code, and replaced with an empty string + when there is no error code. Any extra characters between the percent signs + will be printed when an error code is present. For example, a message like + `(error code): message` will be printed for `'%(code): %%s'` and simply the + message will be printed when there is no code. + + |g:ale_echo_cursor| needs to be set to 1 for messages to be displayed. + + The echo message format can also be configured separately for each buffer, + so different formats can be used for different languages. (Say in ftplugin + files.) + + *ale-options.echo_msg_info_str* + *g:ale_echo_msg_info_str* +echo_msg_info_str +g:ale_echo_msg_info_str + Type: |String| + Default: `'Info'` + + The string used for `%severity%` for info. See |g:ale_echo_msg_format| + + *ale-options.echo_msg_log_str* + *g:ale_echo_msg_log_str* +echo_msg_log_str +g:ale_echo_msg_log_str + Type: |String| + Default: `'Log'` + + The string used for `%severity%` for log, used only for handling LSP show + message requests. See |g:ale_lsp_show_message_format| + + *ale-options.echo_msg_warning_str* + *g:ale_echo_msg_warning_str* +echo_msg_warning_str +g:ale_echo_msg_warning_str + Type: |String| + Default: `'Warning'` + + The string used for `%severity%` for warnings. See |g:ale_echo_msg_format| + + *ale-options.enabled* + *g:ale_enabled* + *b:ale_enabled* +enabled +g:ale_enabled + Type: |Number| + Default: `1` + + When set to `0`, this option will completely disable ALE, such that no + error checking will be performed, etc. ALE can be toggled on and off with + the `:ALEToggle` command, which changes this option. + + ALE can be disabled in each buffer by setting `let b:ale_enabled = 0` + Disabling ALE based on filename patterns can be accomplished by setting + a regular expression for |g:ale_pattern_options|. For example: > + + " Disable linting for all minified JS files. + let g:ale_pattern_options = {'\.min.js$': {'ale_enabled': 0}} +< + See |g:ale_pattern_options| for more information on that option. + + *ale-options.exclude_highlights* + *g:ale_exclude_highlights* + *b:ale_exclude_highlights* +exclude_highlights +g:ale_exclude_highlights + Type: |List| + Default: `[]` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + A list of regular expressions for matching against highlight messages to + remove. For example: > + + " Do not highlight messages matching strings like these. + let b:ale_exclude_highlights = ['line too long', 'foo.*bar'] +< + See also: |g:ale_set_highlights| + + *ale-options.fixers* + *g:ale_fixers* + *b:ale_fixers* +fixers +g:ale_fixers + Type: |Dictionary| + Default: `{}` + + A mapping from filetypes to |List| values for functions for fixing errors. + See |ale-fix| for more information. + + This variable can be overridden with variables in each buffer. + `b:ale_fixers` can be set to a |List| of callbacks instead, which can be + more convenient. + + A special `'*'` key be used as a wildcard filetype for configuring fixers + for every other type of file. For example: > + + " Fix Python files with 'bar'. + " Don't fix 'html' files. + " Fix everything else with 'foo'. + let g:ale_fixers = {'python': ['bar'], 'html': [], '*': ['foo']} +< + *ale-options.fix_on_save* + *g:ale_fix_on_save* + *b:ale_fix_on_save* +fix_on_save +g:ale_fix_on_save + Type: |Number| + Default: `0` + + When set to 1, ALE will fix files when they are saved. + + If |g:ale_lint_on_save| is set to 1, files will be checked with linters + after files are fixed, only when the buffer is open, or re-opened. Changes + to the file will be saved to the file on disk. + + Files will not be fixed on `:wq`, so you should check your code before + closing a buffer. + + Fixing files can be disabled or enabled for individual buffers by setting + `b:ale_fix_on_save` to `0` or `1`. + + Some fixers can be excluded from being run automatically when you save files + with the |g:ale_fix_on_save_ignore| setting. + + *ale-options.fix_on_save_ignore* + *g:ale_fix_on_save_ignore* + *b:ale_fix_on_save_ignore* +fix_on_save_ignore +g:ale_fix_on_save_ignore + Type: |Dictionary| or |List| + Default: `{}` + + Given a |Dictionary| mapping filetypes to |Lists| of fixers to ignore, or + just a |List| of fixers to ignore, exclude those fixers from being run + automatically when files are saved. + + You can disable some fixers in your ftplugin file: > + + " Disable fixers 'b' and 'c' when fixing on safe for this buffer. + let b:ale_fix_on_save_ignore = ['b', 'c'] + " Alternatively, define ignore lists for different filetypes. + let b:ale_fix_on_save_ignore = {'foo': ['b'], 'bar': ['c']} +< + You can disable some fixers globally per filetype like so: > + + let g:ale_fixers = {'foo': ['a', 'b'], 'bar': ['c', 'd']} + let g:ale_fix_on_save = 1 + " For filetype `foo.bar`, only fixers 'b' and 'd' will be run on save. + let g:ale_fix_on_save_ignore = {'foo': ['a'], 'bar': ['c']} + " Alternatively, disable these fixers on save for all filetypes. + let g:ale_fix_on_save_ignore = ['a', 'c'] +< + You can ignore fixers based on matching |Funcref| values too: > + + let g:AddBar = {buffer, lines -> lines + ['bar']} + let g:ale_fixers = {'foo': g:AddBar} + " The lambda fixer will be ignored, as it will be found in the ignore list. + let g:ale_fix_on_save_ignore = [g:AddBar] +< + *ale-options.floating_preview* + *g:ale_floating_preview* +floating_preview +g:ale_floating_preview + Type: |Number| + Default: `0` + + When set to `1`, Neovim or Vim with |popupwin| will use a floating window + for ale's preview window. + This is equivalent to setting |g:ale_hover_to_floating_preview| and + |g:ale_detail_to_floating_preview| to `1`. + + *ale-options.floating_preview_popup_opts* + *g:ale_floating_preview_popup_opts* +floating_preview_popup_opts +g:ale_floating_preview_popup_opts + Type: |String| or |Dictionary| + Default: `''` + + Either a dictionary of options or the string name of a function that returns + a dictionary of options. This will be used as an argument to |popup_create| + for Vim users or |nvim_open_win| for NeoVim users. In either case, the + resulting dictionary is merged with ALE defaults rather than explicitly + overriding them. This only takes effect if |g:ale_floating_preview| is + enabled. + + NOTE: for Vim users see |popup_create-arguments|, for NeoVim users see + |nvim_open_win| for argument details + + For example, to enhance popups with a title: > + + function! CustomOpts() abort + let [l:info, l:loc] = ale#util#FindItemAtCursor(bufnr('')) + return {'title': ' ALE: ' . (l:loc.linter_name) . ' '} + endfunction + + let g:ale_floating_preview_popup_opts = 'g:CustomOpts' +< + *ale-options.floating_window_border* + *g:ale_floating_window_border* +floating_window_border +g:ale_floating_window_border + Type: |List| + Default: `['|', '-', '+', '+', '+', '+', '|', '-']` + + When set to `[]`, window borders are disabled. The elements in the list set + the characters for the left side, top, top-left corner, top-right + corner, bottom-right corner, bottom-left corner, right side, and bottom of + the floating window, respectively. + + If the terminal supports Unicode, you might try setting the value to + ` ['│', '─', '╭', '╮', '╯', '╰', '│', '─']`, to make it look nicer. + + NOTE: For compatibility with previous versions, if the list does not have + elements for the right side and bottom, the left side and top will be used + instead. + + *ale-options.history_enabled* + *g:ale_history_enabled* +history_enabled +g:ale_history_enabled + Type: |Number| + Default: `1` + + When set to `1`, ALE will remember the last few commands which were run + for every buffer which is open. This information can be viewed with the + `:ALEInfo` command. The size of the buffer can be controlled with the + |g:ale_max_buffer_history_size| option. + + This option can be disabled if storing a command history is not desired. + + *ale-options.history_log_output* + *g:ale_history_log_output* +history_log_output +g:ale_history_log_output + Type: |Number| + Default: `1` + + When set to `1`, ALE will store the output of commands which have completed + successfully in the command history, and the output will be displayed when + using `:ALEInfo`. + + |g:ale_history_enabled| must be set to `1` for this output to be stored or + printed. + + Some memory will be consumed by this option. It is very useful for figuring + out what went wrong with linters, and for bug reports. Turn this option off + if you want to save on some memory usage. + + *ale-options.hover_cursor* + *g:ale_hover_cursor* +hover_cursor +g:ale_hover_cursor + Type: |Number| + Default: `1` + + If set to `1`, ALE will show truncated information in the echo line about + the symbol at the cursor automatically when the |CursorHold| event is fired. + The delay before requesting hover information is based on 'updatetime', as + with all |CursorHold| events. + + If there's a problem on the line where the cursor is resting, ALE will not + show any hover information. + + See |ale-hover| for more information on hover information. + + This setting must be set to `1` before ALE is loaded for this behavior + to be enabled. See |ale-lint-settings-on-startup|. + + *ale-options.hover_to_preview* + *g:ale_hover_to_preview* + *b:ale_hover_to_preview* +hover_to_preview +g:ale_hover_to_preview + Type: |Number| + Default: `0` + + If set to `1`, hover messages will be displayed in the preview window, + instead of in balloons or the message line. + + *ale-options.hover_to_floating_preview* + *g:ale_hover_to_floating_preview* + *b:ale_hover_to_floating_preview* +hover_to_floating_preview +g:ale_hover_to_floating_preview + Type: |Number| + Default: `0` + + If set to `1`, Neovim or Vim with |popupwin| will use floating windows for + hover messages. + + *ale-options.info_default_mode* + *g:ale_info_default_mode* + *b:ale_info_default_mode* +info_default_mode +g:ale_info_default_mode + Type: |String| + Default: `'preview'` + + Changes the default mode used for `:ALEInfo`. See documentation for `:ALEInfo` + for more information. + + *ale-options.keep_list_window_open* + *g:ale_keep_list_window_open* + *b:ale_keep_list_window_open* +keep_list_window_open +g:ale_keep_list_window_open + Type: |Number| + Default: `0` + + When set to `1`, this option will keep the loclist or quickfix windows event + after all warnings/errors have been removed for files. By default the + loclist or quickfix windows will be closed automatically when there are no + warnings or errors. + + See |g:ale_open_list| + + *ale-options.list_window_size* + *g:ale_list_window_size* + *b:ale_list_window_size* +list_window_size +g:ale_list_window_size + Type: |Number| + Default: `10` + + This number configures the number of lines to set for the height of windows + opened automatically for ALE problems. The default of `10` matches the Vim + default height. + + See |g:ale_open_list| for information on automatically opening windows + for quickfix or the loclist. + + *ale-options.lint_delay* + *g:ale_lint_delay* + *b:ale_lint_delay* +lint_delay +g:ale_lint_delay + Type: |Number| + Default: `200` + + This variable controls the milliseconds delay after which the linters will + be run after text is changed. This option is only meaningful with the + |g:ale_lint_on_text_changed| variable set to `always`, `insert`, or `normal`. + + A buffer-local option, `b:ale_lint_delay`, can be set to change the delay + for different buffers, such as in |ftplugin| files. + + *ale-options.lint_on_enter* + *g:ale_lint_on_enter* +lint_on_enter +g:ale_lint_on_enter + Type: |Number| + Default: `1` + + When this option is set to `1`, the |BufWinEnter| event will be used to + apply linters when buffers are first opened. If this is not desired, this + variable can be set to `0` in your vimrc file to disable this behavior. + + The |FileChangedShellPost| and |BufEnter| events will be used to check if + files have been changed outside of Vim. If a file is changed outside of + Vim, it will be checked when it is next opened. + + You should set this setting once before ALE is loaded, and restart Vim if + you want to change your preferences. See |ale-lint-settings-on-startup|. + + *ale-options.lint_on_filetype_changed* + *g:ale_lint_on_filetype_changed* +lint_on_filetype_changed +g:ale_lint_on_filetype_changed + Type: |Number| + Default: `1` + + This option will cause ALE to run when the filetype for a file is changed + after a buffer has first been loaded. A short delay will be used before + linting will be done, so the filetype can be changed quickly several times + in a row, but resulting in only one lint cycle. + + You should set this setting once before ALE is loaded, and restart Vim if + you want to change your preferences. See |ale-lint-settings-on-startup|. + + *ale-options.lint_on_save* + *g:ale_lint_on_save* +lint_on_save +g:ale_lint_on_save + Type: |Number| + Default: `1` + + This option will make ALE run the linters whenever a file is saved when it + it set to `1` in your vimrc file. This option can be used in combination + with the |g:ale_lint_on_enter| and |g:ale_lint_on_text_changed| options to + make ALE only check files after that have been saved, if that is what is + desired. + + *ale-options.lint_on_text_changed* + *g:ale_lint_on_text_changed* +lint_on_text_changed +g:ale_lint_on_text_changed + Type: |Boolean| or |Number| or |String| + Default: `'normal'` + + This option controls how ALE will check your files as you make changes. + The following values can be used. + + `'always'`, `'1'`, `true`, or `1` - Check buffers on |TextChanged| or |TextChangedI|. + `'normal'` - Check buffers only on |TextChanged|. + `'insert'` - Check buffers only on |TextChangedI|. + `'never'`, `'0'`, `false`, or `0` - Never check buffers on changes. + + ALE will check buffers after a short delay, with a timer which resets on + each change. The delay can be configured by adjusting the |g:ale_lint_delay| + variable. + *ale-linting-interrupts-mapping* + + Due to a bug in Vim, ALE can interrupt mappings with pending key presses, + per |timeoutlen|. If this happens, follow the advice for enabling + |g:ale_lint_on_insert_leave| below, and set this option to `'normal'`, or + disable it entirely. + + You should set this setting once before ALE is loaded, and restart Vim if + you want to change your preferences. See |ale-lint-settings-on-startup|. + + *ale-options.lint_on_insert_leave* + *g:ale_lint_on_insert_leave* + *b:ale_lint_on_insert_leave* +lint_on_insert_leave +g:ale_lint_on_insert_leave + Type: |Boolean| or |Number| + Default: `true` + + When set to `1` in your vimrc file, this option will cause ALE to run + linters when you leave insert mode. + + ALE will not lint files when you escape insert mode with |CTRL-C| by + default. You can make ALE lint files with this option when you use |CTRL-C| + with the following mapping. > + + " Make using Ctrl+C do the same as Escape, to trigger autocmd commands + inoremap +< + A buffer-local version of this setting `b:ale_lint_on_insert_leave` can be + set to `0` to disable linting when leaving insert mode. The setting must + be enabled globally to be enabled locally. + + You should set this setting once before ALE is loaded, and restart Vim if + you want to change your preferences. See |ale-lint-settings-on-startup|. + + *ale-options.linter_aliases* + *g:ale_linter_aliases* + *b:ale_linter_aliases* +linter_aliases +g:ale_linter_aliases + Type: |Dictionary| or |List| or |String| + Default: `{}` + + The |g:ale_linter_aliases| option can be used to set aliases from one + filetype to another. A given filetype can be mapped to use the linters + run for another given filetype. + + This |Dictionary| will be merged with a default dictionary containing the + following values: > + + { + \ 'Dockerfile': 'dockerfile', + \ 'csh': 'sh', + \ 'javascriptreact': ['javascript', 'jsx'], + \ 'plaintex': 'tex', + \ 'ps1': 'powershell', + \ 'rmarkdown': 'r', + \ 'rmd': 'r', + \ 'systemverilog': 'verilog', + \ 'typescriptreact': ['typescript', 'tsx'], + \ 'vader': ['vim', 'vader'], + \ 'verilog_systemverilog': ['verilog_systemverilog', 'verilog'], + \ 'vimwiki': 'markdown', + \ 'vue': ['vue', 'javascript'], + \ 'xsd': ['xsd', 'xml'], + \ 'xslt': ['xslt', 'xml'], + \ 'zsh': 'sh', + \} +< + For example, if you wish to map a new filetype `'foobar'` to run the `'php'` + linters, you could set the following: > + + let g:ale_linter_aliases = {'foobar': 'php'} +< + Or in Lua: > + + require("ale").setup({linter_aliases = {foobar = "php"}}) +< + When combined with the |g:ale_linters| option, the original filetype + (`'foobar'`) will be used for determining which linters to run, + not the aliased type (`'php'`). This allows an aliased type to run a + different set of linters from the type it is being mapped to. + + Passing a list of filetypes is also supported. Say you want to lint + javascript and css embedded in HTML (using linters that support that). + You could alias `html` like so: > + + `let g:ale_linter_aliases = {'html': ['html', 'javascript', 'css']}` +< + Or in Lua: > + + require("ale").setup({linter_aliases = {html = {"html", "javascript", "css"}}) +< + Note that `html` itself was included as an alias. That is because aliases + will override the original linters for the aliased filetype. + + Linter aliases can be configured in each buffer with buffer-local variables. + ALE will first look for aliases for filetypes in the `b:ale_linter_aliases` + variable, then `g:ale_linter_aliases`, and then a default Dictionary. + + `b:ale_linter_aliases` can be set to a |List| or a |String|, to tell ALE to + load the linters for specific filetypes for a given buffer. > + + let b:ale_linter_aliases = ['html', 'javascript', 'css'] + " OR, Alias a filetype to only a single filetype with a String. + let b:ale_linter_aliases = 'javascript' +< + Or in Lua: > + + require("ale").setup.buffer({linter_aliases = {"html", "javascript", "css"}}) + -- OR, Alias a filetype to only a single filetype with a String. + require("ale").setup.buffer({linter_aliases = "javascript"}) +< + No linters will be loaded when the buffer's filetype is empty. + + *ale-options.filename_mappings* + *g:ale_filename_mappings* + *b:ale_filename_mappings* +filename_mappings +g:ale_filename_mappings + Type: |Dictionary| or |List| + Default: `{}` + + Either a |Dictionary| mapping a linter or fixer name, as displayed in + `:ALEInfo`, to a |List| of two-item |List|s for filename mappings, or just a + |List| of two-item |List|s. When given some paths to files, the value of + this setting will be used to convert filenames on a local file system to + filenames on some remote file system, such as paths in a Docker image, + virtual machine, or network drive. + + For example: > + + let g:ale_filename_mappings = { + \ 'pylint': [ + \ ['/home/john/proj', '/data'], + \ ], + \} +< + Or in Lua: > + + require("ale").setup({ + filename_mappings = { + pylint = { + {"/home/john/proj", "/data"}, + }, + }, + }) +< + With the above configuration, a filename such as `/home/john/proj/foo.py` + will be provided to the linter/fixer as `/data/foo.py`, and paths parsed + from linter results such as `/data/foo.py` will be converted back to + `/home/john/proj/foo.py`. + + You can use `*` as to apply a |List| of filename mappings to all other + linters or fixers not otherwise matched. > + + " Use one List of paths for pylint. + " Use another List of paths for everything else. + let g:ale_filename_mappings = { + \ 'pylint': [ + \ ['/home/john/proj', '/data'], + \ ], + \ '*': [ + \ ['/home/john/proj', '/other-data'], + \ ], + \} +< + If you just want every single linter or fixer to use the same filename + mapping, you can just use a |List|. > + + " Same as above, but for ALL linters and fixers. + let g:ale_filename_mappings = [ + \ ['/home/john/proj', '/data'], + \] +< + Or in Lua: > + + require("ale").setup({ + filename_mappings = { + {"/home/john/proj", "/data"}, + }, + }) +< + You can provide many such filename paths for multiple projects. Paths are + matched by checking if the start of a file path matches the given strings, + in a case-sensitive manner. Earlier entries in the |List| will be tried + before later entries when mapping to a given file system. + + Buffer-local options can be set to the same values to override the global + options, such as in |ftplugin| files. + + NOTE: Only fixers registered with a short name can support filename mapping + by their fixer names. See |ale-fix|. Filename mappings set for all tools by + using only a |List| for the setting will also be applied to fixers not in + the registry. + + NOTE: In order for this filename mapping to work correctly, linters and + fixers must exclusively determine paths to files to lint or fix via ALE + command formatting as per |ale-command-format-strings|, and paths parsed + from linter files must be provided in `filename` keys if a linter returns + results for more than one file at a time, as per |ale-loclist-format|. If + you discover a linter or fixer which does not behave properly, please report + it as an issue. + + If you are running a linter or fixer through Docker or another remote file + system, you may have to mount your temporary directory, which you can + discover with the following command: > + + :echo fnamemodify(tempname(), ':h:h') +< + You should provide a mapping from this temporary directory to whatever you + mount this directory to in Docker, or whatever remote file system you are + working with. + + You can inspect the filename mappings ALE will use with the + |ale#GetFilenameMappings()| function. + + *ale-options.linters* + *g:ale_linters* + *b:ale_linters* +linters +g:ale_linters + Type: |Dictionary| or |List| + Default: `{}` + + The |g:ale_linters| option sets a |Dictionary| mapping a filetype to a + |List| of linter programs to be run when checking particular filetypes. + + This |Dictionary| will be merged with a default dictionary containing the + following values: > + + { + \ 'apkbuild': ['apkbuild_lint', 'secfixes_check'], + \ 'csh': ['shell'], + \ 'elixir': ['credo', 'dialyxir', 'dogma'], + \ 'go': ['gofmt', 'golangci-lint', 'gopls', 'govet'], + \ 'groovy': ['npm-groovy-lint'], + \ 'hack': ['hack'], + \ 'help': [], + \ 'inko': ['inko'], + \ 'json': ['jsonlint', 'spectral'], + \ 'json': ['jsonlint', 'spectral', 'vscodejson'], + \ 'json5': [], + \ 'jsonc': [], + \ 'perl': ['perlcritic'], + \ 'perl6': [], + \ 'python': ['flake8', 'mypy', 'pylint', 'pyright', 'ruff'], + \ 'rust': ['analyzer', 'cargo'], + \ 'spec': [], + \ 'text': [], + \ 'vader': ['vimls'], + \ 'vue': ['eslint', 'vls'], + \ 'zsh': ['shell'], + \ 'v': ['v'], + \ 'yaml': ['actionlint', 'spectral', 'yaml-language-server', 'yamllint'], + \} +< + This option can be used to enable only a particular set of linters for a + file. For example, you can enable only `eslint` for JavaScript files: > + + let g:ale_linters = {'javascript': ['eslint']} +< + Or in Lua: > + + require("ale").setup({linters = {javascript = {"eslint"}}}) +< + If you want to disable all linters for a particular filetype, you can pass + an empty list of linters as the value: > + + let g:ale_linters = {'javascript': []} +< + Or in Lua: > + + require("ale").setup({linters = {javascript = {}}}) +< + All linters will be run for unspecified filetypes. All available linters can + be enabled explicitly for a given filetype by passing the string `'all'`, + instead of a List. > + + let g:ale_linters = {'c': 'all'} +< + Or in Lua: > + + require("ale").setup({linters = {c = "all"}}) +< + Linters can be configured in each buffer with buffer-local variables. ALE + will first look for linters for filetypes in the `b:ale_linters` variable, + then `g:ale_linters`, and then the default Dictionary mentioned above. + + `b:ale_linters` can be set to a List, or the string `'all'`. When linters + for two different filetypes share the same name, the first linter loaded + will be used. Any ambiguity can be resolved by using a Dictionary specifying + which linter to run for which filetype instead. > + + " Use ESLint for the buffer if the filetype includes 'javascript'. + let b:ale_linters = {'javascript': ['eslint'], 'html': ['tidy']} + " Use a List for the same setting. This will work in most cases. + let b:ale_linters = ['eslint', 'tidy'] + " Disable all linters for the buffer. + let b:ale_linters = [] + " Explicitly enable all available linters for the filetype. + let b:ale_linters = 'all' +< + In Lua: > + + require("ale").setup.buffer({ + linters = {javascript = {"eslint"}, html = {"tidy"}}, + }) + require("ale").setup.buffer({linters = {"eslint", "tidy"}}) + require("ale").setup.buffer({linters = {}}) + require("ale").setup.buffer({linters = "all"}) +< + ALE can be configured to disable all linters unless otherwise specified with + `g:ale_enabled` or `b:ale_enabled` with the option |g:ale_linters_explicit|. + + *ale-options.linters_explicit* + *g:ale_linters_explicit* +linters_explicit +g:ale_linters_explicit + Type: |Boolean| or |Number| + Default: `false` + + When set to `true` or `1`, only the linters from |g:ale_linters| and + |b:ale_linters| will be enabled. The default behavior for ALE is to enable + as many linters as possible, unless otherwise specified. + + *ale-options.linters_ignore* + *g:ale_linters_ignore* + *b:ale_linters_ignore* +linters_ignore +g:ale_linters_ignore + Type: |Dictionary| or |List| + Default: `{}` + + Linters to ignore. Commands for ignored linters will not be run, and + diagnostics for LSP linters will be ignored. (See |ale-lsp|) + + This setting can be set to a |Dictionary| mapping filetypes to linter names, + just like |g:ale_linters|, to list linters to ignore. Ignore lists will be + applied after everything else. > + + " Select flake8 and pylint, and ignore pylint, so only flake8 is run. + let g:ale_linters = {'python': ['flake8', 'pylint']} + let g:ale_linters_ignore = {'python': ['pylint']} +< + Or in Lua: > + + require("ale").setup({ + linters = {"python": {"flake8", "pylint"}}, + linters_ignore = {"python": {"pylint"}}, + }) +< + This setting can be set to simply a |List| of linter names, which is + especially more convenient when using the setting in ftplugin files for + particular buffers. > + + " The same as above, in a ftplugin/python.vim. + let b:ale_linters = ['flake8', 'pylint'] + let b:ale_linters_ignore = ['pylint'] +< + Or in Lua: > + + require("ale").setup.buffer({ + linters = {"flake8", "pylint"}, + linters_ignore = {"pylint"}, + }) +< + *ale-options.list_vertical* + *g:ale_list_vertical* + *b:ale_list_vertical* +list_vertical +g:ale_list_vertical + Type: |Boolean| or |Number| + Default: `false` + + When set to `true` or `1`, this will cause ALE to open any windows (loclist + or quickfix) vertically instead of horizontally (|vert| |lopen|) or (|vert| + |copen|) + + *ale-options.loclist_msg_format* + *g:ale_loclist_msg_format* + *b:ale_loclist_msg_format* +loclist_msg_format +g:ale_loclist_msg_format + Type: |String| + Default: `g:ale_echo_msg_format` (`echo_msg_format`) + + This option is the same as |g:ale_echo_msg_format|, but for formatting the + message used for the loclist and the quickfix list. + + The strings for configuring `%severity%` are also used for this option. + + *ale-options.lsp_show_message_format* + *g:ale_lsp_show_message_format* +lsp_show_message_format +g:ale_lsp_show_message_format + Type: |String| + Default: `'%severity%:%linter%: %s'` + + This variable defines the format that messages received from an LSP will + have when echoed. The following sequences of characters will be replaced. + + `%s` - replaced with the message text + `%linter%` - replaced with the name of the linter + `%severity%` - replaced with the severity of the message + + The strings for `%severity%` levels "error", "info" and "warning" are shared + with |g:ale_echo_msg_format|. Severity "log" is unique to + |g:ale_lsp_show_message_format| and it can be configured via + + |g:ale_echo_msg_log_str| - Defaults to `'Log'` + + Please note that |g:ale_lsp_show_message_format| *can not* be configured + separately for each buffer like |g:ale_echo_msg_format| can. + + *ale-options.lsp_show_message_severity* + *g:ale_lsp_show_message_severity* +lsp_show_message_severity +g:ale_lsp_show_message_severity + Type: |String| + Default: `'error'` + + This variable defines the minimum severity level an LSP message needs to be + displayed. Messages below this level are discarded; please note that + messages with `Log` severity level are always discarded. + + Possible values follow the LSP spec `MessageType` definition: + + `'error'` - Displays only errors. + `'warning'` - Displays errors and warnings. + `'information'` - Displays errors, warnings and infos + `'log'` - Same as `'information'` + `'disabled'` - Doesn't display any information at all. + + *ale-options.lsp_suggestions* + *g:ale_lsp_suggestions* +lsp_suggestions +g:ale_lsp_suggestions + Type: |Boolean| or |Number| + Default: `false` + + If set to `true` or ``1`, show suggestions from LSP servers or tsserver, in + addition to warnings and errors. + + *ale-options.max_buffer_history_size* + *g:ale_max_buffer_history_size* +max_buffer_history_size +g:ale_max_buffer_history_size + Type: |Number| + Default: `20` + + This setting controls the maximum number of commands which will be stored in + the command history used for `:ALEInfo`. Command history will be rotated in + a FIFO manner. If set to a number <= 0, then the history will be + continuously set to an empty |List|. + + History can be disabled completely with |g:ale_history_enabled|. + + *ale-options.max_signs* + *g:ale_max_signs* + *b:ale_max_signs* +max_signs +g:ale_max_signs + Type: |Number| + Default: `-1` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + When set to any positive integer, ALE will not render any more than the + given number of signs for any one buffer. + + When set to `0`, no signs will be set, but sign processing will still be + done, so existing signs can be removed. + + When set to any other value, no limit will be imposed on the number of signs + set. + + For disabling sign processing, see |g:ale_set_signs|. + + *ale-options.maximum_file_size* + *g:ale_maximum_file_size* + *b:ale_maximum_file_size* +maximum_file_size +g:ale_maximum_file_size + Type: |Number| + Default: `nil` + + A maximum file size in bytes for ALE to check. If set to any positive + number, ALE will skip checking files larger than the given size. + + *ale-options.open_list* + *g:ale_open_list* + *b:ale_open_list* +open_list +g:ale_open_list + Type: |Boolean| |Number| or |String| + Default: `false` + + When set to `true` or `1`, this will cause ALE to automatically open a + window for the loclist (|lopen|) or for the quickfix list instead if + |g:ale_set_quickfix| is `true` or `1`. (|copen|) + + When set to any higher numerical value, ALE will only open the window when + the number of warnings or errors are at least that many. + + When set to `'on_save'`, ALE will only open the loclist after buffers have + been saved. The list will be opened some time after buffers are saved and + any linter for a buffer returns results. + + The window will be kept open until all warnings or errors are cleared, + including those not set by ALE, unless |g:ale_keep_list_window_open| is set + to `true` or `1`, in which case the window will be kept open when no + problems are found. + + The window size can be configured with |g:ale_list_window_size|. + + Windows can be opened vertically with |g:ale_list_vertical|. + + If you want to close the loclist window automatically when the buffer is + closed, you can set up the following |autocmd| command: > + + augroup CloseLoclistWindowGroup + autocmd! + autocmd QuitPre * if empty(&buftype) | lclose | endif + augroup END +< + *g:ale_pattern_options* +g:ale_pattern_options + Type: |Dictionary| + Default: `nil` + + NOTE: This option is not available through |ale.setup| in Lua as the options + named here would require separate translation to the equivalent Vim options. + You should instead use conditions in ftplugin files to configure options + based on filename patterns. + + This option maps regular expression patterns to |Dictionary| values for + buffer variables. This option can be set to automatically configure + different settings for different files. For example: > + + " Use just ESLint for linting and fixing files which end in '.foo.js' + let g:ale_pattern_options = { + \ '\.foo\.js$': { + \ 'ale_linters': ['eslint'], + \ 'ale_fixers': ['eslint'], + \ }, + \} +< + See |b:ale_linters| and |b:ale_fixers| for information for those options. + + Filenames are matched with |match()|, and patterns depend on the |magic| + setting, unless prefixed with the special escape sequences like `'\v'`, etc. + The patterns can match any part of a filename. The absolute path of the + filename will be used for matching, taken from `expand('%:p')`. + + The options for every match for the filename will be applied, with the + pattern keys sorted in alphabetical order. Options for `'zebra'` will + override the options for `'alpha'` for a filename `alpha-zebra`. + + *ale-options.pattern_options_enabled* + *g:ale_pattern_options_enabled* +pattern_options_enabled +g:ale_pattern_options_enabled + Type: |Boolean| or |Number| + Default: `nil` + + This option can be used for disabling pattern options. If set to `0`, ALE + will not set buffer variables per |g:ale_pattern_options|. + + *ale-options.popup_menu_enabled* + *g:ale_popup_menu_enabled* +popup_menu_enabled +g:ale_popup_menu_enabled + Type: |Boolean| or |Number| + Default: `has('gui_running')` + + When this option is set to `true` or `1`, ALE will show code actions and + rename capabilities in the right click mouse menu when there's a LSP server + or tsserver available. See |ale-refactor|. + + This feature is only supported in GUI versions of Vim. + + This setting must be set to `true` or `1` before ALE is loaded for this + behavior to be enabled. See |ale-lint-settings-on-startup|. + + *ale-options.rename_tsserver_find_in_comments* + *g:ale_rename_tsserver_find_in_comments* +rename_tsserver_find_in_comments +g:ale_rename_tsserver_find_in_comments + Type: |Boolean| or |Number| + Default: `false` + + If set to `true` or `1`, this option will tell tsserver to find and replace + text in comments when calling `:ALERename`. + + *ale-options.rename_tsserver_find_in_strings* + *g:ale_rename_tsserver_find_in_strings* +rename_tsserver_find_in_strings +g:ale_rename_tsserver_find_in_strings + Type: |Boolean| or |Number| + Default: `false` + + If set to `true` or `1`, this option will tell tsserver to find and replace + text in strings when calling `:ALERename`. + + *ale-options.root* + *g:ale_root* + *b:ale_root* +root +g:ale_root + Type: |Dictionary| or |String| + Default: `{}` + + This option is used to determine the project root for a linter. If the value + is a |Dictionary|, it maps a linter to either a |String| containing the + project root or a |Funcref| to call to look up the root. The |Funcref| is + provided the buffer number as its argument. + + The buffer-specific variable may additionally be a string containing the + project root itself. + + If neither variable yields a result, a linter-specific function is invoked to + detect a project root. If this, too, yields no result, and the linter is an + LSP linter, it will not run. + + *ale-options.save_hidden* + *g:ale_save_hidden* +save_hidden +g:ale_save_hidden + Type: |Boolean| or |Number| + Default: `false` + + When set to `true` or `1`, save buffers when 'hidden' is set when applying + code actions or rename operations, such as through `:ALERename` or + `:ALEOrganizeImports`. + + *ale-options.set_balloons* + *g:ale_set_balloons* + *b:ale_set_balloons* +set_balloons +g:ale_set_balloons + Type: |Boolean| or |Number| or |String| + Default: `has('balloon_eval') && has('gui_running')` + + When this option is set to `true` or `1`, balloon messages will be displayed + for problems or hover information if available. + + Problems nearest to the line the mouse cursor is over will be displayed. If + there are no problems to show, and one of the linters is an LSP linter + supporting "Hover" information, per |ale-hover|, then brief information + about the symbol under the cursor will be displayed in a balloon. + + This option can be set to `'hover'` to only enable balloons for hover + message, so diagnostics are never shown in balloons. You may wish to + configure use this setting only in GUI Vim like so: > + + let g:ale_set_balloons = has('gui_running') ? 'hover' : 0 +< + Balloons can be enabled for terminal versions of Vim that support balloons, + but some versions of Vim will produce strange mouse behavior when balloons + are enabled. To configure balloons for your terminal, you should first + configure your |ttymouse| setting, and then consider setting + `g:ale_set_balloons` to `1` before ALE is loaded. + + `b:ale_set_balloons` can be set to `0` to disable balloons for a buffer. + Balloons cannot be enabled for a specific buffer when not initially enabled + globally. + + Balloons will not be shown when |g:ale_enabled| or |b:ale_enabled| is not + `true` or `1`. + + *ale-options.set_balloons_legacy_echo* + *g:ale_set_balloons_legacy_echo* + *b:ale_set_balloons_legacy_echo* +set_balloons_legacy_echo +g:ale_set_balloons_legacy_echo + Type: |Boolean| or |Number| + Default: `nil` + + If set to `true` or `1`, moving your mouse over documents in Vim will make + ALE ask `tsserver` or `LSP` servers for information about the symbol where + the mouse cursor is, and print that information into Vim's echo line. This + is an option for supporting older versions of Vim which do not properly + support balloons in an asynchronous manner. + + If your version of Vim supports the |balloon_show| function, then this + option does nothing meaningful. + + *ale-options.set_highlights* + *g:ale_set_highlights* +set_highlights +g:ale_set_highlights + Type: |Boolean| or |Number| + Default: `has('syntax')` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + ALE's highlight groups will not be used when setting highlights through + Neovim's diagnostics API. See |diagnostic-highlights| for how to configure + Neovim diagnostic highlighting. + + When this option is set to `true` or `1`, highlights will be presented. + + ALE will use the following highlight groups for problems: + + ALEError items with `'type': 'E'` |hl-ALEError| + ALEWarning items with `'type': 'W'` |hl-ALEWarning| + ALEInfo items with `'type': 'I'` |hl-ALEInfo| + ALEStyleError items with `'type': 'E'` and + `'sub_type': 'style'` |hl-ALEStyleError| + ALEStyleWarning items with `'type': 'W'` and + `'sub_type': 'style'` |hl-ALEStyleWarning| + + When |g:ale_set_signs| is not set to `true` or `1`, the following highlights + for entire lines will be set. + + ALEErrorLine all items with `'type': 'E'` |hl-ALEErrorLine| + ALEWarningLine all items with `'type': 'W'` |hl-ALEWarningLine| + ALEInfoLine all items with `'type': 'I'` |hl-ALEInfoLine| + + Vim can only highlight the characters up to the last column in a buffer for + match highlights, whereas the line highlights when signs are enabled will + run to the edge of the screen. + + Highlights can be excluded with the |g:ale_exclude_highlights| option. + + *ale-options.set_loclist* + *g:ale_set_loclist* +set_loclist +g:ale_set_loclist + Type: |Boolean| or |Number| + Default: `true` + + When this option is set to `true` or `1`, the |location-list| will be + populated with any warnings and errors which are found by ALE. This feature + can be used to implement jumping between errors through typical use of + `:lnext` and `:lprev`. + + *ale-options.set_quickfix* + *g:ale_set_quickfix* +set_quickfix +g:ale_set_quickfix + Type: |Boolean| or |Number| + Default: `false` + + When this option is set to `true` or `1`, the |quickfix| list will be + populated with any problems which are found by ALE, instead of the + |location-list|. The loclist will never be populated when this option is + enabled. + + Problems from every buffer ALE has checked will be included in the quickfix + list, which can be checked with `:copen`. Problems will be de-duplicated. + + This feature should not be used in combination with tools for searching for + matches and commands like `:cfdo`, as ALE will replace the quickfix list + pretty frequently. If you wish to use such tools, you should populate the + loclist or use `:ALEPopulateQuickfix` instead. + + *ale-options.set_signs* + *g:ale_set_signs* +set_signs +g:ale_set_signs + Type: |Boolean| or |Number| + Default: `has('signs')` + + When this option is set to `true` or `1`, the |sign| column will be + populated with signs marking where problems appear in the file. + + When |g:ale_use_neovim_diagnostics_api| is `1`, the only other setting that + will be respected for signs is |g:ale_sign_priority|. ALE's highlight groups + will and other sign settings will not apply when setting signs through + Neovim's diagnostics API. See |diagnostic-signs| for how to configure signs + in Neovim. + + ALE will use the following highlight groups for problems: + + ALEErrorSign items with `'type': 'E'` |hl-ALEErrorSign| + ALEWarningSign items with `'type': 'W'` |hl-ALEWarningSign| + ALEInfoSign items with `'type': 'I'` |hl-ALEInfoSign| + ALEStyleErrorSign items with `'type': 'E'` and + `'sub_type': 'style'` |hl-ALEStyleErrorSign| + ALEStyleWarningSign items with `'type': 'W'` and + `'sub_type': 'style'` |hl-ALEStyleWarningSign| + + In addition to the style of the signs, the style of lines where signs appear + can be configured with the following highlights: + + ALEErrorLine all items with `'type': 'E'` |hl-ALEErrorLine| + ALEWarningLine all items with `'type': 'W'` |hl-ALEWarningLine| + ALEInfoLine all items with `'type': 'I'` |hl-ALEInfoLine| + + With Neovim 0.3.2 or higher, ALE can use the `numhl` option to highlight the + 'number' column. It uses the following highlight groups. + + ALEErrorSignLineNr items with `'type': 'E'` |hl-ALEErrorSignLineNr| + ALEWarningSignLineNr items with `'type': 'W'` |hl-ALEWarningSignLineNr| + ALEInfoSignLineNr items with `'type': 'I'` |hl-ALEInfoSignLineNr| + ALEStyleErrorSignLineNr items with `'type': 'E'` and + `'sub_type': 'style'` |hl-ALEStyleErrorSignLineNr| + ALEStyleWarningSignLineNr items with `'type': 'W'` and + `'sub_type': 'style'` |hl-ALEStyleWarningSignLineNr| + + To enable line number highlighting |g:ale_sign_highlight_linenrs| must be + set to `true` or `1` before ALE is loaded. + + The markers for the highlights can be customized with the following options: + + |g:ale_sign_error| + |g:ale_sign_warning| + |g:ale_sign_info| + |g:ale_sign_style_error| + |g:ale_sign_style_warning| + + When multiple problems exist on the same line, the signs will take + precedence in the order above, from highest to lowest. + + To limit the number of signs ALE will set, see |g:ale_max_signs|. + + *ale-options.sign_priority* + *g:ale_sign_priority* +sign_priority +g:ale_sign_priority + Type: |Number| + Default: `30` + + From Neovim 0.4.0 and Vim 8.1, ALE can set sign priority to all signs. The + larger this value is, the higher priority ALE signs have over other plugin + signs. See |sign-priority| for further details on how priority works. + + *ale-options.shell* + *g:ale_shell* + *b:ale_shell* +shell +g:ale_shell + Type: |String| + Default: `nil` + + Override the shell used by ALE for executing commands. ALE uses 'shell' by + default, but falls back in `/bin/sh` if the default shell looks like `fish` + or `pwsh`, which are not compatible with all of the commands run by ALE. The + shell specified with this option will be used even if it might not work in + all cases. + + For Windows, ALE uses `cmd` when this option isn't set. Setting this option + will apply shell escaping to the command string, even on Windows. + + NOTE: Consider setting |g:ale_shell_arguments| if this option is defined. + + *ale-options.shell_arguments* + *g:ale_shell_arguments* + *b:ale_shell_arguments* +shell_arguments +g:ale_shell_arguments + Type: |String| + Default: `nil` + + This option specifies the arguments to use for executing a command with a + custom shell, per |g:ale_shell|. If this option is not set, 'shellcmdflag' + will be used instead. + + *ale-options.sign_column_always* + *g:ale_sign_column_always* +sign_column_always +g:ale_sign_column_always + Type: |Boolean| or |Number| + Default: `v:false` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + By default, the sign gutter will disappear when all warnings and errors have + been fixed for a file. When this option is set to `1`, the sign column will + remain open. This can be preferable if you don't want the text in your file + to move around as you edit a file. + + *ale-options.sign_error* + *g:ale_sign_error* +sign_error +g:ale_sign_error + Type: |String| + Default: `'E'` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + The sign for errors in the sign gutter. + + *ale-options.sign_info* + *g:ale_sign_info* +sign_info +g:ale_sign_info + Type: |String| + Default: `'I'` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + The sign for "info" markers in the sign gutter. + + *ale-options.sign_style_error* + *g:ale_sign_style_error* +sign_style_error +g:ale_sign_style_error + Type: |String| + Default: `g:ale_sign_error` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + The sign for style errors in the sign gutter. + + *ale-options.sign_style_warning* + *g:ale_sign_style_warning* +sign_style_warning +g:ale_sign_style_warning + Type: |String| + Default: `g:ale_sign_warning` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + The sign for style warnings in the sign gutter. + + *ale-options.sign_offset* + *g:ale_sign_offset* +sign_offset +g:ale_sign_offset + Type: |Number| + Default: `1000000` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + This variable controls offset from which numeric IDs will be generated for + new signs. Signs cannot share the same ID values, so when two Vim plugins + set signs at the same time, the IDs have to be configured such that they do + not conflict with one another. If the IDs used by ALE are found to conflict + with some other plugin, this offset value can be changed, and hopefully both + plugins will work together. See |sign-place| for more information on how + signs are set. + + *ale-options.sign_warning* + *g:ale_sign_warning* +sign_warning +g:ale_sign_warning + Type: |String| + Default: `'W'` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + The sign for warnings in the sign gutter. + + *ale-options.sign_highlight_linenrs* + *g:ale_sign_highlight_linenrs* +sign_highlight_linenrs +g:ale_sign_highlight_linenrs + Type: |Boolean| or |Number| + Default: `false` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + When set to `true` or `1`, this option enables highlighting problems on the + 'number' column in Vim versions that support `numhl` highlights. This option + must be configured before ALE is loaded. + + *ale-options.update_tagstack* + *g:ale_update_tagstack* + *b:ale_update_tagstack* +update_tagstack +g:ale_update_tagstack + Type: |Boolean| or |Number| + Default: `v:true` + + When set to `true` or `1`, ALE will update Vims |tagstack| automatically + when jumping to a location through ALE's commands, so users can jump back to + where they came from. + *ale-options.type_map* + *g:ale_type_map* + *b:ale_type_map* +type_map +g:ale_type_map + Type: |Dictionary| + Default: `{}` + + This option can be set re-map problem types for linters. Each key in the + |Dictionary| should be the name of a linter, and each value must be a + |Dictionary| mapping problem types from one type to another. The following + types are supported: + + `'E'` - `{'type': 'E'}` + `'ES'` - `{'type': 'E', 'sub_type': 'style'}` + `'W'` - `{'type': 'W'}` + `'WS'` - `{'type': 'W', 'sub_type': 'style'}` + `'I'` - `{'type': 'I'}` + + For example, if you want to turn flake8 errors into warnings, you can write + the following: > + + let g:ale_type_map = {'flake8': {'ES': 'WS', 'E': 'W'}} +< + Or in Lua: > + + require("ale").setup(type_map = {flake8 = {ES = "WS", E = "W"}}) +< + If you wanted to turn style errors and warnings into regular errors and + warnings, you can write the following: > + + let g:ale_type_map = {'flake8': {'ES': 'E', 'WS': 'W'}} +< + Or in Lua: > + + require("ale").setup(type_map = {flake8 = {ES = "E", WS = "W"}}) +< + Type maps can be set per-buffer with `b:ale_type_map`, or in Lua with + |ale.setup.buffer|. + + *ale-options.use_global_executables* + *g:ale_use_global_executables* +use_global_executables +g:ale_use_global_executables + Type: |Number| + Default: `nil` + + This option can be set to change the default for all `_use_global` options. + This option must be set before ALE is loaded, preferably in a vimrc file. + + See |ale-integrations-local-executables| for more information on those + options. + + *ale-options.use_neovim_diagnostics_api* + *g:ale_use_neovim_diagnostics_api* +use_neovim_diagnostics_api +g:ale_use_neovim_diagnostics_api + Type: |Boolean| or |Number| + Default: `has('nvim-0.7')` + + If set to `true` or `1`, disable ALE's standard UI, and instead send all + linter output to Neovim's diagnostics API. This allows you to collect + problems using ALE and other plugins together all in one place. Many + options for configuring how problems appear on the screen will not apply + when the API is enabled. + + This option requires Neovim 0.7+, as that version introduces the diagnostics + API. + + *ale-options.use_neovim_lsp_api* + *g:ale_use_neovim_lsp_api* +use_neovim_lsp_api +g:ale_use_neovim_lsp_api + Type: |Boolean| or |Number| + Default: `has('nvim-0.8')` + + If set to `true` or `1`, ALE will use Neovim's native LSP client API for LSP + functionality. This makes it possible to use Neovim's built in LSP commands + and keybinds, and improves integration with other Neovim plugins that + integrate with Neovim's LSP client. + + See |ale-lsp-neovim| for more information about ALE's integration with + Neovim's LSP client. + + This option requires Neovim 0.8+. + + *ale-options.virtualtext_cursor* + *g:ale_virtualtext_cursor* +virtualtext_cursor +g:ale_virtualtext_cursor + Type: |Number| or |String| + Default: `'all'` (if supported, otherwise `'disabled'`) + + This option controls how ALE will display problems using |virtual-text|. + The following values can be used. + + `'all'`, `'2'`, or `2` - Show problems for all lines. + `'current'`, `'1'`, or `1` - Show problems for the current line. + `'disabled'`, `'0'`, or `0` - Do not show problems with virtual-text. + + When |g:ale_use_neovim_diagnostics_api| is `1`, `'current'` will behave the + same as `'all'`. + + Messages are only displayed after a short delay. See |g:ale_virtualtext_delay|. + + Messages can be prefixed with a string if not using Neovim's diagnostics + API. See |g:ale_virtualtext_prefix|. + + If and only if not displaying problems via Neovim's diagnostics API, + highlights for configuring ALE's virtualtext messages can be configured with + custom highlight groups: + + ALEVirtualTextError items with `'type': 'E'` |hl-ALEVirtualTextError| + ALEVirtualTextWarning items with `'type': 'W'` |hl-ALEVirtualTextWarning| + ALEVirtualTextInfo items with `'type': 'I'` |hl-ALEVirtualTextInfo| + ALEVirtualTextStyleError items with `'type': 'E'` and + `'sub_type': 'style'` |hl-ALEVirtualTextStyleError| + ALEVirtualTextStyleWarning items with `'type': 'W'` and + `'sub_type': 'style'` |hl-ALEVirtualTextStyleWarning| + + *ale-options.virtualtext_delay* + *g:ale_virtualtext_delay* + *b:ale_virtualtext_delay* +virtualtext_delay +g:ale_virtualtext_delay + Type: |Number| + Default: `10` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + Given any integer, this option controls the number of milliseconds before + ALE will show a message for a problem near the cursor. + + The value can be increased to decrease the amount of processing ALE will do + for files displaying a large number of problems. + + *ale-options.virtualtext_prefix* + *g:ale_virtualtext_prefix* + *b:ale_virtualtext_prefix* +virtualtext_prefix +g:ale_virtualtext_prefix + Type: |String| + Default: `'%comment% %type%: '` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + Prefix to be used with |g:ale_virtualtext_cursor|. + + This setting can be changed in each buffer with |b:ale_virtualtext_prefix||. + + All of the same format markers used for |g:ale_echo_msg_format| can be used + for defining the prefix, including some additional sequences of characters. + + `%comment%` - replaced with comment characters in the current language + + ALE will read the comment characters from 'commentstring', reading only the + part before `%s`, with whitespace trimmed. If comment syntax cannot be + pulled from 'commentstring', ALE will default to `'#'`. + + *ale-options.virtualtext_column* + *g:ale_virtualtext_column* + *b:ale_virtualtext_column* + *ale-options.virtualtext_maxcolumn* + *g:ale_virtualtext_maxcolumn* + *b:ale_virtualtext_maxcolumn* +virtualtext_column +virtualtext_maxcolumn +g:ale_virtualtext_column +g:ale_virtualtext_maxcolumn + Type: |String| or |Number| + Default: `0` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + Virtualtext column range, from `column` to `maxcolumn`. If a line is + `column` or less characters long, the virtualtext message is shifted right + to `column`. + + Where the line is greater than `column` characters long, but less than + `maxcolumn`, the virtualtext message is placed at the end of the line. + + Where the line is greater than `maxcolumn` the virtualtext message is + omitted. + + A |Number| greater than `0` is used as the fixed column position, however + a |String| ending in `%` represents a percentage of the window width. + When `column` is set to zero, column positioning is disabled, when `maxcolumn` + is set to zero, no maximum line length is enforced. + + *ale-options.virtualtext_single* + *g:ale_virtualtext_single* + *b:ale_virtualtext_single* +virtualtext_single +g:ale_virtualtext_single + Type: |Boolean| or |Number| + Default: `true` + + This has no effect when |g:ale_use_neovim_diagnostics_api| is `true` or `1`. + + Enable or disable concatenation of multiple virtual text messages on a single + line. By default, if a line has multiple errors or warnings, each will be + appended in turn. + + With `single` set to a non-zero value, only the first problem on a line will + be printed with virtual text. The most severe problem on a line will be + printed. If two problems exist on a line of equal severity, the problem at + the left-most position will be printed. + + *ale-options.virtualenv_dir_names* + *g:ale_virtualenv_dir_names* + *b:ale_virtualenv_dir_names* +virtualenv_dir_names +g:ale_virtualenv_dir_names + Type: |List| + Default: `['.venv', 'env', 've', 'venv', 'virtualenv', '.env']` + + A list of directory names to be used when searching upwards from Python + files to discover virtualenv directories with. + + For directory named `'foo'`, ALE will search for `'foo/bin/activate'` + (`foo\Scripts\activate\` on Windows) in all directories on and above the + directory containing the Python file to find virtualenv paths. + + *ale-options.warn_about_trailing_blank_lines* + *g:ale_warn_about_trailing_blank_lines* + *b:ale_warn_about_trailing_blank_lines* +warn_about_trailing_blank_lines +g:ale_warn_about_trailing_blank_lines + Type: |Number| + Default: `1` + + When this option is set to `1`, warnings about trailing blank lines will be + shown. + + This option behaves similarly to |g:ale_warn_about_trailing_whitespace|. + + *ale-options.warn_about_trailing_whitespace* + *g:ale_warn_about_trailing_whitespace* + *b:ale_warn_about_trailing_whitespace* +warn_about_trailing_whitespace +g:ale_warn_about_trailing_whitespace + Type: |Number| + Default: `1` + + When this option is set to `1`, warnings relating to trailing whitespace on + lines will be shown. If warnings are too irritating while editing buffers, + and you have configured Vim to automatically remove trailing whitespace, + you can disable these warnings by setting this option to `0`. + + Not all linters may respect this option. If a linter does not, please file a + bug report, and it may be possible to add such support. + + This option may be configured on a per buffer basis. + + *ale-options.windows_node_executable_path* + *g:ale_windows_node_executable_path* + *b:ale_windows_node_executable_path* +windows_node_executable_path +g:ale_windows_node_executable_path + Type: |String| + Default: `'node.exe'` + + This variable is used as the path to the executable to use for executing + scripts with Node.js on Windows. + + For Windows, any file with a `.js` file extension needs to be executed with + the node executable explicitly. Otherwise, Windows could try and open the + scripts with other applications, like a text editor. Therefore, these + scripts are executed with whatever executable is configured with this + setting. + + +------------------------------------------------------------------------------- +6.1. Highlights *ale-highlights* + +ALEError *hl-ALEError* + + Default: `highlight link ALEError SpellBad` + + The highlight for highlighted errors. See |g:ale_set_highlights|. + + +ALEErrorLine *hl-ALEErrorLine* + + Default: Undefined + + The highlight for an entire line where errors appear. Only the first + line for a problem will be highlighted. + + See |g:ale_set_signs| and |g:ale_set_highlights|. + + +ALEErrorSign *hl-ALEErrorSign* + + Default: `highlight link ALEErrorSign error` + + The highlight for error signs. See |g:ale_set_signs|. + + +ALEErrorSignLineNr *hl-ALEErrorSignLineNr* + + Default: `highlight link ALEErrorSignLineNr CursorLineNr` + + The highlight for error signs. See |g:ale_set_signs|. + + NOTE: This highlight is only available on Neovim 0.3.2 or higher. + + +ALEInfo *hl-ALEInfo* + *ALEInfo-highlight* + Default: `highlight link ALEInfo ALEWarning` + + The highlight for highlighted info messages. See |g:ale_set_highlights|. + + +ALEInfoSign *hl-ALEInfoSign* + + Default: `highlight link ALEInfoSign ALEWarningSign` + + The highlight for info message signs. See |g:ale_set_signs|. + + +ALEInfoLine *hl-ALEInfoLine* + + Default: Undefined + + The highlight for entire lines where info messages appear. Only the first + line for a problem will be highlighted. + + See |g:ale_set_signs| and |g:ale_set_highlights|. + + +ALEInfoSignLineNr *hl-ALEInfoSignLineNr* + + Default: `highlight link ALEInfoSignLineNr CursorLineNr` + + The highlight for error signs. See |g:ale_set_signs|. + + NOTE: This highlight is only available on Neovim 0.3.2 or higher. + + +ALEStyleError *hl-ALEStyleError* + + Default: `highlight link ALEStyleError ALEError` + + The highlight for highlighted style errors. See |g:ale_set_highlights|. + + +ALEStyleErrorSign *hl-ALEStyleErrorSign* + + Default: `highlight link ALEStyleErrorSign ALEErrorSign` + + The highlight for style error signs. See |g:ale_set_signs|. + + +ALEStyleErrorSignLineNr *hl-ALEStyleErrorSignLineNr* + + Default: `highlight link ALEStyleErrorSignLineNr CursorLineNr` + + The highlight for error signs. See |g:ale_set_signs|. + + NOTE: This highlight is only available on Neovim 0.3.2 or higher. + + +ALEStyleWarning *hl-ALEStyleWarning* + + Default: `highlight link ALEStyleWarning ALEError` + + The highlight for highlighted style warnings. See |g:ale_set_highlights|. + + +ALEStyleWarningSign *hl-ALEStyleWarningSign* + + Default: `highlight link ALEStyleWarningSign ALEWarningSign` + + The highlight for style warning signs. See |g:ale_set_signs|. + + +ALEStyleWarningSignLineNr *hl-ALEStyleWarningSignLineNr* + + Default: `highlight link ALEStyleWarningSignLineNr CursorLineNr` + + The highlight for error signs. See |g:ale_set_signs|. + + NOTE: This highlight is only available on Neovim 0.3.2 or higher. + + +ALEVirtualTextError *hl-ALEVirtualTextError* + + Default: `highlight link ALEVirtualTextError Comment` + + The highlight for virtualtext errors. See |g:ale_virtualtext_cursor|. + + +ALEVirtualTextInfo *hl-ALEVirtualTextInfo* + + Default: `highlight link ALEVirtualTextInfo ALEVirtualTextWarning` + + The highlight for virtualtext info. See |g:ale_virtualtext_cursor|. + + +ALEVirtualTextStyleError *hl-ALEVirtualTextStyleError* + + Default: `highlight link ALEVirtualTextStyleError ALEVirtualTextError` + + The highlight for virtualtext style errors. See |g:ale_virtualtext_cursor|. + + +ALEVirtualTextStyleWarning *hl-ALEVirtualTextStyleWarning* + + Default: `highlight link ALEVirtualTextStyleWarning ALEVirtualTextWarning` + + The highlight for virtualtext style warnings. See |g:ale_virtualtext_cursor|. + + +ALEVirtualTextWarning *hl-ALEVirtualTextWarning* + + Default: `highlight link ALEVirtualTextWarning Comment` + + The highlight for virtualtext errors. See |g:ale_virtualtext_cursor|. + + +ALEWarning *hl-ALEWarning* + + Default: `highlight link ALEWarning SpellCap` + + The highlight for highlighted warnings. See |g:ale_set_highlights|. + + +ALEWarningLine *hl-ALEWarningLine* + + Default: Undefined + + The highlight for entire lines where warnings appear. Only the first line + for a problem will be highlighted. + + See |g:ale_set_signs| and |g:ale_set_highlights|. + + +ALEWarningSign *hl-ALEWarningSign* + + Default: `highlight link ALEWarningSign todo` + + The highlight for warning signs. See |g:ale_set_signs|. + + +ALEWarningSignLineNr *hl-ALEWarningSignLineNr* + + Default: `highlight link ALEWarningSignLineNr CursorLineNr` + + The highlight for error signs. See |g:ale_set_signs|. + + NOTE: This highlight is only available on Neovim 0.3.2 or higher. + + +=============================================================================== +7. Linter/Fixer Options *ale-integration-options* + +Linter and fixer options are documented below and in individual help files. + +Every option for programs can be set globally, or individually for each +buffer. For example, |b:ale_python_flake8_executable| will override any +values set for |g:ale_python_flake8_executable|. + + *ale-integrations-local-executables* + +Some tools will prefer to search for locally-installed executables, unless +configured otherwise. For example, the `eslint` linter will search for +various executable paths in `node_modules`. The `flake8` linter will search +for virtualenv directories. + +If you prefer to use global executables for those tools, set the relevant +`_use_global` and `_executable` options for those linters. > + + " Use the global executable with a special name for eslint. + let g:ale_javascript_eslint_executable = 'special-eslint' + let g:ale_javascript_eslint_use_global = 1 + + " Use the global executable with a special name for flake8. + let g:ale_python_flake8_executable = '/foo/bar/flake8' + let g:ale_python_flake8_use_global = 1 +< +|g:ale_use_global_executables| can be set to `true` or `1` in your init or +vimrc file to make ALE use global executables for all linters by default. + +The option |g:ale_virtualenv_dir_names| controls the local virtualenv paths +ALE will use to search for Python executables. + + +------------------------------------------------------------------------------- +7.1. Options for alex *ale-alex-options* + +The options for `alex` are shared between all filetypes, so options can be +configured once. + + *ale-options.alex_executable* + *g:ale_alex_executable* + *b:ale_alex_executable* +alex_executable +g:ale_alex_executable + Type: |String| + Default: `'alex'` + + See |ale-integrations-local-executables| + + *ale-options.alex_use_global* + *g:ale_alex_use_global* + *b:ale_alex_use_global* +alex_use_global +g:ale_alex_use_global + Type: |Number| + Default: `get(g:, 'ale_use_global_executables', 0)` + + See |ale-integrations-local-executables| + + +------------------------------------------------------------------------------- +7.2. Options for cspell *ale-cspell-options* + +The options for `cspell` are shared between all filetypes, so options can be +configured only once. + + *ale-options.cspell_executable* + *g:ale_cspell_executable* + *b:ale_cspell_executable* +cspell_executable +g:ale_cspell_executable + Type: |String| + Default: `'cspell'` + + See |ale-integrations-local-executables| + + *ale-options.cspell_options* + *g:ale_cspell_options* + *b:ale_cspell_options* +cspell_options +g:ale_cspell_options + Type: |String| + Default: `''` + + This variable can be set to pass additional options to `cspell`. + + *ale-options.cspell_use_global* + *g:ale_cspell_use_global* + *b:ale_cspell_use_global* +cspell_use_global +g:ale_cspell_use_global + Type: |Number| + Default: `get(g: 'ale_use_global_executables', 0)` + + See |ale-integrations-local-executables| + + +------------------------------------------------------------------------------- +7.3. Options for dprint *ale-dprint-options* + +`dprint` is a fixer for many file types, including: (java|type)script, +json(c?), markdown, and more. See https://dprint.dev/plugins for an up-to-date +list of supported plugins and their configuration options. + + *ale-options.dprint_executable* + *g:ale_dprint_executable* + *b:ale_dprint_executable* +dprint_executable +g:ale_dprint_executable + Type: |String| + Default: `'dprint'` + + See |ale-integrations-local-executables| + + *ale-options.dprint_config* + *g:ale_dprint_config* + *b:ale_dprint_config* +dprint_config +g:ale_dprint_config + Type: |String| + Default: `'dprint.json'` + + This variable can be changed to provide a config file to `dprint`. The + default is the nearest `dprint.json` searching upward from the current + buffer. + + See https://dprint.dev/config and https://plugins.dprint.dev + + *ale-options.dprint_options* + *g:ale_dprint_options* + *b:ale_dprint_options* +dprint_options +g:ale_dprint_options + Type: |String| + Default: `''` + + This variable can be set to pass additional options to `dprint`. + + *ale-options.dprint_use_global* + *g:ale_dprint_use_global* + *b:ale_dprint_use_global* +dprint_use_global +g:ale_dprint_use_global + Type: |Number| + Default: `get(g: 'ale_use_global_executables', 0)` + + See |ale-integrations-local-executables| + + +------------------------------------------------------------------------------- +7.4. Options for languagetool *ale-languagetool-options* + + *ale-options.languagetool_executable* + *g:ale_languagetool_executable* + *b:ale_languagetool_executable* +languagetool_executable +g:ale_languagetool_executable + Type: |String| + Default: `'languagetool'` + + The executable to run for languagetool. + + *ale-options.languagetool_options* + *g:ale_languagetool_options* + *b:ale_languagetool_options* +languagetool_options +g:ale_languagetool_options + Type: |String| + Default: `'--autoDetect'` + + This variable can be set to pass additional options to languagetool. + + +------------------------------------------------------------------------------- +7.5. Options for write-good *ale-write-good-options* + +The options for `write-good` are shared between all filetypes, so options can +be configured once. + + *ale-options.writegood_executable* + *g:ale_writegood_executable* + *b:ale_writegood_executable* +writegood_executable +g:ale_writegood_executable + Type: |String| + Default: `'writegood'` + + See |ale-integrations-local-executables| + + *ale-options.writegood_options* + *g:ale_writegood_options* + *b:ale_writegood_options* +writegood_options +g:ale_writegood_options + Type: |String| + Default: `''` + + This variable can be set to pass additional options to writegood. + + *ale-options.writegood_use_global* + *g:ale_writegood_use_global* + *b:ale_writegood_use_global* +writegood_use_global +g:ale_writegood_use_global + Type: |Number| + Default: `get(g:, 'ale_use_global_executables', 0)` + + See |ale-integrations-local-executables| + + +------------------------------------------------------------------------------- +7.6. Other Linter/Fixer Options *ale-other-integration-options* + +ALE supports a very wide variety of tools. Other linter or fixer options are +documented in additional help files. + + ada.....................................|ale-ada-options| + cspell................................|ale-ada-cspell| + gcc...................................|ale-ada-gcc| + gnatpp................................|ale-ada-gnatpp| + ada-language-server...................|ale-ada-language-server| + ansible.................................|ale-ansible-options| + ansible-language-server...............|ale-ansible-language-server| + ansible-lint..........................|ale-ansible-ansible-lint| + apkbuild................................|ale-apkbuild-options| + apkbuild-fixer........................|ale-apkbuild-apkbuild-fixer| + apkbuild-lint.........................|ale-apkbuild-apkbuild-lint| + secfixes-check........................|ale-apkbuild-secfixes-check| + asciidoc................................|ale-asciidoc-options| + cspell................................|ale-asciidoc-cspell| + write-good............................|ale-asciidoc-write-good| + textlint..............................|ale-asciidoc-textlint| + asm.....................................|ale-asm-options| + gcc...................................|ale-asm-gcc| + llvm_mc...............................|ale-asm-llvm_mc| + astro...................................|ale-astro-options| + eslint................................|ale-astro-eslint| + prettier..............................|ale-astro-prettier| + avra....................................|ale-avra-options| + avra..................................|ale-avra-avra| + awk.....................................|ale-awk-options| + gawk..................................|ale-awk-gawk| + bats....................................|ale-bats-options| + shellcheck............................|ale-bats-shellcheck| + bazel...................................|ale-bazel-options| + buildifier............................|ale-bazel-buildifier| + bib.....................................|ale-bib-options| + bibclean..............................|ale-bib-bibclean| + bicep...................................|ale-bicep-options| + bicep.................................|ale-bicep-bicep| + az_bicep..............................|ale-bicep-az_bicep| + bitbake.................................|ale-bitbake-options| + oelint-adv............................|ale-bitbake-oelint_adv| + c.......................................|ale-c-options| + astyle................................|ale-c-astyle| + cc....................................|ale-c-cc| + ccls..................................|ale-c-ccls| + clangcheck............................|ale-c-clangcheck| + clangd................................|ale-c-clangd| + clang-format..........................|ale-c-clangformat| + clangtidy.............................|ale-c-clangtidy| + cppcheck..............................|ale-c-cppcheck| + cquery................................|ale-c-cquery| + cspell................................|ale-c-cspell| + flawfinder............................|ale-c-flawfinder| + uncrustify............................|ale-c-uncrustify| + cairo...................................|ale-cairo-options| + scarb.................................|ale-cairo-scarb| + starknet..............................|ale-cairo-starknet| + chef....................................|ale-chef-options| + cookstyle.............................|ale-chef-cookstyle| + foodcritic............................|ale-chef-foodcritic| + clojure.................................|ale-clojure-options| + clj-kondo.............................|ale-clojure-clj-kondo| + cljfmt................................|ale-clojure-cljfmt| + joker.................................|ale-clojure-joker| + cloudformation..........................|ale-cloudformation-options| + cfn-python-lint.......................|ale-cloudformation-cfn-python-lint| + cmake...................................|ale-cmake-options| + cmakelint.............................|ale-cmake-cmakelint| + cmake-lint............................|ale-cmake-cmake-lint| + cmake-format..........................|ale-cmake-cmakeformat| + cpp.....................................|ale-cpp-options| + astyle................................|ale-cpp-astyle| + cc....................................|ale-cpp-cc| + ccls..................................|ale-cpp-ccls| + clangcheck............................|ale-cpp-clangcheck| + clangd................................|ale-cpp-clangd| + clang-format..........................|ale-cpp-clangformat| + clangtidy.............................|ale-cpp-clangtidy| + clazy.................................|ale-cpp-clazy| + cppcheck..............................|ale-cpp-cppcheck| + cpplint...............................|ale-cpp-cpplint| + cquery................................|ale-cpp-cquery| + cspell................................|ale-cpp-cspell| + flawfinder............................|ale-cpp-flawfinder| + uncrustify............................|ale-cpp-uncrustify| + c#......................................|ale-cs-options| + clang-format..........................|ale-cs-clangformat| + csc...................................|ale-cs-csc| + cspell................................|ale-cs-cspell| + dotnet-format.........................|ale-cs-dotnet-format| + mcs...................................|ale-cs-mcs| + mcsc..................................|ale-cs-mcsc| + uncrustify............................|ale-cs-uncrustify| + css.....................................|ale-css-options| + cspell................................|ale-css-cspell| + css-beautify..........................|ale-css-css-beautify| + fecs..................................|ale-css-fecs| + prettier..............................|ale-css-prettier| + stylelint.............................|ale-css-stylelint| + vscodecss.............................|ale-css-vscode| + cuda....................................|ale-cuda-options| + clang-format..........................|ale-cuda-clangformat| + clangd................................|ale-cuda-clangd| + nvcc..................................|ale-cuda-nvcc| + c3......................................|ale-c3-options| + c3lsp.................................|ale-c3-c3lsp| + d.......................................|ale-d-options| + dfmt..................................|ale-d-dfmt| + dls...................................|ale-d-dls| + uncrustify............................|ale-d-uncrustify| + dafny...................................|ale-dafny-options| + dafny.................................|ale-dafny-dafny| + dart....................................|ale-dart-options| + analysis_server.......................|ale-dart-analysis_server| + dart-analyze..........................|ale-dart-analyze| + dart-format...........................|ale-dart-format| + dartfmt...............................|ale-dart-dartfmt| + desktop.................................|ale-desktop-options| + desktop-file-validate.................|ale-desktop-desktop-file-validate| + dhall...................................|ale-dhall-options| + dhall-format..........................|ale-dhall-format| + dhall-freeze..........................|ale-dhall-freeze| + dhall-lint............................|ale-dhall-lint| + dockerfile..............................|ale-dockerfile-options| + dockerfile_lint.......................|ale-dockerfile-dockerfile_lint| + dockerlinter..........................|ale-dockerfile-dockerlinter| + dprint................................|ale-dockerfile-dprint| + hadolint..............................|ale-dockerfile-hadolint| + elixir..................................|ale-elixir-options| + mix...................................|ale-elixir-mix| + mix_format............................|ale-elixir-mix-format| + dialyxir..............................|ale-elixir-dialyxir| + elixir-ls.............................|ale-elixir-elixir-ls| + credo.................................|ale-elixir-credo| + cspell................................|ale-elixir-cspell| + lexical...............................|ale-elixir-lexical| + elm.....................................|ale-elm-options| + elm-format............................|ale-elm-elm-format| + elm-ls................................|ale-elm-elm-ls| + elm-make..............................|ale-elm-elm-make| + erlang..................................|ale-erlang-options| + dialyzer..............................|ale-erlang-dialyzer| + elvis.................................|ale-erlang-elvis| + erlang-mode...........................|ale-erlang-erlang-mode| + erlang_ls.............................|ale-erlang-erlang_ls| + erlc..................................|ale-erlang-erlc| + erlfmt................................|ale-erlang-erlfmt| + syntaxerl.............................|ale-erlang-syntaxerl| + eruby...................................|ale-eruby-options| + erb-formatter.........................|ale-eruby-erbformatter| + erblint...............................|ale-eruby-erblint| + htmlbeautifier........................|ale-eruby-htmlbeautifier| + ruumba................................|ale-eruby-ruumba| + fish....................................|ale-fish-options| + fish_indent...........................|ale-fish-fish_indent| + fortran.................................|ale-fortran-options| + gcc...................................|ale-fortran-gcc| + language_server.......................|ale-fortran-language-server| + fountain................................|ale-fountain-options| + fusionscript............................|ale-fuse-options| + fusion-lint...........................|ale-fuse-fusionlint| + git commit..............................|ale-gitcommit-options| + gitlint...............................|ale-gitcommit-gitlint| + gleam...................................|ale-gleam-options| + gleam_format..........................|ale-gleam-gleam_format| + gleamlsp..............................|ale-gleam-gleamlsp| + glsl....................................|ale-glsl-options| + glslang...............................|ale-glsl-glslang| + glslls................................|ale-glsl-glslls| + go......................................|ale-go-options| + bingo.................................|ale-go-bingo| + cspell................................|ale-go-cspell| + gobuild...............................|ale-go-gobuild| + gofmt.................................|ale-go-gofmt| + gofumpt...............................|ale-go-gofumpt| + golangci-lint.........................|ale-go-golangci-lint| + golangserver..........................|ale-go-golangserver| + golines...............................|ale-go-golines| + gopls.................................|ale-go-gopls| + govet.................................|ale-go-govet| + revive................................|ale-go-revive| + staticcheck...........................|ale-go-staticcheck| + go html template........................|ale-gohtmltmpl-options| + djlint................................|ale-gohtmltmpl-djlint| + graphql.................................|ale-graphql-options| + eslint................................|ale-graphql-eslint| + gqlint................................|ale-graphql-gqlint| + prettier..............................|ale-graphql-prettier| + groovy..................................|ale-groovy-options| + npm-groovy-lint.......................|ale-groovy-npm-groovy-lint| + hack....................................|ale-hack-options| + hack..................................|ale-hack-hack| + hackfmt...............................|ale-hack-hackfmt| + hhast.................................|ale-hack-hhast| + handlebars..............................|ale-handlebars-options| + djlint................................|ale-handlebars-djlint| + prettier..............................|ale-handlebars-prettier| + ember-template-lint...................|ale-handlebars-embertemplatelint| + haskell.................................|ale-haskell-options| + brittany..............................|ale-haskell-brittany| + cspell................................|ale-haskell-cspell| + floskell..............................|ale-haskell-floskell| + ghc...................................|ale-haskell-ghc| + ghc-mod...............................|ale-haskell-ghc-mod| + cabal-ghc.............................|ale-haskell-cabal-ghc| + hdevtools.............................|ale-haskell-hdevtools| + hfmt..................................|ale-haskell-hfmt| + hindent...............................|ale-haskell-hindent| + hlint.................................|ale-haskell-hlint| + hls...................................|ale-haskell-hls| + stack-build...........................|ale-haskell-stack-build| + stack-ghc.............................|ale-haskell-stack-ghc| + stylish-haskell.......................|ale-haskell-stylish-haskell| + hie...................................|ale-haskell-hie| + ormolu................................|ale-haskell-ormolu| + fourmolu..............................|ale-haskell-fourmolu| + hcl.....................................|ale-hcl-options| + packer-fmt............................|ale-hcl-packer-fmt| + terraform-fmt.........................|ale-hcl-terraform-fmt| + help....................................|ale-help-options| + cspell................................|ale-help-cspell| + html....................................|ale-html-options| + angular...............................|ale-html-angular| + cspell................................|ale-html-cspell| + djlint................................|ale-html-djlint| + fecs..................................|ale-html-fecs| + html-beautify.........................|ale-html-beautify| + htmlhint..............................|ale-html-htmlhint| + prettier..............................|ale-html-prettier| + rustywind.............................|ale-html-rustywind| + stylelint.............................|ale-html-stylelint| + tidy..................................|ale-html-tidy| + vscodehtml............................|ale-html-vscode| + write-good............................|ale-html-write-good| + html angular template...................|ale-htmlangular-options| + djlint................................|ale-htmlangular-djlint| + html django template....................|ale-htmldjango-options| + djlint................................|ale-htmldjango-djlint| + http....................................|ale-http-options| + kulala_fmt............................|ale-http-kulala_fmt| + hurl....................................|ale-hurl-options| + hurlfmt...............................|ale-hurl-hurlfmt| + idris...................................|ale-idris-options| + idris.................................|ale-idris-idris| + ink.....................................|ale-ink-options| + ink-language-server...................|ale-ink-language-server| + inko....................................|ale-inko-options| + inko..................................|ale-inko-inko| + ispc....................................|ale-ispc-options| + ispc..................................|ale-ispc-ispc| + java....................................|ale-java-options| + checkstyle............................|ale-java-checkstyle| + clang-format..........................|ale-java-clangformat| + cspell................................|ale-java-cspell| + javac.................................|ale-java-javac| + google-java-format....................|ale-java-google-java-format| + pmd...................................|ale-java-pmd| + javalsp...............................|ale-java-javalsp| + eclipselsp............................|ale-java-eclipselsp| + uncrustify............................|ale-java-uncrustify| + javascript..............................|ale-javascript-options| + biome.................................|ale-javascript-biome| + clang-format..........................|ale-javascript-clangformat| + cspell................................|ale-javascript-cspell| + deno..................................|ale-javascript-deno| + dprint................................|ale-javascript-dprint| + eslint................................|ale-javascript-eslint| + fecs..................................|ale-javascript-fecs| + flow..................................|ale-javascript-flow| + importjs..............................|ale-javascript-importjs| + jscs..................................|ale-javascript-jscs| + jshint................................|ale-javascript-jshint| + prettier..............................|ale-javascript-prettier| + prettier-eslint.......................|ale-javascript-prettier-eslint| + prettier-standard.....................|ale-javascript-prettier-standard| + standard..............................|ale-javascript-standard| + xo....................................|ale-javascript-xo| + jinja...................................|ale-jinja-options| + djlint................................|ale-jinja-djlint| + json....................................|ale-json-options| + biome.................................|ale-json-biome| + clang-format..........................|ale-json-clangformat| + cspell................................|ale-json-cspell| + dprint................................|ale-json-dprint| + eslint................................|ale-json-eslint| + fixjson...............................|ale-json-fixjson| + pytool................................|ale-json-pytool| + jsonlint..............................|ale-json-jsonlint| + jq....................................|ale-json-jq| + prettier..............................|ale-json-prettier| + spectral..............................|ale-json-spectral| + vscodejson............................|ale-json-vscode| + jsonc...................................|ale-jsonc-options| + biome.................................|ale-jsonc-biome| + eslint................................|ale-jsonc-eslint| + jsonnet.................................|ale-jsonnet-options| + jsonnetfmt............................|ale-jsonnet-jsonnetfmt| + jsonnet-lint..........................|ale-jsonnet-jsonnet-lint| + json5...................................|ale-json5-options| + eslint................................|ale-json5-eslint| + julia...................................|ale-julia-options| + languageserver........................|ale-julia-languageserver| + kotlin..................................|ale-kotlin-options| + kotlinc...............................|ale-kotlin-kotlinc| + ktlint................................|ale-kotlin-ktlint| + languageserver........................|ale-kotlin-languageserver| + latex...................................|ale-latex-options| + cspell................................|ale-latex-cspell| + write-good............................|ale-latex-write-good| + textlint..............................|ale-latex-textlint| + less....................................|ale-less-options| + lessc.................................|ale-less-lessc| + prettier..............................|ale-less-prettier| + stylelint.............................|ale-less-stylelint| + llvm....................................|ale-llvm-options| + llc...................................|ale-llvm-llc| + lua.....................................|ale-lua-options| + cspell................................|ale-lua-cspell| + lua-format............................|ale-lua-lua-format| + lua-language-server...................|ale-lua-lua-language-server| + luac..................................|ale-lua-luac| + luacheck..............................|ale-lua-luacheck| + luafmt................................|ale-lua-luafmt| + selene................................|ale-lua-selene| + stylua................................|ale-lua-stylua| + make....................................|ale-make-options| + checkmake.............................|ale-make-checkmake| + markdown................................|ale-markdown-options| + cspell................................|ale-markdown-cspell| + dprint................................|ale-markdown-dprint| + markdownlint..........................|ale-markdown-markdownlint| + marksman..............................|ale-markdown-marksman| + mdl...................................|ale-markdown-mdl| + pandoc................................|ale-markdown-pandoc| + prettier..............................|ale-markdown-prettier| + pymarkdown............................|ale-markdown-pymarkdown| + remark-lint...........................|ale-markdown-remark-lint| + textlint..............................|ale-markdown-textlint| + write-good............................|ale-markdown-write-good| + mercury.................................|ale-mercury-options| + mmc...................................|ale-mercury-mmc| + nasm....................................|ale-nasm-options| + nasm..................................|ale-nasm-nasm| + nickel..................................|ale-nickel-options| + nickel_format.........................|ale-nickel-nickel-format| + nim.....................................|ale-nim-options| + nimcheck..............................|ale-nim-nimcheck| + nimlsp................................|ale-nim-nimlsp| + nimpretty.............................|ale-nim-nimpretty| + nix.....................................|ale-nix-options| + alejandra.............................|ale-nix-alejandra| + nixfmt................................|ale-nix-nixfmt| + nixpkgs-fmt...........................|ale-nix-nixpkgs-fmt| + statix................................|ale-nix-statix| + deadnix...............................|ale-nix-deadnix| + nroff...................................|ale-nroff-options| + write-good............................|ale-nroff-write-good| + nunjucks................................|ale-nunjucks-options| + djlint................................|ale-nunjucks-djlint| + objc....................................|ale-objc-options| + ccls..................................|ale-objc-ccls| + clang.................................|ale-objc-clang| + clang-format..........................|ale-objc-clangformat| + clangd................................|ale-objc-clangd| + uncrustify............................|ale-objc-uncrustify| + objcpp..................................|ale-objcpp-options| + clang.................................|ale-objcpp-clang| + clangd................................|ale-objcpp-clangd| + uncrustify............................|ale-objcpp-uncrustify| + ocaml...................................|ale-ocaml-options| + dune..................................|ale-ocaml-dune| + merlin................................|ale-ocaml-merlin| + ocamllsp..............................|ale-ocaml-ocamllsp| + ols...................................|ale-ocaml-ols| + ocamlformat...........................|ale-ocaml-ocamlformat| + ocp-indent............................|ale-ocaml-ocp-indent| + odin....................................|ale-odin-options| + ols...................................|ale-odin-ols| + openapi.................................|ale-openapi-options| + ibm_validator.........................|ale-openapi-ibm-validator| + prettier..............................|ale-openapi-prettier| + yamllint..............................|ale-openapi-yamllint| + openscad................................|ale-openscad-options| + sca2d.................................|ale-openscad-sca2d| + scadformat............................|ale-openscad-scadformat| + packer..................................|ale-packer-options| + packer-fmt-fixer......................|ale-packer-fmt-fixer| + pascal..................................|ale-pascal-options| + ptop..................................|ale-pascal-ptop| + pawn....................................|ale-pawn-options| + uncrustify............................|ale-pawn-uncrustify| + perl....................................|ale-perl-options| + perl..................................|ale-perl-perl| + perlcritic............................|ale-perl-perlcritic| + perltidy..............................|ale-perl-perltidy| + perl6...................................|ale-perl6-options| + perl6.................................|ale-perl6-perl6| + php.....................................|ale-php-options| + cspell................................|ale-php-cspell| + langserver............................|ale-php-langserver| + phan..................................|ale-php-phan| + phpcbf................................|ale-php-phpcbf| + phpcs.................................|ale-php-phpcs| + phpmd.................................|ale-php-phpmd| + phpstan...............................|ale-php-phpstan| + psalm.................................|ale-php-psalm| + php-cs-fixer..........................|ale-php-php-cs-fixer| + php...................................|ale-php-php| + pint..................................|ale-php-pint| + tlint.................................|ale-php-tlint| + intelephense..........................|ale-php-intelephense| + po......................................|ale-po-options| + write-good............................|ale-po-write-good| + pod.....................................|ale-pod-options| + write-good............................|ale-pod-write-good| + pony....................................|ale-pony-options| + ponyc.................................|ale-pony-ponyc| + powershell..............................|ale-powershell-options| + cspell................................|ale-powershell-cspell| + powershell............................|ale-powershell-powershell| + psscriptanalyzer......................|ale-powershell-psscriptanalyzer| + prolog..................................|ale-prolog-options| + swipl.................................|ale-prolog-swipl| + proto...................................|ale-proto-options| + buf-format............................|ale-proto-buf-format| + buf-lint..............................|ale-proto-buf-lint| + clang-format..........................|ale-proto-clangformat| + protoc-gen-lint.......................|ale-proto-protoc-gen-lint| + protolint.............................|ale-proto-protolint| + pug.....................................|ale-pug-options| + puglint...............................|ale-pug-puglint| + puppet..................................|ale-puppet-options| + puppet................................|ale-puppet-puppet| + puppetlint............................|ale-puppet-puppetlint| + puppet-languageserver.................|ale-puppet-languageserver| + purescript..............................|ale-purescript-options| + purescript-language-server............|ale-purescript-language-server| + purs-tidy.............................|ale-purescript-tidy| + purty.................................|ale-purescript-purty| + pyrex (cython)..........................|ale-pyrex-options| + cython................................|ale-pyrex-cython| + python..................................|ale-python-options| + autoflake.............................|ale-python-autoflake| + autoimport............................|ale-python-autoimport| + autopep8..............................|ale-python-autopep8| + bandit................................|ale-python-bandit| + black.................................|ale-python-black| + cspell................................|ale-python-cspell| + flake8................................|ale-python-flake8| + flakehell.............................|ale-python-flakehell| + isort.................................|ale-python-isort| + mypy..................................|ale-python-mypy| + prospector............................|ale-python-prospector| + pycln.................................|ale-python-pycln| + pycodestyle...........................|ale-python-pycodestyle| + pydocstyle............................|ale-python-pydocstyle| + pyflakes..............................|ale-python-pyflakes| + pyflyby...............................|ale-python-pyflyby| + pylama................................|ale-python-pylama| + pylint................................|ale-python-pylint| + pylsp.................................|ale-python-pylsp| + pyre..................................|ale-python-pyre| + pyright...............................|ale-python-pyright| + refurb................................|ale-python-refurb| + reorder-python-imports................|ale-python-reorder_python_imports| + ruff..................................|ale-python-ruff| + ruff-format...........................|ale-python-ruff-format| + unimport..............................|ale-python-unimport| + vulture...............................|ale-python-vulture| + yapf..................................|ale-python-yapf| + qml.....................................|ale-qml-options| + qmlfmt................................|ale-qml-qmlfmt| + r.......................................|ale-r-options| + languageserver........................|ale-r-languageserver| + lintr.................................|ale-r-lintr| + styler................................|ale-r-styler| + racket..................................|ale-racket-options| + racket_langserver.....................|ale-racket-langserver| + raco_fmt..............................|ale-racket-raco-fmt| + reasonml................................|ale-reasonml-options| + merlin................................|ale-reasonml-merlin| + ols...................................|ale-reasonml-ols| + reason-language-server................|ale-reasonml-language-server| + refmt.................................|ale-reasonml-refmt| + rego....................................|ale-rego-options| + cspell................................|ale-rego-cspell| + opacheck..............................|ale-rego-opa-check| + opafmt................................|ale-rego-opa-fmt-fixer| + rest....................................|ale-rest-options| + kulala_fmt............................|ale-rest-kulala_fmt| + restructuredtext........................|ale-restructuredtext-options| + cspell................................|ale-restructuredtext-cspell| + textlint..............................|ale-restructuredtext-textlint| + write-good............................|ale-restructuredtext-write-good| + robot...................................|ale-robot-options| + rflint................................|ale-robot-rflint| + ruby....................................|ale-ruby-options| + brakeman..............................|ale-ruby-brakeman| + cspell................................|ale-ruby-cspell| + debride...............................|ale-ruby-debride| + packwerk..............................|ale-ruby-packwerk| + prettier..............................|ale-ruby-prettier| + rails_best_practices..................|ale-ruby-rails_best_practices| + reek..................................|ale-ruby-reek| + rubocop...............................|ale-ruby-rubocop| + ruby..................................|ale-ruby-ruby| + rufo..................................|ale-ruby-rufo| + solargraph............................|ale-ruby-solargraph| + sorbet................................|ale-ruby-sorbet| + standardrb............................|ale-ruby-standardrb| + syntax_tree...........................|ale-ruby-syntax_tree| + rubyfmt...............................|ale-ruby-rubyfmt| + rust....................................|ale-rust-options| + analyzer..............................|ale-rust-analyzer| + cargo.................................|ale-rust-cargo| + cspell................................|ale-rust-cspell| + rls...................................|ale-rust-rls| + rustc.................................|ale-rust-rustc| + rustfmt...............................|ale-rust-rustfmt| + salt....................................|ale-salt-options| + salt-lint.............................|ale-salt-salt-lint| + sass....................................|ale-sass-options| + sasslint..............................|ale-sass-sasslint| + stylelint.............................|ale-sass-stylelint| + scala...................................|ale-scala-options| + cspell................................|ale-scala-cspell| + metals................................|ale-scala-metals| + sbtserver.............................|ale-scala-sbtserver| + scalafmt..............................|ale-scala-scalafmt| + scalastyle............................|ale-scala-scalastyle| + scss....................................|ale-scss-options| + prettier..............................|ale-scss-prettier| + sasslint..............................|ale-scss-sasslint| + stylelint.............................|ale-scss-stylelint| + sh......................................|ale-sh-options| + bashate...............................|ale-sh-bashate| + cspell................................|ale-sh-cspell| + sh-language-server....................|ale-sh-language-server| + shell.................................|ale-sh-shell| + shellcheck............................|ale-sh-shellcheck| + shfmt.................................|ale-sh-shfmt| + sml.....................................|ale-sml-options| + smlnj.................................|ale-sml-smlnj| + solidity................................|ale-solidity-options| + solc..................................|ale-solidity-solc| + solhint...............................|ale-solidity-solhint| + solium................................|ale-solidity-solium| + forge.................................|ale-solidity-forge| + spec....................................|ale-spec-options| + rpmlint...............................|ale-spec-rpmlint| + sql.....................................|ale-sql-options| + dprint................................|ale-sql-dprint| + pgformatter...........................|ale-sql-pgformatter| + sqlfluff..............................|ale-sql-sqlfluff| + sqlfmt................................|ale-sql-sqlfmt| + sqlformat.............................|ale-sql-sqlformat| + stylus..................................|ale-stylus-options| + stylelint.............................|ale-stylus-stylelint| + sugarss.................................|ale-sugarss-options| + stylelint.............................|ale-sugarss-stylelint| + svelte..................................|ale-svelte-options| + prettier..............................|ale-svelte-prettier| + svelteserver..........................|ale-svelte-svelteserver| + swift...................................|ale-swift-options| + apple-swift-format....................|ale-swift-apple-swift-format| + cspell................................|ale-swift-cspell| + sourcekitlsp..........................|ale-swift-sourcekitlsp| + systemd.................................|ale-systemd-options| + systemd-analyze.......................|ale-systemd-analyze| + tcl.....................................|ale-tcl-options| + nagelfar..............................|ale-tcl-nagelfar| + terraform...............................|ale-terraform-options| + checkov...............................|ale-terraform-checkov| + terraform-fmt-fixer...................|ale-terraform-fmt-fixer| + terraform.............................|ale-terraform-terraform| + terraform-ls..........................|ale-terraform-terraform-ls| + terraform-lsp.........................|ale-terraform-terraform-lsp| + tflint................................|ale-terraform-tflint| + tfsec.................................|ale-terraform-tfsec| + tex.....................................|ale-tex-options| + chktex................................|ale-tex-chktex| + cspell................................|ale-tex-cspell| + lacheck...............................|ale-tex-lacheck| + latexindent...........................|ale-tex-latexindent| + texlab................................|ale-tex-texlab| + texinfo.................................|ale-texinfo-options| + cspell................................|ale-texinfo-cspell| + write-good............................|ale-texinfo-write-good| + text....................................|ale-text-options| + cspell................................|ale-text-cspell| + textlint..............................|ale-text-textlint| + write-good............................|ale-text-write-good| + thrift..................................|ale-thrift-options| + thrift................................|ale-thrift-thrift| + thriftcheck...........................|ale-thrift-thriftcheck| + toml....................................|ale-toml-options| + dprint................................|ale-toml-dprint| + typescript..............................|ale-typescript-options| + biome.................................|ale-typescript-biome| + cspell................................|ale-typescript-cspell| + deno..................................|ale-typescript-deno| + dprint................................|ale-typescript-dprint| + eslint................................|ale-typescript-eslint| + prettier..............................|ale-typescript-prettier| + standard..............................|ale-typescript-standard| + tslint................................|ale-typescript-tslint| + tsserver..............................|ale-typescript-tsserver| + xo....................................|ale-typescript-xo| + typst...................................|ale-typst-options| + typstyle..............................|ale-typst-typstyle| + v.......................................|ale-v-options| + v.....................................|ale-v-v| + vfmt..................................|ale-v-vfmt| + vala....................................|ale-vala-options| + uncrustify............................|ale-vala-uncrustify| + verilog/systemverilog...................|ale-verilog-options| + hdl-checker...........................|ale-verilog-hdl-checker| + iverilog..............................|ale-verilog-iverilog| + slang.................................|ale-verilog-slang| + verilator.............................|ale-verilog-verilator| + vlog..................................|ale-verilog-vlog| + xvlog.................................|ale-verilog-xvlog| + yosys.................................|ale-verilog-yosys| + vhdl....................................|ale-vhdl-options| + ghdl..................................|ale-vhdl-ghdl| + hdl-checker...........................|ale-vhdl-hdl-checker| + vcom..................................|ale-vhdl-vcom| + xvhdl.................................|ale-vhdl-xvhdl| + vim help................................|ale-vim-help-options| + write-good............................|ale-vim-help-write-good| + vim.....................................|ale-vim-options| + vimls.................................|ale-vim-vimls| + vint..................................|ale-vim-vint| + vue.....................................|ale-vue-options| + cspell................................|ale-vue-cspell| + prettier..............................|ale-vue-prettier| + vls...................................|ale-vue-vls| + volar.................................|ale-vue-volar| + wgsl....................................|ale-wgsl-options| + naga..................................|ale-wgsl-naga| + xhtml...................................|ale-xhtml-options| + cspell................................|ale-xhtml-cspell| + write-good............................|ale-xhtml-write-good| + xml.....................................|ale-xml-options| + xmllint...............................|ale-xml-xmllint| + yaml....................................|ale-yaml-options| + actionlint............................|ale-yaml-actionlint| + circleci..............................|ale-yaml-circleci| + prettier..............................|ale-yaml-prettier| + spectral..............................|ale-yaml-spectral| + swaglint..............................|ale-yaml-swaglint| + yaml-language-server..................|ale-yaml-language-server| + yamlfix...............................|ale-yaml-yamlfix| + yamlfmt...............................|ale-yaml-yamlfmt| + yamllint..............................|ale-yaml-yamllint| + gitlablint............................|ale-yaml-gitlablint| + yq....................................|ale-yaml-yq| + yang....................................|ale-yang-options| + yang-lsp..............................|ale-yang-lsp| + yara....................................|ale-yara-options| + yls...................................|ale-yara-yls| + zeek....................................|ale-zeek-options| + zeek..................................|ale-zeek-zeek| + zig.....................................|ale-zig-options| + zigfmt................................|ale-zig-zigfmt| + zlint.................................|ale-zig-zlint| + zls...................................|ale-zig-zls| + + +=============================================================================== +8. Commands/Keybinds *ale-commands* + +:ALEComplete *:ALEComplete* + + Manually trigger LSP autocomplete and show the menu. Works only when called + from insert mode. > + + inoremap :ALEComplete +< + A plug mapping `(ale_complete)` is defined for this command. > + + imap (ale_complete) +< + +:ALEDocumentation *:ALEDocumentation* + + Similar to the `:ALEHover` command, retrieve documentation information for + the symbol at the cursor. Documentation data will always be shown in a + preview window, no matter how small the documentation content is. + + NOTE: This command is only available for `tsserver`. + + A plug mapping `(ale_documentation)` is defined for this command. + + +:ALEFindReferences *:ALEFindReferences* + + Find references in the codebase for the symbol under the cursor using the + enabled LSP linters for the buffer. ALE will display a preview window + containing the results if some references are found. + + The window can be navigated using the usual Vim navigation commands. The + Enter key () can be used to jump to a referencing location, or the `t` + key can be used to jump to the location in a new tab. + + The locations opened in different ways using the following variations. + + `:ALEFindReferences -tab` - Open the location in a new tab. + `:ALEFindReferences -split` - Open the location in a horizontal split. + `:ALEFindReferences -vsplit` - Open the location in a vertical split. + `:ALEFindReferences -quickfix` - Put the locations into quickfix list. + + The default method used for navigating to a new location can be changed + by modifying |g:ale_default_navigation|. + + You can add `-relative` to the command to view results with relatives paths, + instead of absolute paths. This option has no effect if `-quickfix` is used. + + The selection can be opened again with the `:ALERepeatSelection` command. + + You can jump back to the position you were at before going to a reference of + something with jump motions like CTRL-O. See |jump-motions|. + + A plug mapping `(ale_find_references)` is defined for this command. + You can define additional plug mapping with any additional options you want + like so: > + + nnoremap (my_mapping) :ALEFindReferences -relative +< + +:ALEFix [linter] *:ALEFix* + + Fix problems with the current buffer. See |ale-fix| for more information. + + If the command is run with a bang (`:ALEFix!`), all warnings will be + suppressed, including warnings about no fixers being defined, and warnings + about not being able to apply fixes to a file because it has been changed. + + A plug mapping `(ale_fix)` is defined for this command. + + +:ALEFixSuggest *:ALEFixSuggest* + + Suggest tools that can be used to fix problems in the current buffer. + + See |ale-fix| for more information. + + +:ALEGoToDefinition [options] *:ALEGoToDefinition* + + Jump to the definition of a symbol under the cursor using the enabled LSP + linters for the buffer. ALE will jump to a definition if an LSP server + provides a location to jump to. Otherwise, ALE will do nothing. + + The locations opened in different ways using the following variations. + + `:ALEGoToDefinition -tab` - Open the location in a new tab. + `:ALEGoToDefinition -split` - Open the location in a horizontal split. + `:ALEGoToDefinition -vsplit` - Open the location in a vertical split. + + The default method used for navigating to a new location can be changed + by modifying |g:ale_default_navigation|. + + You can jump back to the position you were at before going to the definition + of something with jump motions like CTRL-O. See |jump-motions|. + + You should consider using the 'hidden' option in combination with this + command. Otherwise, Vim will refuse to leave the buffer you're jumping from + unless you have saved your edits. + + The following Plug mappings are defined for this command, which correspond + to the following commands. + + `(ale_go_to_definition)` - `:ALEGoToDefinition` + `(ale_go_to_definition_in_tab)` - `:ALEGoToDefinition -tab` + `(ale_go_to_definition_in_split)` - `:ALEGoToDefinition -split` + `(ale_go_to_definition_in_vsplit)` - `:ALEGoToDefinition -vsplit` + + +:ALEGoToTypeDefinition [options] *:ALEGoToTypeDefinition* + + This works similar to `:ALEGoToDefinition` but instead jumps to the + definition of a type of a symbol under the cursor. ALE will jump to a + definition if an LSP server provides a location to jump to. Otherwise, ALE + will do nothing. + + The locations opened in different ways using the following variations. + + `:ALEGoToTypeDefinition -tab` - Open the location in a new tab. + `:ALEGoToTypeDefinition -split` - Open the location in a horizontal split. + `:ALEGoToTypeDefinition -vsplit` - Open the location in a vertical split. + + The default method used for navigating to a new location can be changed + by modifying |g:ale_default_navigation|. + + You can jump back to the position you were at before going to the definition + of something with jump motions like CTRL-O. See |jump-motions|. + + The following Plug mappings are defined for this command, which correspond + to the following commands. + + `(ale_go_to_type_definition)` - `:ALEGoToTypeDefinition` + `(ale_go_to_type_definition_in_tab)` - `:ALEGoToTypeDefinition -tab` + `(ale_go_to_type_definition_in_split)` - `:ALEGoToTypeDefinition -split` + `(ale_go_to_type_definition_in_vsplit)` - `:ALEGoToTypeDefinition -vsplit` + + +:ALEGoToImplementation [options] *:ALEGoToImplementation* + + This works similar to `:ALEGoToDefinition` but instead jumps to the + implementation of symbol under the cursor. ALE will jump to a definition if + an LSP server provides a location to jump to. Otherwise, ALE will do nothing. + + The locations opened in different ways using the following variations. + + `:ALEGoToImplementation -tab` - Open the location in a new tab. + `:ALEGoToImplementation -split` - Open the location in a horizontal split. + `:ALEGoToImplementation -vsplit` - Open the location in a vertical split. + + The default method used for navigating to a new location can be changed + by modifying |g:ale_default_navigation|. + + You can jump back to the position you were at before going to the definition + of something with jump motions like CTRL-O. See |jump-motions|. + + The following Plug mappings are defined for this command, which correspond + to the following commands. + + `(ale_go_to_implementation)` - `:ALEGoToImplementation` + `(ale_go_to_implementation_in_tab)` - `:ALEGoToImplementation -tab` + `(ale_go_to_implementation_in_split)` - `:ALEGoToImplementation -split` + `(ale_go_to_implementation_in_vsplit)` - `:ALEGoToImplementation -vsplit` + + +:ALEHover *:ALEHover* + + Print brief information about the symbol under the cursor, taken from any + available LSP linters. There may be a small non-blocking delay before + information is printed. + + NOTE: In Vim 8, long messages will be shown in a preview window, as Vim 8 + does not support showing a prompt to press enter to continue for long + messages from asynchronous callbacks. + + A plug mapping `(ale_hover)` is defined for this command. + + +:ALEImport *:ALEImport* + + Try to import a symbol using `tsserver` or a Language Server. + + ALE will look for completions for the word at the cursor which contain + additional text edits that possible insert lines to import the symbol. The + first match with additional text edits will be used, and may add other code + to the current buffer other than import lines. + + If linting is enabled, and |g:ale_lint_on_text_changed| is set to ever check + buffers when text is changed, the buffer will be checked again after changes + are made. + + A Plug mapping `(ale_import)` is defined for this command. This + mapping should only be bound for normal mode. + + +:ALEOrganizeImports *:ALEOrganizeImports* + + Organize imports using tsserver. Currently not implemented for LSPs. + + +:ALERename *:ALERename* + + Rename a symbol using `tsserver` or a Language Server. + + The symbol where the cursor is resting will be the symbol renamed, and a + prompt will open to request a new name. + + The rename operation will not save modified buffers when 'hidden' is on + unless |g:ale_save_hidden| is `true` or `1`. + + +:ALEFileRename *:ALEFileRename* + + Rename a file and fix imports using `tsserver`. + + +:ALECodeAction *:ALECodeAction* + + Apply a code action via LSP servers or `tsserver`. + + If there is an error present on a line that can be fixed, ALE will + automatically fix a line, unless there are multiple possible code fixes to + apply. + + This command can be run in visual mode apply actions, such as applicable + refactors. A menu will be shown to select code action to apply. + + +:ALERepeatSelection *:ALERepeatSelection* + + Repeat the last selection displayed in the preview window. + + +:ALESymbolSearch [query] *:ALESymbolSearch* + + Search for symbols in the workspace, taken from any available LSP linters. + + The arguments provided to this command will be used as a search query for + finding symbols in the workspace, such as functions, types, etc. + + You can add `-relative` to the command to view results with relatives paths, + instead of absolute paths. + + +:ALELint *:ALELint* + + Run ALE once for the current buffer. This command can be used to run ALE + manually, instead of automatically, if desired. + + This command will also run linters where `lint_file` is evaluates to `1`, + meaning linters which check the file instead of the Vim buffer. + + A plug mapping `(ale_lint)` is defined for this command. + + +:ALELintStop *:ALELintStop* + + Stop any currently running jobs for checking the current buffer. + + Any problems from previous linter results will continue to be shown. + + +:ALEPopulateQuickfix *:ALEPopulateQuickfix* +:ALEPopulateLocList *:ALEPopulateLocList* + + Manually populate the |quickfix| or |location-list| and show the + corresponding list. Useful when you have other uses for both the |quickfix| + and |location-list| and don't want them automatically populated. Be sure to + disable auto populating: > + + let g:ale_set_quickfix = 0 + let g:ale_set_loclist = 0 +< + With these settings, ALE will still run checking and display it with signs, + highlighting, and other output described in |ale-lint-file-linters|. + +:ALEPrevious *:ALEPrevious* +:ALEPreviousWrap *:ALEPreviousWrap* +:ALENext *:ALENext* +:ALENextWrap *:ALENextWrap* +:ALEFirst *:ALEFirst* +:ALELast *:ALELast* + *ale-navigation-commands* + + Move between warnings or errors in a buffer. ALE will only navigate between + the errors or warnings it generated, even if both |g:ale_set_quickfix| + and |g:ale_set_loclist| are set to `0`. + + `:ALEPrevious` and `:ALENext` will stop at the top and bottom of a file, while + `:ALEPreviousWrap` and `:ALENextWrap` will wrap around the file to find + the last or first warning or error in the file, respectively. + + `:ALEPrevious` and `:ALENext` take optional flags arguments to custom their + behavior : + `-wrap` enable wrapping around the file + `-error`, `-warning` and `-info` enable jumping to errors, warnings or infos + respectively, ignoring anything else. They are mutually exclusive and if + several are provided the priority is the following: error > warning > info. + `-style` and `-nostyle` allow you to jump respectively to style error or + warning and to not style error or warning. They also are mutually + exclusive and nostyle has priority over style. + + Flags can be combined to create create custom jumping. Thus you can use + ":ALENext -wrap -error -nosyle" to jump to the next error which is not a + style error while going back to the beginning of the file if needed. + + `:ALEFirst` goes to the first error or warning in the buffer, while `:ALELast` + goes to the last one. + + The following || mappings are defined for the commands: > + (ale_previous) - ALEPrevious + (ale_previous_wrap) - ALEPreviousWrap + (ale_previous_error) - ALEPrevious -error + (ale_previous_wrap_error) - ALEPrevious -wrap -error + (ale_previous_warning) - ALEPrevious -warning + (ale_previous_wrap_warning) - ALEPrevious -wrap -warning + (ale_next) - ALENext + (ale_next_wrap) - ALENextWrap + (ale_next_error) - ALENext -error + (ale_next_wrap_error) - ALENext -wrap -error + (ale_next_warning) - ALENext -warning + (ale_next_wrap_warning) - ALENext -wrap -warning + (ale_first) - ALEFirst + (ale_last) - ALELast +< + For example, these commands could be bound to the keys CTRL-j + and CTRL-k: > + + " Map movement through errors without wrapping. + nmap (ale_previous) + nmap (ale_next) + " OR map keys to use wrapping. + nmap (ale_previous_wrap) + nmap (ale_next_wrap) +< + +:ALEToggle *:ALEToggle* +:ALEEnable *:ALEEnable* +:ALEDisable *:ALEDisable* +:ALEToggleBuffer *:ALEToggleBuffer* +:ALEEnableBuffer *:ALEEnableBuffer* +:ALEDisableBuffer *:ALEDisableBuffer* + + `:ALEToggle`, `:ALEEnable`, and `:ALEDisable` enable or disable ALE linting, + including all of its autocmd events, loclist items, quickfix items, signs, + current jobs, etc., globally. Executing any of these commands will change + the |g:ale_enabled| variable. + + ALE can be disabled or enabled for only a single buffer with + `:ALEToggleBuffer`, `:ALEEnableBuffer`, and `:ALEDisableBuffer`. Disabling ALE + for a buffer will not remove autocmd events, but will prevent ALE from + checking for problems and reporting problems for whatever buffer the + `:ALEDisableBuffer` or `:ALEToggleBuffer` command is executed from. These + commands can be used for temporarily disabling ALE for a buffer. These + commands will modify the |b:ale_enabled| variable. + + ALE linting cannot be enabled for a single buffer when it is disabled + globally, as disabling ALE globally removes the autocmd events needed to + perform linting with. + + The following plug mappings are defined, for conveniently defining keybinds: + + `:ALEToggle` - `(ale_toggle)` + `:ALEEnable` - `(ale_enable)` + `:ALEDisable` - `(ale_disable)` + `:ALEToggleBuffer` - `(ale_toggle_buffer)` + `:ALEEnableBuffer` - `(ale_enable_buffer)` + `:ALEDisableBuffer` - `(ale_disable_buffer)` + + For removing problems reported by ALE, but leaving ALE enabled, see + `:ALEReset` and `:ALEResetBuffer`. + + +:ALEDetail *:ALEDetail* + + Show the full linter message for the problem nearest to the cursor on the + given line in the preview window. The preview window can be easily closed + with the `q` key. If there is no message to show, the window will not be + opened. + + If a loclist item has a `detail` key set, the message for that key will be + preferred over `text`. See |ale-loclist-format|. + + A plug mapping `(ale_detail)` is defined for this command. + + +:ALEInfo *:ALEInfo* + *:ALEInfoToFile* + + Print runtime information about ALE, including the values of global and + buffer-local settings for ALE, the linters that are enabled, the commands + that have been run, and the output of commands. + + ALE will log the commands that are run by default. If you wish to disable + this, set |g:ale_history_enabled| to `0`. Because it could be expensive, ALE + does not remember the output of recent commands by default. Set + |g:ale_history_log_output| to `1` to enable logging of output for commands. + ALE will only log the output captured for parsing problems, etc. + + You can pass options to the command to control how ALE displays the + information, such as `:ALEInfo -echo`, etc. > + + -preview Show the info in a preview window. + -clip OR -clipboard Copy the information to your clipboard. + -echo echo all of the information with :echo +< + The default mode can be configured with |g:ale_info_default_mode|. + + When shown in a preview window, syntax highlights can be defined for the + `ale-info` filetype. + + `:ALEInfoToFile` will write the ALE runtime information to a given filename. + The filename works just like `:write`. + + +:ALEReset *:ALEReset* +:ALEResetBuffer *:ALEResetBuffer* + + `:ALEReset` will remove all problems reported by ALE for all buffers. + `:ALEResetBuffer` will remove all problems reported for a single buffer. + + Either command will leave ALE linting enabled, so ALE will report problems + when linting is performed again. See |ale-lint| for more information. + + The following plug mappings are defined, for conveniently defining keybinds: + + `:ALEReset` - `(ale_reset)` + `:ALEResetBuffer` - `(ale_reset_buffer)` + + ALE can be disabled globally or for a buffer with `:ALEDisable` or + `:ALEDisableBuffer`. + + +:ALEStopAllLSPs *:ALEStopAllLSPs* + + `:ALEStopAllLSPs` will close and stop all channels and jobs for all LSP-like + clients, including tsserver, remove all of the data stored for them, and + delete all of the problems found for them, updating every linted buffer. + + This command can be used when LSP clients mess up and need to be restarted. + + +:ALEStopLSP [linter] *:ALEStopLSP* + + `:ALEStopLSP` will stop a specific language server with a given linter name. + Completion is supported for currently running language servers. All language + servers with the given name will be stopped across all buffers for all + projects. + + If the command is run with a bang (`:ALEStopLSP!`), all warnings will be + suppressed. + + +=============================================================================== +9. API *ale-api* + +ALE offers a number of functions for running linters or fixers, or defining +them. The following functions are part of the publicly documented part of that +API, and should be expected to continue to work. Functions documented with +Vim autocmd names `ale#Foo` are available in the Vim context, and functions +documented with dot names `ale.foo` are available in Lua scripts. + + +ale.env(variable_name, value) *ale.env()* +ale#Env(variable_name, value) *ale#Env()* + + Given a variable name and a string value, produce a string for including in + a command for setting environment variables. This function can be used for + building a command like so. > + + :echo string(ale#Env('VAR', 'some value') . 'command') + 'VAR=''some value'' command' # On Linux or Mac OSX + 'set VAR="some value" && command' # On Windows + + +ale.escape(str) *ale.escape()* +ale#Escape(str) *ale#Escape()* + + Given a string, escape that string so it is ready for shell execution. + + If the shell is detected to be `cmd.exe`, ALE will apply its own escaping + that tries to avoid escaping strings unless absolutely necessary to avoid + issues with Windows programs that do not properly handle quoted arguments. + + In all other cases, ALE will call |shellescape|. + + +ale.get_filename_mappings(buffer, name) *ale.get_filename_mappings()* +ale#GetFilenameMappings(buffer, name) *ale#GetFilenameMappings()* + + Given a `buffer` and the `name` of either a linter for fixer, return a + |List| of two-item |List|s that describe mapping to and from the local and + foreign file systems for running a particular linter or fixer. + + See |g:ale_filename_mappings| for details on filename mapping. + + +ale.has(feature) *ale.has()* +ale#Has(feature) *ale#Has()* + + In Vim, `ale#Has` returns `1` if ALE supports a given feature, like |has()| + for Vim features. In Lua `ale.has` returns `true` instead, and `false` if a + feature is not supported. + + ALE versions can be checked with version strings in the format + `ale#Has('ale-x.y.z')`, such as `ale#Has('ale-2.4.0')`. + + +ale.pad(str) *ale.pad()* +ale#Pad(str) *ale#Pad()* + + Given a string or any |empty()| value, return either the string prefixed + with a single space, or an empty string. This function can be used to build + parts of a command from variables. + + +ale.queue(delay, [linting_flag, buffer]) *ale.queue()* +ale#Queue(delay, [linting_flag, buffer]) *ale#Queue()* + + Run linters for the current buffer, based on the filetype of the buffer, + with a given `delay`. A `delay` of `0` will run the linters immediately. + The linters will always be run in the background. Calling this function + several times will reset an internal timer so ALE doesn't check buffers too + often. + + An optional `linting_flag` argument can be given. If `linting_flag` is + `'lint_file'`, then linters where the `lint_file` option evaluates to `1` + will be run. Otherwise, those linters will not be run. + + An optional `buffer` argument can be given for specifying the buffer to + check. The active buffer (`bufnr('')`) will be checked by default. + + *ale-cool-down* + If an exception is thrown when queuing/running ALE linters, ALE will enter + a cool down period where it will stop checking anything for a short period + of time. This is to prevent ALE from seriously annoying users if a linter + is broken, or when developing ALE itself. + + +ale.setup(config) *ale.setup()* + + Configure ALE global settings, which are documented in |ale-options|. For + example: > + + require("ale").setup({ + completion_enabled = true, + maximum_file_size = 1024 * 1024, + warn_about_trailing_whitespace = false, + }) +< + You can also call this function with `ale.setup.global` to make what context + ALE is being configured in less ambiguous if you like. + + +ale.setup.buffer(config) *ale.setup.buffer()* + + Configure ALE buffer-local settings, which are documented in |ale-options|. + For example: > + require("ale").setup.buffer({ + linters = {"ruff", "pyright"}, + fixers = {"ruff"} + }) +< + +ale.var(buffer, variable_name) *ale.var()* +ale#Var(buffer, variable_name) *ale#Var()* + + Given a buffer number and an ALE variable name return the value of that + if defined in the buffer, and if not defined in the buffer return the + global value. The `ale_` prefix will be added to the Vim variable name. + + The `ale#Var` Vim function will return errors if the variable is not defined + in either the buffer or globally. The `ale.var` Lua function will return + `nil` if the variable is not defined in either the buffer or globally. + + +ale#command#CreateDirectory(buffer) *ale#command#CreateDirectory()* + + Create a new temporary directory with a unique name, and manage that + directory with |ale#command#ManageDirectory()|, so it will be removed as soon + as possible. + + It is advised to only call this function from a callback function for + returning a linter command to run. + + +ale#command#CreateFile(buffer) *ale#command#CreateFile()* + + Create a new temporary file with a unique name, and manage that file with + |ale#command#ManageFile()|, so it will be removed as soon as possible. + + It is advised to only call this function from a callback function for + returning a linter command to run. + + +ale#command#Run(buffer, command, callback, [options]) *ale#command#Run()* + + Start running a job in the background, and pass the results to the given + callback later. + + This function can be used for computing the results of ALE linter or fixer + functions asynchronously with jobs. `buffer` must match the buffer being + linted or fixed, `command` must be a |String| for a shell command to + execute, `callback` must be defined as a |Funcref| to call later with the + results, and an optional |Dictionary| of `options` can be provided. + + The `callback` will receive the arguments `(buffer, output, metadata)`, + where the `buffer` will match the buffer given to the function, the `output` + will be a `List` of lines of output from the job that was run, and the + `metadata` will be a |Dictionary| with additional information about the job + that was run, including: + + `exit_code` - A |Number| with the exit code for the program that was run. + + The result of this function is either a special |Dictionary| ALE will use + for waiting for the command to finish, or `0` if the job is not started. The + The return value of the `callback` will be used as the eventual result for + whatever value is being given to ALE. For example: > + + function! s:GetCommand(buffer, output, meta) abort + " Do something with a:output here, from the foo command. + + " This is used as the command to run for linting. + return 'final command' + endfunction + + " ... + + 'command': {b -> ale#command#Run(b, 'foo', function('s:GetCommand'))} +< + The result of a callback can also be the result of another call to this + function, so that several commands can be arbitrarily chained together. For + example: > + + function! s:GetAnotherCommand(buffer, output, meta) abort + " We can finally return this command. + return 'last command' + endfunction + + function! s:GetCommand(buffer, output, meta) abort + " We can return another deferred result. + return ale#command#Run( + \ a:buffer, + \ 'second command', + \ function('s:GetAnotherCommand') + \) + endfunction + + " ... + + 'command': {b -> ale#command#Run(b, 'foo', function('s:GetCommand'))} +< + The following `options` can be provided. + + `cwd` - An optional |String| for setting the working directory + for the command, just as per |ale#linter#Define|. + + If not set, or `v:null`, the `cwd` of the last command + that spawned this one will be used. + + `output_stream` - Either `'stdout'`, `'stderr'`, `'both'`, or + `'none`' for selecting which output streams to read + lines from. + + The default is `'stdout'` + + `executable` - An executable for formatting into `%e` in the + command. If this option is not provided, formatting + commands with `%e` will not work. + + `read_buffer` - If set to `1`, the buffer will be piped into the + command. + + The default is `0`. + + `input` - When creating temporary files with `%t` or piping + text into a command `input` can be set to a |List| of + text to use instead of the buffer's text. + + `filename_mappings` - A |List| of two-item |List|s describing filename + mappings to apply for formatted filenames in the + command string, as per |g:ale_filename_mappings|. + + If the call to this function is being used for a + linter or fixer, the mappings should be provided with + this option, and can be retrieved easily with + |ale#GetFilenameMappings()|. + + The default is `[]`. + + +ale#command#EscapeCommandPart(command_part) *ale#command#EscapeCommandPart()* + + Given a |String|, return a |String| with all `%` characters replaced with + `%%` instead. This function can be used to escape strings which are + dynamically generated for commands before handing them over to ALE, + so that ALE doesn't treat any strings with `%` formatting sequences + specially. + + +ale#command#ManageDirectory(buffer, directory) *ale#command#ManageDirectory()* + + Like |ale#command#ManageFile()|, but directories and all of their contents + will be deleted, akin to `rm -rf directory`, which could lead to loss of + data if mistakes are made. This command will also delete any temporary + filenames given to it. + + It is advised to use |ale#command#ManageFile()| instead for deleting single + files. + + +ale#command#ManageFile(buffer, filename) *ale#command#ManageFile()* + + Given a buffer number for a buffer currently running some linting or fixing + tasks and a filename, register a filename with ALE for automatic deletion + after linting or fixing is complete, or when Vim exits. + + If Vim exits suddenly, ALE will try its best to remove temporary files, but + ALE cannot guarantee with absolute certainty that the files will be removed. + It is advised to create temporary files in the operating system's managed + temporary file directory, such as with |tempname()|. + + Directory names should not be given to this function. ALE will only delete + files and symlinks given to this function. This is to prevent entire + directories from being accidentally deleted, say in cases of writing + `dir . '/' . filename` where `filename` is actually `''`, etc. ALE instead + manages directories separately with the |ale#command#ManageDirectory| function. + + +ale#completion#OmniFunc(findstart, base) *ale#completion#OmniFunc()* + + A completion function to use with 'omnifunc'. + + See |ale-completion|. + + +ale#engine#GetLoclist(buffer) *ale#engine#GetLoclist()* + + Given a buffer number, this function will return the list of problems + reported by ALE for a given buffer in the format accepted by |setqflist()|. + + A reference to the buffer's list of problems will be returned. The list must + be copied before applying |map()| or |filter()|. + + +ale#engine#IsCheckingBuffer(buffer) *ale#engine#IsCheckingBuffer()* + + Given a buffer number, returns `1` when ALE is busy checking that buffer. + + This function can be used for status lines, tab names, etc. + + *ale#fix#registry#Add()* +ale#fix#registry#Add(name, func, filetypes, desc, [aliases]) + + Given a |String| `name` for a name to add to the registry, a |String| `func` + for a function name, a |List| `filetypes` for a list of filetypes to + set for suggestions, and a |String| `desc` for a short description of + the fixer, register a fixer in the registry. + + The `name` can then be used for |g:ale_fixers| in place of the function + name, and suggested for fixing files. + + An optional |List| of |String|s for aliases can be passed as the `aliases` + argument. These aliases can also be used for looking up a fixer function. + ALE will search for fixers in the registry first by `name`, then by their + `aliases`. + + For example to register a custom fixer for `luafmt`: > + + function! FormatLua(buffer) abort + return { + \ 'command': 'luafmt --stdin' + \} + endfunction + + execute ale#fix#registry#Add('luafmt', 'FormatLua', ['lua'], 'luafmt for lua') + + " You can now use it in g:ale_fixers + let g:ale_fixers = { + \ 'lua': ['luafmt'] + } +< + +ale#linter#Define(filetype, linter) *ale#linter#Define()* + + Given a |String| for a filetype and a |Dictionary| Describing a linter + configuration, add a linter for the given filetype. The dictionaries each + offer the following options: + + `name` The name of the linter. These names will be used by + |g:ale_linters| option for enabling/disabling + particular linters. + + This argument is required. + + `callback` A |String| or |Funcref| for a callback function + accepting two arguments (buffer, lines), for a + buffer number the output is for, and the lines of + output from a linter. + + This callback function should return a |List| of + |Dictionary| objects in the format accepted by + |setqflist()|. The |List| will be sorted by line and + then column order so it can be searched with a binary + search by in future before being passed on to the + |location-list|, etc. + + This argument is required, unless the linter is an + LSP linter. In which case, this argument must not be + defined, as LSP linters handle diagnostics + automatically. See |ale-lsp-linters|. + + If the function named does not exist, including if + the function is later deleted, ALE will behave as if + the callback returned an empty list. + + The keys for each item in the List will be handled in + the following manner: + *ale-loclist-format* + `text` - This error message is required. + `detail` - An optional, more descriptive message. + This message can be displayed with the `:ALEDetail` + command instead of the message for `text`, if set. + `lnum` - The line number is required. Any strings + will be automatically converted to numbers by + using |str2nr()|. + + Line 0 will be moved to line 1, and lines beyond + the end of the file will be moved to the end. + `col` - The column number is optional and will + default to `0`. Any strings will be automatically + converted to number using |str2nr()|. + `end_col` - An optional end column number. + This key can be set to specify the column problems + end on, for improved highlighting. + `end_lnum` - An optional end line number. + This key can set along with `end_col` for + highlighting multi-line problems. + `bufnr` - This key represents the buffer number the + problems are for. This value will default to + the buffer number being checked. + + The `filename` key can be set instead of this key, + and then the eventual `bufnr` value in the final + list will either represent the number for an open + buffer or `-1` for a file not open in any buffer. + `filename` - An optional filename for the file the + problems are for. This should be an absolute path to + a file. + + Problems for files which have not yet been opened + will be set in those files after they are opened + and have been checked at least once. + + Temporary files in directories used for Vim + temporary files with |tempname()| will be assumed + to be the buffer being checked, unless the `bufnr` + key is also set with a valid number for some other + buffer. + `vcol` - Defaults to `0`. + + If set to `1`, ALE will convert virtual column + positions for `col` and `end_col` to byte column + positions. If the buffer is changed in-between + checking it and displaying the results, the + calculated byte column positions will probably be + wrong. + `type` - Defaults to `'E'`. + `nr` - Defaults to `-1`. + + Numeric error code. If `nr` is not `-1`, `code` + likely should contain the string representation of + the same value. + `code` - No default; may be unset. + + Human-readable |String| error code. + + `executable` A |String| naming the executable itself which + will be run, or a |Funcref| for a function to call + for computing the executable, accepting a buffer + number. + + The result can be computed with |ale#command#Run()|. + + This value will be used to check if the program + requested is installed or not. + + If an `executable` is not defined, the command will + be run without checking if a program is executable + first. Defining an executable path is recommended to + avoid starting too many processes. + + `command` A |String| for a command to run asynchronously, or a + |Funcref| for a function to call for computing the + command, accepting a buffer number. + + The result can be computed with |ale#command#Run()|. + + The command string can be formatted with format + markers. See |ale-command-format-strings|. + + This command will be fed the lines from the buffer to + check, and will produce the lines of output given to + the `callback`. + + `cwd` An optional |String| for setting the working + directory for the command, or a |Funcref| for a + function to call for computing the command, accepting + a buffer number. The working directory can be + specified as a format string for determining the path + dynamically. See |ale-command-format-strings|. + + To set the working directory to the directory + containing the file you're checking, you should + probably use `'%s:h'` as the option value. + + If this option is absent or the string is empty, the + `command` will be run with no determined working + directory in particular. + + The directory specified with this option will be used + as the default working directory for all commands run + in a chain with |ale#command#Run()|, unless otherwise + specified. + + `output_stream` A |String| for the output stream the lines of output + should be read from for the command which is run. The + accepted values are `'stdout'`, `'stderr'`, and + `'both'`. This argument defaults to `'stdout'`. This + argument can be set for linter programs which output + their errors and warnings to the stderr stream + instead of stdout. The option `'both'` will read + from both stder and stdout at the same time. + + `read_buffer` A |Number| (`0` or `1`) indicating whether a command + should read the Vim buffer as input via stdin. This + option is set to `1` by default, and can be disabled + if a command manually reads from a temporary file + instead, etc. + + This option behaves as if it was set to `0` when the + `lint_file` option evaluates to `1`. + + *ale-lint-file* + `lint_file` A |Number| (`0` or `1`), or a |Funcref| for a function + accepting a buffer number for computing either `0` or + `1`, indicating whether a command should read the file + instead of the Vim buffer. This option can be used + for linters which must check the file on disk, and + which cannot check a Vim buffer instead. + + The result can be computed with |ale#command#Run()|. + + Linters where the eventual value of this option + evaluates to `1` will not be run as a user types, per + |g:ale_lint_on_text_changed|. Linters will instead be + run only when events occur against the file on disk, + including |g:ale_lint_on_enter| and + |g:ale_lint_on_save|. Linters where this option + evaluates to `1` will also be run when the `:ALELint` + command is run. + + When this option is evaluates to `1`, ALE will behave + as if `read_buffer` was set to `0`. + + *ale-lsp-linters* + `lsp` A |String| for defining LSP (Language Server Protocol) + linters. + + This argument may be omitted or `''` when a linter + does not represent an LSP linter. + + When this argument is set to `'stdio'`, then the + linter will be defined as an LSP linter which keeps a + process for a language server running, and + communicates with it directly via a |channel|. + `executable` and `command` must be set. + + When this argument is set to `'socket'`, then the + linter will be defined as an LSP linter via a TCP + or named pipe socket connection. `address` must be set. + + ALE will not start a server automatically. + + When this argument is not empty `project_root` must + be defined. + + `language` can be defined to describe the language + for a file. The filetype will be used as the language + by default. + + LSP linters handle diagnostics automatically, so + the `callback` argument must not be defined. + + An optional `completion_filter` callback may be + defined for filtering completion results. + + `initialization_options` may be defined to pass + initialization options to the LSP. + + `lsp_config` may be defined to pass configuration + settings to the LSP. + + `address` A |String| representing an address to connect to, + or a |Funcref| accepting a buffer number and + returning the |String|. If the value contains a + colon, it is interpreted as referring to a TCP + socket; otherwise it is interpreted as the path of a + named pipe. + + The result can be computed with |ale#command#Run()|. + + This argument must only be set if the `lsp` argument + is set to `'socket'`. + + `project_root` A |String| representing a path to the project for + the file being checked with the language server, or + a |Funcref| accepting a buffer number and returning + the |String|. + + If an empty string is returned, the file will not be + checked at all. + + This argument must only be set if the `lsp` argument + is also set to a non-empty string. + + `language` A |String| representing the name of the language + being checked, or a |Funcref| accepting a buffer + number and returning the |String|. This string will + be sent to the LSP to tell it what type of language + is being checked. + + If a language isn't provided, the language will + default to the value of the filetype given to + |ale#linter#Define|. + + `completion_filter` A |String| or |Funcref| for a callback function + accepting a buffer number and a completion item. + + The completion item will be a |Dictionary| following + the Language Server Protocol `CompletionItem` + interface as described in the specification, + available online here: + https://microsoft.github.io/language-server-protocol + + `aliases` A |List| of aliases for the linter name. + + This argument can be set with alternative names for + selecting the linter with |g:ale_linters|. This + setting can make it easier to guess the linter name + by offering a few alternatives. + + `initialization_options` A |Dictionary| of initialization options for LSPs, + or a |Funcref| for a callback function accepting + a buffer number and returning the |Dictionary|. + + This will be fed (as JSON) to the LSP in the + initialize command. + + `lsp_config` A |Dictionary| for configuring a language server, + or a |Funcref| for a callback function accepting + a buffer number and returning the |Dictionary|. + + This will be fed (as JSON) to the LSP in the + workspace/didChangeConfiguration command. + + If temporary files or directories are created for commands run with + `command`, then these temporary files or directories can be managed by ALE, + for automatic deletion. See |ale#command#ManageFile()| and + |ale#command#ManageDirectory| for more information. + + *ale-command-format-strings* + + All command strings will be formatted for special character sequences. + Any substring `%s` will be replaced with the full path to the current file + being edited. This format option can be used to pass the exact filename + being edited to a program. + + For example: > + 'command': 'eslint -f unix --stdin --stdin-filename %s' +< + Any substring `%t` will be replaced with a path to a temporary file. Merely + adding `%t` will cause ALE to create a temporary file containing the + contents of the buffer being checked. All occurrences of `%t` in command + strings will reference the one temporary file. The temporary file will be + created inside a temporary directory, and the entire temporary directory + will be automatically deleted, following the behavior of + |ale#command#ManageDirectory|. This option can be used for some linters which + do not support reading from stdin. + + For example: > + 'command': 'ghc -fno-code -v0 %t', +< + Any substring `%e` will be replaced with the escaped executable supplied + with `executable`. This provides a convenient way to define a command string + which needs to include a dynamic executable name, but which is otherwise + static. + + For example: > + 'command': '%e --some-argument', +< + The character sequence `%%` can be used to emit a literal `%` into a + command, so literal character sequences `%s` and `%t` can be escaped by + using `%%s` and `%%t` instead, etc. + + Some |filename-modifiers| can be applied to `%s` and `%t`. Only `:h`, `:t`, + `:r`, and `:e` may be applied, other modifiers will be ignored. Filename + modifiers can be applied to the format markers by placing them after them. + + For example: > + 'command': '%s:h %s:e %s:h:t', +< + Given a path `/foo/baz/bar.txt`, the above command string will generate + something akin to `'/foo/baz' 'txt' 'baz'` + + If a callback for a command generates part of a command string which might + possibly contain `%%`, `%s`, `%t`, or `%e`, where the special formatting + behavior is not desired, the |ale#command#EscapeCommandPart()| function can + be used to replace those characters to avoid formatting issues. + + *ale-linter-loading-behavior* + + Linters for ALE will be loaded by searching |runtimepath| in the following + format: > + + ale_linters//.vim +< + Any linters which exist anywhere in 'runtimepath' with that directory + structure will be automatically loaded for the matching |filetype|. Filetypes + containing `.` characters will be split into individual parts, and files + will be loaded for each filetype between the `.` characters. + + Linters can be defined from vimrc and other files as long as this function + is loaded first. For example, the following code will define a Hello World + linter in vimrc in Vim 8: > + + " Plugins have to be loaded first. + " If you are using a plugin manager, run that first. + packloadall + + call ale#linter#Define('vim', { + \ 'name': 'echo-test', + \ 'executable': 'echo', + \ 'command': 'echo hello world', + \ 'callback': {buffer, lines -> map(lines, '{"text": v:val, "lnum": 1}')}, + \}) +< + +ale#linter#Get(filetype) *ale#linter#Get()* + + Return all of linters configured for a given filetype as a |List| of + |Dictionary| values in the format specified by |ale#linter#Define()|. + + Filetypes may be dot-separated to invoke linters for multiple filetypes: + for instance, the filetype `javascript.jsx` will return linters for both the + `javascript` and `jsx` filetype. + + Aliases may be defined in as described in |g:ale_linter_aliases|. Aliases + are applied after dot-separated filetypes are broken up into their + components. + + +ale#linter#PreventLoading(filetype) *ale#linter#PreventLoading()* + + Given a `filetype`, prevent any more linters from being loaded from + |runtimepath| for that filetype. This function can be called from vimrc or + similar to prevent ALE from loading linters. + + *ale#lsp_linter#SendRequest()* +ale#lsp_linter#SendRequest(buffer, linter_name, message, [Handler]) + + Send a custom request to an LSP linter. The arguments are defined as + follows: + + `buffer` A valid buffer number. + + `linter_name` A |String| identifying an LSP linter that is available and + enabled for the |filetype| of `buffer`. + + `message` A |List| in the form `[is_notification, method, parameters]`, + containing three elements: + `is_notification` - an |Integer| that has value 1 if the + request is a notification, 0 otherwise; + `method` - a |String|, identifying an LSP method supported + by `linter`; + `parameters` - a |dictionary| of LSP parameters that are + applicable to `method`. + + `Handler` Optional argument, meaningful only when `message[0]` is 0. + A |Funcref| that is called when a response to the request is + received, and takes as unique argument a dictionary + representing the response obtained from the server. + + *ale#other_source#ShowResults()* +ale#other_source#ShowResults(buffer, linter_name, loclist) + + Show results from another source of information. + + `buffer` must be a valid buffer number, and `linter_name` must be a unique + name for identifying another source of information. The `loclist` given + where the problems in a buffer are, and should be provided in the format ALE + uses for regular linter results. See |ale-loclist-format|. + + *ale#other_source#StartChecking()* +ale#other_source#StartChecking(buffer, linter_name) + + Tell ALE that another source of information has started checking a buffer. + + `buffer` must be a valid buffer number, and `linter_name` must be a unique + name for identifying another source of information. + + +ale#statusline#Count(buffer) *ale#statusline#Count()* + + Given the number of a buffer which may have problems, return a |Dictionary| + containing information about the number of problems detected by ALE. The + following keys are supported: + + `error` -> The number of problems with type `E` and `sub_type != 'style'` + `warning` -> The number of problems with type `W` and `sub_type != 'style'` + `info` -> The number of problems with type `I` + `style_error` -> The number of problems with type `E` and `sub_type == 'style'` + `style_warning` -> The number of problems with type `W` and `sub_type == 'style'` + `total` -> The total number of problems. + + +ale#statusline#FirstProblem(buffer, type) *ale#statusline#FirstProblem()* + + Returns a copy of the first entry in the `loclist` that matches the supplied + buffer number and problem type. If there is no such entry, an empty dictionary + is returned. + Problem type should be one of the strings listed below: + + `error` -> Returns the first `loclist` item with type `E` and + `sub_type != 'style'` + `warning` -> First item with type `W` and `sub_type != 'style'` + `info` -> First item with type `I` + `style_error` -> First item with type `E` and `sub_type == 'style'` + `style_warning` -> First item with type `W` and `sub_type == 'style'` + + +b:ale_linted *b:ale_linted* + + `b:ale_linted` is set to the number of times a buffer has been checked by + ALE after all linters for one lint cycle have finished checking a buffer. + This variable may not be defined until ALE first checks a buffer, so it + should be accessed with |get()| or |getbufvar()|. For example: > + + " Print a message indicating how many times ALE has checked this buffer. + echo 'ALE has checked this buffer ' . get(b:, 'ale_linted') . ' time(s).' + " Print 'checked' using getbufvar() if a buffer has been checked. + echo getbufvar(bufnr(''), 'ale_linted', 0) > 0 ? 'checked' : 'not checked' +< + +g:ale_want_results_buffer *g:ale_want_results_buffer* + + `g:ale_want_results_buffer` is set to the number of the buffer being checked + when the |ALEWantResults| event is signaled. This variable should be read to + figure out which buffer other sources should lint. This variable can be read + in Lua scripts in the usual way via `vim.g.ale_want_results_buffer`. + + *ALECompletePost-autocmd* +ALECompletePost *ALECompletePost* + + This |User| autocmd is triggered after ALE inserts an item on + |CompleteDone|. This event can be used to run commands after a buffer + is changed by ALE as the result of completion. For example, `:ALEFix` can + be configured to run automatically when completion is done: > + + augroup FixAfterComplete + autocmd! + " Run ALEFix when completion items are added. + autocmd User ALECompletePost ALEFix! + " If ALE starts fixing a file, stop linters running for now. + autocmd User ALEFixPre ALELintStop + augroup END +< + *ALELintPre-autocmd* +ALELintPre *ALELintPre* + *ALELintPost-autocmd* +ALELintPost *ALELintPost* + *ALEFixPre-autocmd* +ALEFixPre *ALEFixPre* + *ALEFixPost-autocmd* +ALEFixPost *ALEFixPost* + + These |User| autocommands are triggered before and after every lint or fix + cycle. They can be used to update statuslines, send notifications, etc. + The autocmd commands are run with |:silent|, so |:unsilent| is required for + echoing messages. + + For example to change the color of the statusline while the linter is + running: > + + augroup ALEProgress + autocmd! + autocmd User ALELintPre hi Statusline ctermfg=darkgrey + autocmd User ALELintPost hi Statusline ctermfg=NONE + augroup END +< + Or to display the progress in the statusline: > + + let s:ale_running = 0 + let l:stl .= '%{s:ale_running ? "[linting]" : ""}' + augroup ALEProgress + autocmd! + autocmd User ALELintPre let s:ale_running = 1 | redrawstatus + autocmd User ALELintPost let s:ale_running = 0 | redrawstatus + augroup END +< + *ALEJobStarted-autocmd* +ALEJobStarted *ALEJobStarted* + + This |User| autocommand is triggered immediately after a job is successfully + run. This provides better accuracy for checking linter status with + |ale#engine#IsCheckingBuffer()| over |ALELintPre-autocmd|, which is actually + triggered before any linters are executed. + + *ALELSPStarted-autocmd* +ALELSPStarted *ALELSPStarted* + + This |User| autocommand is triggered immediately after an LSP connection is + successfully initialized. This provides a way to perform any additional + initialization work, such as setting up buffer-level mappings. + + *ALEWantResults-autocmd* +ALEWantResults *ALEWantResults* + + This |User| autocommand is triggered before ALE begins a lint cycle. Another + source can respond by calling |ale#other_source#StartChecking()|, and + |ALELintPre| will be signaled thereafter, to allow other plugins to know + that another source is checking the buffer. + + |g:ale_want_results_buffer| will be set to the number for a buffer being + checked when the event is signaled, and deleted after the event is done. + This variable should be read to know which buffer to check. + + Other plugins can use this event to start checking buffers when ALE events + for checking buffers are triggered. + + +=============================================================================== +10. Special Thanks *ale-special-thanks* + +Special thanks to Mark Grealish (https://www.bhalash.com/) for providing ALE's +snazzy looking ale glass logo. Cheers, Mark! + + +=============================================================================== +11. Contact *ale-contact* + +If you like this plugin, and wish to get in touch, check out the GitHub +page for issues and more at https://github.com/dense-analysis/ale + +If you wish to contact the author of this plugin directly, please feel +free to send an email to devw0rp@gmail.com. + +Please drink responsibly, or not at all, which is ironically the preference +of w0rp, who is teetotal. + + +=============================================================================== + vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl: