Merge pull request #2016 from terryding77/master

fix: change google_java_format_* to java_google_java_format_*
Merge pull request #2012 from paihu/fix-cdstring-win32-change-drive
2025-12-07 05:04:28 +08:00 · 2018-10-25 15:34:58 +01:00 · 2018-10-25 14:25:27 +01:00 · 2018-10-11 15:01:46 +01:00 · 2018-10-10 17:23:21 +01:00
837 changed files with 4986 additions and 27160 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -5,11 +5,6 @@ clone_depth: 10
 # Use the directory C:\testplugin so test directories will mostly work.
 clone_folder: C:\testplugin
 branches:
  only:
    - master
    - /v\d+\.\d+\.(x|\d+)/
 # Cache the vim and vader directories between builds.
 cache:
  - C:\vim -> .appveyor.yml
--- a/.github/ISSUE_TEMPLATE/report-a-bug.md
+++ b/.github/ISSUE_TEMPLATE/report-a-bug.md
@@ -23,13 +23,14 @@ about: Report a bug with ALE.
 Operating System: <!-- Describe your operating system version. -->
 ### :ALEInfo
 <!-- Paste the output of :ALEInfo here. Try :ALEInfoToClipboard -->
 <!-- Make sure to run :ALEInfo from the buffer where the bug occurred. -->
 ## What went wrong
-<!-- Describe what went wrong here. Be specific. -->
+<!-- Describe what went wrong here. -->
 Something went wrong in specifically this place, and I also searched through both open and closed issues for the same problem before reporting a bug here.
 Are you having trouble configuring ALE? Try asking for help on [Stack Exchange](https://vi.stackexchange.com/) or perhaps on [Reddit](https://www.reddit.com/r/vim/) instead. The GitHub issue tracker should be used for reporting bugs or asking for new features.
 ## Reproducing the bug
@@ -37,9 +38,3 @@ Are you having trouble configuring ALE? Try asking for help on [Stack Exchange](
 1. I did this.
 2. Then this happened.
 ### :ALEInfo
 <!-- Paste the output of :ALEInfo here. Try :ALEInfoToClipboard -->
 <!-- Make sure to run :ALEInfo from the buffer where the bug occurred. -->
 <!-- Read the output. You might figure out what went wrong yourself. -->
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -2,12 +2,7 @@
 Before creating a pull request, do the following.
 * Read the Contributing guide linked above first.
-* Read the documentation that comes with ALE with `:help ale-dev`.
+* Read the documentation that comes with ALE with `:help ale-development`.
 Have fun!
 -->
 Where are the tests? Have you added tests? Have you updated the tests? Read the
 comment above and the documentation referenced in it first. Write tests!
 Seriously, read `:help ale-dev` and write tests.
--- a/.gitignore
+++ b/.gitignore
@@ -1,10 +1,6 @@
 !.editorconfig
 *.obj
 # Ignore all hidden files everywhere.
 # Use `git add -f` to add hidden files.
 .*
 __pycache__
 *.pyc
 /doc/tags
 /init.vim
 /test/ale-info-test-file
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,10 +3,6 @@ sudo: required
 services:
    - docker
 language: generic
 branches:
  only:
    - master
    - /^v\d+\.\d+\.(x|\d+)$/
 env:
    - OPTIONS=--vim-80-only
    - OPTIONS=--vim-81-only
--- a/4
+++ b/4
@@ -1,9 +1,9 @@
 FROM tweekmonster/vim-testbed:latest
 RUN install_vim -tag v8.0.0027 -build \
-                -tag v8.1.0519 -build \
+                -tag v8.1.0204 -build \
                -tag neovim:v0.2.0 -build \
-                -tag neovim:v0.3.5 -build
+                -tag neovim:v0.3.0 -build
 ENV PACKAGES="\
    bash \
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Copyright (c) 2016-2019, w0rp <devw0rp@gmail.com>
+Copyright (c) 2016-2018, w0rp <devw0rp@gmail.com>
 All rights reserved.
 Redistribution and use in source and binary forms, with or without
--- a/README.md
+++ b/README.md
@@ -1,13 +1,13 @@
-# Asynchronous Lint Engine [![Travis CI Build Status](https://travis-ci.com/dense-analysis/ale.svg?branch=master)](https://travis-ci.com/dense-analysis/ale) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/r0ef1xu8xjmik58d/branch/master?svg=true)](https://ci.appveyor.com/project/dense-analysis/ale) [![Join the chat at https://gitter.im/vim-ale/Lobby](https://badges.gitter.im/vim-ale/Lobby.svg)](https://gitter.im/vim-ale/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+# Asynchronous Lint Engine [![Travis CI Build Status](https://travis-ci.org/w0rp/ale.svg?branch=master)](https://travis-ci.org/w0rp/ale) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/r0ef1xu8xjmik58d/branch/master?svg=true)](https://ci.appveyor.com/project/w0rp/ale)
-![ALE Logo by Mark Grealish - https://www.bhalash.com/](https://user-images.githubusercontent.com/3518142/59195920-2c339500-8b85-11e9-9c22-f6b7f69637b8.jpg)
+![ALE Logo by Mark Grealish - https://www.bhalash.com/](img/logo.jpg?raw=true)
-ALE (Asynchronous Lint Engine) is a plugin providing linting (syntax checking
+ALE (Asynchronous Lint Engine) is a plugin for providing linting in NeoVim
-and semantic errors) in NeoVim 0.2.0+ and Vim 8 while you edit your text files,
+0.2.0+ and Vim 8 while you edit your text files, and acts as a Vim
-and acts as a Vim [Language Server Protocol](https://langserver.org/) client.
+[Language Server Protocol](https://langserver.org/) client.
-<img src="https://user-images.githubusercontent.com/3518142/59195938-3a81b100-8b85-11e9-8e8d-6a601b1db908.gif" alt="A linting example with the darkspectrum color scheme in GVim." title="A linting example with the darkspectrum color scheme in GVim.">
+<img src="img/example.gif?raw=true" alt="A linting example with the darkspectrum color scheme in GVim." title="A linting example with the darkspectrum color scheme in GVim.">
 ALE makes use of NeoVim and Vim 8 job control functions and timers to
 run linters on the contents of text buffers and return errors as
@@ -26,18 +26,14 @@ features, including:
 * Diagnostics (via Language Server Protocol linters)
 * Go To Definition (`:ALEGoToDefinition`)
-* Completion (Built in completion support, or with Deoplete)
+* Completion (`let g:ale_completion_enabled = 1`)
 * Finding references (`:ALEFindReferences`)
 * Hover information (`:ALEHover`)
 * Symbol search (`:ALESymbolSearch`)
 If you don't care about Language Server Protocol, ALE won't load any of the code
 for working with it unless needed. One of ALE's general missions is that you
 won't pay for the features that you don't use.
 If you enjoy this plugin, feel free to contribute or check out the author's
 other content at [w0rp.com](https://w0rp.com).
 ## Table of Contents
 1. [Supported Languages and Tools](#supported-languages)
@@ -48,12 +44,10 @@ other content at [w0rp.com](https://w0rp.com).
    4. [Go To Definition](#usage-go-to-definition)
    5. [Find References](#usage-find-references)
    6. [Hovering](#usage-hover)
    7. [Symbol Search](#usage-symbol-search)
 3. [Installation](#installation)
    1. [Installation with Vim package management](#standard-installation)
    2. [Installation with Pathogen](#installation-with-pathogen)
    3. [Installation with Vundle](#installation-with-vundle)
    4. [Installation with Vim-Plug](#installation-with-vim-plug)
 4. [Contributing](#contributing)
 5. [FAQ](#faq)
    1. [How do I disable particular linters?](#faq-disable-linters)
@@ -68,20 +62,139 @@ other content at [w0rp.com](https://w0rp.com).
    10. [How can I run linters only when I save files?](#faq-lint-on-save)
    11. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
    12. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
-    13. [How can I check Vue files with ESLint?](#faq-vue-eslint)
+    13. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
-    14. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
+    14. [How can I configure my C or C++ project?](#faq-c-configuration)
-    15. [How can I configure my C or C++ project?](#faq-c-configuration)
+    15. [How can I configure ALE differently for different buffers?](#faq-buffer-configuration)
-    16. [How can I configure ALE differently for different buffers?](#faq-buffer-configuration)
+    16. [How can I configure the height of the list in which ALE displays errors?](#faq-list-window-height)
    17. [How can I configure the height of the list in which ALE displays errors?](#faq-list-window-height)
    18. [How can I see what ALE has configured for the current file?](#faq-get-info)
 <a name="supported-languages"></a>
 ## 1. Supported Languages and Tools
-ALE supports a wide variety of languages and tools. See the
+This plugin supports the following languages and tools. All available
-[full list](supported-tools.md) in the
+tools will be run in combination, so they can be complementary.
-[Supported Languages and Tools](supported-tools.md) page.
+
 <!--
 Keep the table rows sorted alphabetically by the language name,
 and the tools in the tools column sorted alphabetically by the tool
 name. That seems to be the fairest way to arrange this table.
 Remember to also update doc/ale.txt, which has a similar list with different
 formatting.
 -->
 **Notes:**
 * *^ No linters for text or Vim help filetypes are enabled by default.*
 * *!! These linters check only files on disk. See `:help ale-lint-file-linters`*
 | Language | Tools |
 | -------- | ----- |
 | ASM | [gcc](https://gcc.gnu.org) |
 | Ansible | [ansible-lint](https://github.com/willthames/ansible-lint) |
 | API Blueprint | [drafter](https://github.com/apiaryio/drafter) |
 | AsciiDoc | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [write-good](https://github.com/btford/write-good) |
 | Awk | [gawk](https://www.gnu.org/software/gawk/)|
 | Bash | [language-server](https://github.com/mads-hartmann/bash-language-server), shell [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/), [shfmt](https://github.com/mvdan/sh) |
 | Bourne Shell | shell [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/), [shfmt](https://github.com/mvdan/sh) |
 | C | [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint), [clang](http://clang.llvm.org/), [clangd](https://clang.llvm.org/extra/clangd.html), [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html), [cquery](https://github.com/cquery-project/cquery), [flawfinder](https://www.dwheeler.com/flawfinder/), [gcc](https://gcc.gnu.org/), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangd](https://clang.llvm.org/extra/clangd.html), [clangcheck](http://clang.llvm.org/docs/ClangCheck.html) !!, [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html), [clazy](https://github.com/KDE/clazy) !!, [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint) !!, [cquery](https://github.com/cquery-project/cquery), [flawfinder](https://www.dwheeler.com/flawfinder/), [gcc](https://gcc.gnu.org/), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | CUDA | [nvcc](http://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html) |
 | C# | [mcs](http://www.mono-project.com/docs/about-mono/languages/csharp/) see:`help ale-cs-mcs` for details, [mcsc](http://www.mono-project.com/docs/about-mono/languages/csharp/) !! see:`help ale-cs-mcsc` for details and configuration, [uncrustify](https://github.com/uncrustify/uncrustify) |
 | Chef | [foodcritic](http://www.foodcritic.io/) |
 | Clojure | [joker](https://github.com/candid82/joker) |
 | CloudFormation | [cfn-python-lint](https://github.com/awslabs/cfn-python-lint) |
 | CMake | [cmakelint](https://github.com/richq/cmake-lint) |
 | CoffeeScript | [coffee](http://coffeescript.org/), [coffeelint](https://www.npmjs.com/package/coffeelint) |
 | Crystal | [crystal](https://crystal-lang.org/) !! |
 | CSS | [csslint](http://csslint.net/), [prettier](https://github.com/prettier/prettier), [stylelint](https://github.com/stylelint/stylelint) |
 | Cucumber | [cucumber](https://cucumber.io/) |
 | Cython (pyrex filetype) | [cython](http://cython.org/) |
 | D | [dmd](https://dlang.org/dmd-linux.html), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | Dafny | [dafny](https://rise4fun.com/Dafny) !! |
 | Dart | [dartanalyzer](https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_cli) !!, [language_server](https://github.com/natebosch/dart_language_server), [dartfmt](https://github.com/dart-lang/sdk/tree/master/utils/dartfmt) |
 | Dockerfile | [hadolint](https://github.com/hadolint/hadolint) |
 | Elixir | [credo](https://github.com/rrrene/credo), [dialyxir](https://github.com/jeremyjh/dialyxir), [dogma](https://github.com/lpil/dogma), [mix](https://hexdocs.pm/mix/Mix.html) !!|
 | Elm | [elm-format](https://github.com/avh4/elm-format), [elm-make](https://github.com/elm-lang/elm-make) |
 | Erb | [erb](https://apidock.com/ruby/ERB), [erubi](https://github.com/jeremyevans/erubi), [erubis](https://github.com/kwatch/erubis) |
 | Erlang | [erlc](http://erlang.org/doc/man/erlc.html), [SyntaxErl](https://github.com/ten0s/syntaxerl) |
 | Fish | fish [-n flag](https://linux.die.net/man/1/fish)
 | Fortran | [gcc](https://gcc.gnu.org/), [language_server](https://github.com/hansec/fortran-language-server) |
 | Fountain | [proselint](http://proselint.com/) |
 | FusionScript | [fusion-lint](https://github.com/RyanSquared/fusionscript) |
 | Git Commit Messages | [gitlint](https://github.com/jorisroovers/gitlint) |
 | GLSL | [glslang](https://github.com/KhronosGroup/glslang), [glslls](https://github.com/svenstaro/glsl-language-server) |
 | Go | [gofmt](https://golang.org/cmd/gofmt/), [goimports](https://godoc.org/golang.org/x/tools/cmd/goimports), [go mod](https://golang.org/cmd/go/) !!, [go vet](https://golang.org/cmd/vet/) !!, [golint](https://godoc.org/github.com/golang/lint), [gotype](https://godoc.org/golang.org/x/tools/cmd/gotype) !!, [gometalinter](https://github.com/alecthomas/gometalinter) !!, [go build](https://golang.org/cmd/go/) !!, [gosimple](https://github.com/dominikh/go-tools/tree/master/cmd/gosimple) !!, [staticcheck](https://github.com/dominikh/go-tools/tree/master/cmd/staticcheck) !!, [golangserver](https://github.com/sourcegraph/go-langserver), [golangci-lint](https://github.com/golangci/golangci-lint) !! |
 | GraphQL | [eslint](http://eslint.org/), [gqlint](https://github.com/happylinks/gqlint), [prettier](https://github.com/prettier/prettier) |
 | Hack | [hack](http://hacklang.org/), [hackfmt](https://github.com/facebook/hhvm/tree/master/hphp/hack/hackfmt), [hhast](https://github.com/hhvm/hhast) (disabled by default; see `:help ale-integration-hack`) |
 | Haml | [haml-lint](https://github.com/brigade/haml-lint) |
 | Handlebars | [ember-template-lint](https://github.com/rwjblue/ember-template-lint) |
 | Haskell | [brittany](https://github.com/lspitzner/brittany), [ghc](https://www.haskell.org/ghc/), [cabal-ghc](https://www.haskell.org/cabal/), [stylish-haskell](https://github.com/jaspervdj/stylish-haskell), [stack-ghc](https://haskellstack.org/), [stack-build](https://haskellstack.org/) !!, [ghc-mod](https://github.com/DanielG/ghc-mod), [stack-ghc-mod](https://github.com/DanielG/ghc-mod), [hlint](https://hackage.haskell.org/package/hlint), [hdevtools](https://hackage.haskell.org/package/hdevtools), [hfmt](https://github.com/danstiner/hfmt), [hie](https://github.com/haskell/haskell-ide-engine) |
 | HTML | [alex](https://github.com/wooorm/alex) !!, [HTMLHint](http://htmlhint.com/), [proselint](http://proselint.com/), [tidy](http://www.html-tidy.org/), [write-good](https://github.com/btford/write-good) |
 | Idris | [idris](http://www.idris-lang.org/) |
 | Java | [checkstyle](http://checkstyle.sourceforge.net), [javac](http://www.oracle.com/technetwork/java/javase/downloads/index.html), [google-java-format](https://github.com/google/google-java-format), [PMD](https://pmd.github.io/), [javalsp](https://github.com/georgewfraser/vscode-javac), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | JavaScript | [eslint](http://eslint.org/), [flow](https://flowtype.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [prettier](https://github.com/prettier/prettier), [prettier-eslint](https://github.com/prettier/prettier-eslint-cli), [prettier-standard](https://github.com/sheerun/prettier-standard), [standard](http://standardjs.com/), [xo](https://github.com/sindresorhus/xo)
 | JSON | [fixjson](https://github.com/rhysd/fixjson), [jsonlint](http://zaa.ch/jsonlint/), [jq](https://stedolan.github.io/jq/), [prettier](https://github.com/prettier/prettier) |
 | Julia | [languageserver](https://github.com/JuliaEditorSupport/LanguageServer.jl) |
 | Kotlin | [kotlinc](https://kotlinlang.org) !!, [ktlint](https://ktlint.github.io) !!, [languageserver](https://github.com/fwcd/KotlinLanguageServer) see `:help ale-integration-kotlin` for configuration instructions |
 | LaTeX | [alex](https://github.com/wooorm/alex) !!, [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck), [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | Less | [lessc](https://www.npmjs.com/package/less), [prettier](https://github.com/prettier/prettier), [stylelint](https://github.com/stylelint/stylelint) |
 | LLVM | [llc](https://llvm.org/docs/CommandGuide/llc.html) |
 | Lua | [luac](https://www.lua.org/manual/5.1/luac.html), [luacheck](https://github.com/mpeterv/luacheck) |
 | Mail | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
 | Make | [checkmake](https://github.com/mrtazz/checkmake) |
 | Markdown | [alex](https://github.com/wooorm/alex) !!, [markdownlint](https://github.com/DavidAnson/markdownlint) !!, [mdl](https://github.com/mivok/markdownlint), [prettier](https://github.com/prettier/prettier), [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [remark-lint](https://github.com/wooorm/remark-lint), [textlint](https://textlint.github.io/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | MATLAB | [mlint](https://www.mathworks.com/help/matlab/ref/mlint.html) |
 | Mercury | [mmc](http://mercurylang.org) !! |
 | NASM | [nasm](https://www.nasm.us/) !! |
 | Nim | [nim check](https://nim-lang.org/docs/nimc.html) !! |
 | nix | [nix-instantiate](http://nixos.org/nix/manual/#sec-nix-instantiate) |
 | nroff | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good)|
 | Objective-C | [clang](http://clang.llvm.org/), [clangd](https://clang.llvm.org/extra/clangd.html), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | Objective-C++ | [clang](http://clang.llvm.org/), [clangd](https://clang.llvm.org/extra/clangd.html), [uncrustify](https://github.com/uncrustify/uncrustify) |
 | OCaml | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-ocaml-merlin` for configuration instructions, [ols](https://github.com/freebroccolo/ocaml-language-server), [ocamlformat](https://github.com/ocaml-ppx/ocamlformat) |
 | Pawn | [uncrustify](https://github.com/uncrustify/uncrustify) |
 | Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic), [perltidy](https://metacpan.org/pod/distribution/Perl-Tidy/bin/perltidy) |
 | PHP | [langserver](https://github.com/felixfbecker/php-language-server), [phan](https://github.com/phan/phan) see `:help ale-php-phan` to instructions, [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer), [phpmd](https://phpmd.org), [phpstan](https://github.com/phpstan/phpstan), [phpcbf](https://github.com/squizlabs/PHP_CodeSniffer), [php-cs-fixer](http://cs.sensiolabs.org/) |
 | PO | [alex](https://github.com/wooorm/alex) !!, [msgfmt](https://www.gnu.org/software/gettext/manual/html_node/msgfmt-Invocation.html), [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | Pod | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | Pony | [ponyc](https://github.com/ponylang/ponyc) |
 | proto | [protoc-gen-lint](https://github.com/ckaznocha/protoc-gen-lint) |
 | Pug | [pug-lint](https://github.com/pugjs/pug-lint) |
 | Puppet | [languageserver](https://github.com/lingua-pupuli/puppet-editor-services), [puppet](https://puppet.com), [puppet-lint](https://puppet-lint.com) |
 | Python | [autopep8](https://github.com/hhatto/autopep8), [black](https://github.com/ambv/black), [flake8](http://flake8.pycqa.org/en/latest/), [isort](https://github.com/timothycrosley/isort), [mypy](http://mypy-lang.org/), [prospector](https://github.com/PyCQA/prospector), [pycodestyle](https://github.com/PyCQA/pycodestyle), [pyls](https://github.com/palantir/python-language-server), [pyre](https://github.com/facebook/pyre-check), [pylint](https://www.pylint.org/) !!, [vulture](https://github.com/jendrikseipp/vulture) !!, [yapf](https://github.com/google/yapf) |
 | QML | [qmlfmt](https://github.com/jesperhh/qmlfmt), [qmllint](https://github.com/qt/qtdeclarative/tree/5.11/tools/qmllint) |
 | R | [lintr](https://github.com/jimhester/lintr) |
 | ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-reasonml-ols` for configuration instructions, [ols](https://github.com/freebroccolo/ocaml-language-server), [refmt](https://github.com/reasonml/reason-cli) |
 | reStructuredText | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [rstcheck](https://github.com/myint/rstcheck), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | Re:VIEW | [redpen](http://redpen.cc/) |
 | RPM spec | [rpmlint](https://github.com/rpm-software-management/rpmlint) (disabled by default; see `:help ale-integration-spec`) |
 | Ruby | [brakeman](http://brakemanscanner.org/) !!, [rails_best_practices](https://github.com/flyerhzm/rails_best_practices) !!, [reek](https://github.com/troessner/reek), [rubocop](https://github.com/bbatsov/rubocop), [ruby](https://www.ruby-lang.org), [rufo](https://github.com/ruby-formatter/rufo), [solargraph](https://solargraph.org) |
 | Rust |  cargo !! (see `:help ale-integration-rust` for configuration instructions), [rls](https://github.com/rust-lang-nursery/rls), [rustc](https://www.rust-lang.org/), [rustfmt](https://github.com/rust-lang-nursery/rustfmt) |
 | SASS | [sass-lint](https://www.npmjs.com/package/sass-lint), [stylelint](https://github.com/stylelint/stylelint) |
 | SCSS | [prettier](https://github.com/prettier/prettier), [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint), [stylelint](https://github.com/stylelint/stylelint) |
 | Scala | [fsc](https://www.scala-lang.org/old/sites/default/files/linuxsoft_archives/docu/files/tools/fsc.html), [sbtserver](https://www.scala-sbt.org/1.x/docs/sbt-server.html), [scalac](http://scala-lang.org), [scalafmt](https://scalameta.org/scalafmt/), [scalastyle](http://www.scalastyle.org)|
 | Slim | [slim-lint](https://github.com/sds/slim-lint) |
 | SML | [smlnj](http://www.smlnj.org/) |
 | Solidity | [solhint](https://github.com/protofire/solhint), [solium](https://github.com/duaraghav8/Solium) |
 | Stylus | [stylelint](https://github.com/stylelint/stylelint) |
 | SQL | [sqlint](https://github.com/purcell/sqlint), [sqlfmt](https://github.com/jackc/sqlfmt) |
 | Swift | [swiftlint](https://github.com/realm/SwiftLint), [swiftformat](https://github.com/nicklockwood/SwiftFormat) |
 | Tcl | [nagelfar](http://nagelfar.sourceforge.net) !! |
 | Terraform | [tflint](https://github.com/wata727/tflint) |
 | Texinfo | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good)|
 | Text^ | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [textlint](https://textlint.github.io/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | Thrift | [thrift](http://thrift.apache.org/) |
 | TypeScript | [eslint](http://eslint.org/), [prettier](https://github.com/prettier/prettier), [tslint](https://github.com/palantir/tslint), tsserver, typecheck |
 | VALA | [uncrustify](https://github.com/uncrustify/uncrustify) |
 | Verilog | [iverilog](https://github.com/steveicarus/iverilog), [verilator](http://www.veripool.org/projects/verilator/wiki/Intro) |
 | Vim | [vint](https://github.com/Kuniwak/vint) |
 | Vim help^ | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | Vue | [prettier](https://github.com/prettier/prettier), [vls](https://github.com/vuejs/vetur/tree/master/server) |
 | XHTML | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | XML | [xmllint](http://xmlsoft.org/xmllint.html) |
 | YAML | [prettier](https://github.com/prettier/prettier), [swaglint](https://github.com/byCedric/swaglint), [yamllint](https://yamllint.readthedocs.io/) |
 | YANG | [yang-lsp](https://github.com/theia-ide/yang-lsp) |
 <a name="usage"></a>
@@ -101,7 +214,7 @@ new buffers or as you make edits to your files.
 The behaviour of linting can be configured with a variety of options,
 documented in [the Vim help file](doc/ale.txt). For more information on the
 options ALE offers, consult `:help ale-options` for global options and `:help
-ale-integration-options` for options specified to particular linters.
+ale-linter-options` for options specified to particular linters.
 <a name="usage-fixing"></a>
@@ -159,44 +272,11 @@ ALE offers some support for completion via hijacking of omnicompletion while you
 type. All of ALE's completion information must come from Language Server
 Protocol linters, or from `tsserver` for TypeScript.
 ALE integrates with [Deoplete](https://github.com/Shougo/deoplete.nvim) as a
 completion source, named `'ale'`. You can configure Deoplete to only use ALE as
 the source of completion information, or mix it with other sources.
 ```vim
 " Use ALE and also some plugin 'foobar' as completion sources for all code.
 call deoplete#custom#option('sources', {
 \ '_': ['ale', 'foobar'],
 \})
 ```
 ALE also offers its own automatic completion support, which does not require any
 other plugins, and can be enabled by changing a setting before ALE is loaded.
 ```vim
 " Enable completion where available.
 " This setting must be set before ALE is loaded.
 "
 " You should not turn this setting on if you wish to use ALE as a completion
 " source for other completion plugins, like Deoplete.
 let g:ale_completion_enabled = 1
 ```
 ALE provides an omni-completion function you can use for triggering
 completion manually with `<C-x><C-o>`.
 ```vim
 set omnifunc=ale#completion#OmniFunc
 ```
 When working with TypeScript files, ALE supports automatic imports from
 external modules. This behavior is disabled by default and can be enabled by
 setting:
 ```vim
 let g:ale_completion_tsserver_autoimport = 1
 ```
 See `:help ale-completion` for more information.
 <a name="usage-go-to-definition"></a>
@@ -227,24 +307,11 @@ ALE supports "hover" information for printing brief information about symbols at
 the cursor taken from Language Server Protocol linters and `tsserver` with the
 `ALEHover` command.
-The information can be displayed in a `balloon` tooltip in Vim or GVim by
+On vim/gvim with `balloon` support you can see the information in a tooltip
-hovering your mouse over symbols. Mouse hovering is enabled by default in GVim,
+that appears under the mouse when you mouseover a symbol.
 and needs to be configured for Vim 8.1+ in terminals.
 See `:help ale-hover` for more information.
 <a name="usage-symbol-search"></a>
 ### 2.vii Symbol Search
 ALE supports searching for workspace symbols via Language Server Protocol
 linters with the `ALESymbolSearch` command.
 Search queries can be performed to find functions, types, and more which are
 similar to a given query string.
 See `:help ale-symbol-search` for more information.
 <a name="installation"></a>
 ## 3. Installation
@@ -266,14 +333,14 @@ any other tools. Simply clone the plugin into your `pack` directory.
 ```bash
 mkdir -p ~/.vim/pack/git-plugins/start
-git clone --depth 1 https://github.com/dense-analysis/ale.git ~/.vim/pack/git-plugins/start/ale
+git clone https://github.com/w0rp/ale.git ~/.vim/pack/git-plugins/start/ale
 ```
 #### NeoVim on Unix
 ```bash
 mkdir -p ~/.local/share/nvim/site/pack/git-plugins/start
-git clone --depth 1 https://github.com/dense-analysis/ale.git ~/.local/share/nvim/site/pack/git-plugins/start/ale
+git clone https://github.com/w0rp/ale.git ~/.local/share/nvim/site/pack/git-plugins/start/ale
 ```
 #### Vim 8 on Windows
@@ -281,7 +348,7 @@ git clone --depth 1 https://github.com/dense-analysis/ale.git ~/.local/share/nvi
 ```bash
 # Run these commands in the "Git for Windows" Bash terminal
 mkdir -p ~/vimfiles/pack/git-plugins/start
-git clone --depth 1 https://github.com/dense-analysis/ale.git ~/vimfiles/pack/git-plugins/start/ale
+git clone https://github.com/w0rp/ale.git ~/vimfiles/pack/git-plugins/start/ale
 ```
 #### Generating Vim help files
@@ -312,7 +379,7 @@ You can run the following commands in your terminal to do so:
 ```bash
 cd ~/.vim/bundle
-git clone https://github.com/dense-analysis/ale.git
+git clone https://github.com/w0rp/ale.git
 ```
 <a name="installation-with-vundle"></a>
@@ -323,36 +390,24 @@ You can install this plugin using [Vundle](https://github.com/VundleVim/Vundle.v
 by using the path on GitHub for this repository.
 ```vim
-Plugin 'dense-analysis/ale'
+Plugin 'w0rp/ale'
 ```
 See the Vundle documentation for more information.
 <a name="installation-with-vim-plug"></a>
 ### 3.iiii. Installation with Vim-Plug
 You can install this plugin using [Vim-Plug](https://github.com/junegunn/vim-plug)
 by adding the GitHub path for this repository to your `~/.vimrc`
 and running `:PlugInstall`.
 ```vim
 Plug 'dense-analysis/ale'
 ```
 <a name="contributing"></a>
 ## 4. Contributing
 If you would like to see support for more languages and tools, please
-[create an issue](https://github.com/dense-analysis/ale/issues)
+[create an issue](https://github.com/w0rp/ale/issues)
-or [create a pull request](https://github.com/dense-analysis/ale/pulls).
+or [create a pull request](https://github.com/w0rp/ale/pulls).
 If your tool can read from stdin or you have code to suggest which is good,
 support can be happily added for it.
 If you are interested in the general direction of the project, check out the
-[wiki home page](https://github.com/dense-analysis/ale/wiki). The wiki includes
+[wiki home page](https://github.com/w0rp/ale/wiki). The wiki includes a
-a Roadmap for the future, and more.
+Roadmap for the future, and more.
 If you'd liked to discuss the project more directly, check out the `#vim-ale` channel
 on Freenode. Web chat is available [here](https://webchat.freenode.net/?channels=vim-ale).
@@ -481,16 +536,8 @@ let g:airline#extensions#ale#enabled = 1
 ```
 If you don't want to use vim-airline, you can implement your own statusline
-function without adding any other plugins. ALE provides some functions to
+function without adding any other plugins. ALE provides a function for counting
-assist in this endeavour, including:
+the number of problems for this purpose, named `ale#statusline#Count`.
 * `ale#statusline#Count`: Which returns the number of problems found by ALE
  for a specified buffer.
 * `ale#statusline#FirstProblem`: Which returns a dictionary containing the
  full loclist details of the first problem of a specified type found by ALE
  in a buffer. (e.g. The first style warning in the current buffer.)
  This can be useful for displaying more detailed information such as the
  line number of the first problem in a file.
 Say you want to display all errors as one figure, and all non-errors as another
 figure. You can do the following:
@@ -512,8 +559,7 @@ endfunction
 set statusline=%{LinterStatus()}
 ```
-See `:help ale#statusline#Count()` or `:help ale#statusline#FirstProblem()`
+See `:help ale#statusline#Count()` for more information.
 for more information.
 <a name="faq-lightline"></a>
@@ -535,7 +581,7 @@ There are 3 global options that allow customizing the echoed message.
    * `%...code...%` is an optional error code, and most characters can be
      written between the `%` characters.
    * `%linter%` is the linter name
-    * `%severity%` is the severity type
+    * `%severity` is the severity type
 - `g:ale_echo_msg_error_str` is the string used for error severity.
 - `g:ale_echo_msg_warning_str` is the string used for warning severity.
@@ -549,7 +595,7 @@ let g:ale_echo_msg_format = '[%linter%] %s [%severity%]'
 Will give you:
-![Echoed message](https://user-images.githubusercontent.com/3518142/59195927-348bd000-8b85-11e9-88b6-508a094f1548.png)
+![Echoed message](img/echo.png)
 See `:help g:ale_echo_msg_format` for more information.
@@ -604,7 +650,6 @@ options off.
 ```vim
 " Write this in your vimrc file
 let g:ale_lint_on_text_changed = 'never'
 let g:ale_lint_on_insert_leave = 0
 " You can disable this option too
 " if you don't want linters to run on opening a file
 let g:ale_lint_on_enter = 0
@@ -668,16 +713,16 @@ options in a jsx.vim ftplugin file.
 ```vim
 " In ~/.vim/ftplugin/jsx.vim, or somewhere similar.
 let b:ale_linter_aliases = ['css', 'javascript']
 let b:ale_linters = ['stylelint', 'eslint']
 let b:ale_linter_aliases = ['css']
 ```
 Or if you want, you can configure the linters from your vimrc file.
 ```vim
 " In ~/.vim/vimrc, or somewhere similar.
 let g:ale_linter_aliases = {'jsx': ['css', 'javascript']}
 let g:ale_linters = {'jsx': ['stylelint', 'eslint']}
 let g:ale_linter_aliases = {'jsx': 'css'}
 ```
 ALE will alias the `jsx` filetype so it uses the `css` filetype linters, and
@@ -685,40 +730,9 @@ use the original Array of selected linters for `jsx` from the `g:ale_linters`
 object. All available linters will be used for the filetype `javascript`, and
 no linter will be run twice for the same file.
 <a name="faq-vue-eslint"></a>
 ### 5.xiii. How can I check Vue files with ESLint?
 To check Vue files with ESLint, your ESLint project configuration file must be
 configured to use the [Vue plugin](https://github.com/vuejs/eslint-plugin-vue).
 After that, you need to configure ALE so it will run the JavaScript ESLint
 linter on your files. The settings you need are similar to the settings needed
 for checking JSX code with both stylelint and ESLint, in the previous section.
 ```vim
 " In ~/.vim/ftplugin/vue.vim, or somewhere similar.
 " Run both javascript and vue linters for vue files.
 let b:ale_linter_aliases = ['javascript', 'vue']
 " Select the eslint and vls linters.
 let b:ale_linters = ['eslint', 'vls']
 ```
 Run `:ALEInfo` to see which linters are available after telling ALE to run
 JavaScript linters on Vue files. Not all linters support checking Vue files.
 If you don't want to configure your linters in ftplugin files for some reason,
 you can configure them from your vimrc file instead.
 ```vim
 " In ~/.vim/vimrc, or somewhere similar.
 let g:ale_linter_aliases = {'vue': ['vue', 'javascript']}
 let g:ale_linters = {'vue': ['eslint', 'vls']}
 ```
 <a name="faq-my-battery-is-sad"></a>
-### 5.xiv. Will this plugin eat all of my laptop battery power?
+### 5.xiii. Will this plugin eat all of my laptop battery power?
 ALE takes advantage of the power of various tools to check your code. This of
 course means that CPU time will be used to continuously check your code. If you
@@ -731,10 +745,11 @@ while you type. ALE uses a timeout which is cancelled and reset every time you
 type, and this delay can be increased so linters are run less often. See
 `:help g:ale_lint_delay` for more information.
-If you don't wish to run linters while you type, you can disable that behaviour.
+If you don't wish to run linters while you type, you can disable that
-Set `g:ale_lint_on_text_changed` to `never`. You won't get as frequent error
+behaviour. Set `g:ale_lint_on_text_changed` to `never` or `normal`. You won't
-checking, but ALE shouldn't block your ability to edit a document after you save
+get as frequent error checking, but ALE shouldn't block your ability to edit a
-a file, so the asynchronous nature of the plugin will still be an advantage.
+document after you save a file, so the asynchronous nature of the plugin will
 still be an advantage.
 If you are still concerned, you can turn the automatic linting off altogether,
 including the option `g:ale_lint_on_enter`, and you can run ALE manually with
@@ -742,7 +757,7 @@ including the option `g:ale_lint_on_enter`, and you can run ALE manually with
 <a name="faq-c-configuration"></a>
-### 5.xv. How can I configure my C or C++ project?
+### 5.xiv. How can I configure my C or C++ project?
 The structure of C and C++ projects varies wildly from project to project, with
 many different build tools being used for building them, and many different
@@ -768,7 +783,7 @@ used for executing local vimrc files which can be shared in your project.
 <a name="faq-buffer-configuration"></a>
-### 5.xvi. How can I configure ALE differently for different buffers?
+### 5.xv. How can I configure ALE differently for different buffers?
 ALE offers various ways to configure which linters or fixers are run, and
 other settings. For the majority of ALE's settings, they can either be
@@ -804,7 +819,7 @@ Buffer-local variables for settings always override the global settings.
 <a name="faq-list-window-height"></a>
-### 5.xvii. How can I configure the height of the list in which ALE displays errors?
+### 5.xvi. How can I configure the height of the list in which ALE displays errors?
 To set a default height for the error list, use the `g:ale_list_window_size` variable.
@@ -812,13 +827,3 @@ To set a default height for the error list, use the `g:ale_list_window_size` var
 " Show 5 lines of errors (default: 10)
 let g:ale_list_window_size = 5
 ```
 <a name="faq-get-info"></a>
 ### 5.xviii. How can I see what ALE has configured for the current file?
 Run the following to see what is currently configured:
 ```vim
 :ALEInfo
 ```
--- a/ale_linters/ada/gcc.vim
+++ b/ale_linters/ada/gcc.vim
@@ -1,54 +0,0 @@
 " Author: Martino Pilia <martino.pilia@gmail.com>
 " Description: Lint Ada files with GCC
 call ale#Set('ada_gcc_executable', 'gcc')
 " -gnatwa: activate most optional warnings
 " -gnatq: try semantic analysis even if syntax errors have been found
 call ale#Set('ada_gcc_options', '-gnatwa -gnatq')
 function! ale_linters#ada#gcc#GetCommand(buffer) abort
    " Build a suitable output file name. The output file is specified because
    " the .ali file may be created even if no code generation is attempted.
    " The output file name must match the source file name (except for the
    " extension), so here we cannot use the null file as output.
    let l:tmp_dir = fnamemodify(ale#command#CreateDirectory(a:buffer), ':p')
    let l:out_file = l:tmp_dir . fnamemodify(bufname(a:buffer), ':t:r') . '.o'
    " -gnatc: Check syntax and semantics only (no code generation attempted)
    return '%e -x ada -c -gnatc'
    \   . ' -o ' . ale#Escape(l:out_file)
    \   . ' -I ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
    \   . ale#Pad(ale#Var(a:buffer, 'ada_gcc_options'))
    \   . ' %t'
 endfunction
 " For the message format please refer to:
 "   https://gcc.gnu.org/onlinedocs/gnat_ugn/Output-and-Error-Message-Control.html
 "   https://gcc.gnu.org/onlinedocs/gnat_ugn/Warning-Message-Control.html
 function! ale_linters#ada#gcc#Handle(buffer, lines) abort
    " Error format: <filename>:<lnum>:<col>: <text>
    " Warning format: <filename>:<lnum>:<col>: warning: <text>
    let l:re = '\v(.+):([0-9]+):([0-9]+):\s+(warning:)?\s*(.+)\s*'
    let l:output = []
    for l:match in ale#util#GetMatches(a:lines, l:re)
        call add(l:output, {
        \   'bufnr': a:buffer,
        \   'lnum': str2nr(l:match[2]),
        \   'col': str2nr(l:match[3]),
        \   'type': l:match[4] is# 'warning:' ? 'W' : 'E',
        \   'text': l:match[5],
        \})
    endfor
    return l:output
 endfunction
 call ale#linter#Define('ada', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
 \   'executable': {b -> ale#Var(b, 'ada_gcc_executable')},
 \   'command': function('ale_linters#ada#gcc#GetCommand'),
 \   'callback': 'ale_linters#ada#gcc#Handle',
 \})
--- a/ale_linters/ansible/ansible_lint.vim
+++ b/ale_linters/ansible/ansible_lint.vim
@@ -1,12 +1,6 @@
 " Author: Bjorn Neergaard <bjorn@neersighted.com>
 " Description: ansible-lint for ansible-yaml files
 call ale#Set('ansible_ansible_lint_executable', 'ansible-lint')
 function! ale_linters#ansible#ansible_lint#GetExecutable(buffer) abort
    return ale#Var(a:buffer, 'ansible_ansible_lint_executable')
 endfunction
 function! ale_linters#ansible#ansible_lint#Handle(buffer, lines) abort
    for l:line in a:lines[:10]
        if match(l:line, '^Traceback') >= 0
@@ -48,9 +42,8 @@ function! ale_linters#ansible#ansible_lint#Handle(buffer, lines) abort
 endfunction
 call ale#linter#Define('ansible', {
-\   'name': 'ansible_lint',
+\   'name': 'ansible',
-\   'aliases': ['ansible', 'ansible-lint'],
+\   'executable': 'ansible',
-\   'executable': function('ale_linters#ansible#ansible_lint#GetExecutable'),
+\   'command': 'ansible-lint -p %t',
 \   'command': '%e -p %t',
 \   'callback': 'ale_linters#ansible#ansible_lint#Handle',
 \})
--- a/ale_linters/asciidoc/alex.vim
+++ b/ale_linters/asciidoc/alex.vim
@@ -1,4 +1,11 @@
 " Author: Johannes Wienke <languitar@semipol.de>
 " Description: alex for asciidoc files
-call ale#handlers#alex#DefineLinter('asciidoc', '--text')
+call ale#linter#Define('help', {
 \   'name': 'alex',
 \   'executable': 'alex',
 \   'command': 'alex %s -t',
 \   'output_stream': 'stderr',
 \   'callback': 'ale#handlers#alex#Handle',
 \   'lint_file': 1,
 \})
--- a/ale_linters/asciidoc/textlint.vim
+++ b/ale_linters/asciidoc/textlint.vim
@@ -1,9 +0,0 @@
 " Author: TANIGUCHI Masaya <ta2gch@gmail.com>
 " Description: textlint for AsciiDoc files
 call ale#linter#Define('asciidoc', {
 \   'name': 'textlint',
 \   'executable': function('ale#handlers#textlint#GetExecutable'),
 \   'command': function('ale#handlers#textlint#GetCommand'),
 \   'callback': 'ale#handlers#textlint#HandleTextlintOutput',
 \})
--- a/ale_linters/asciidoc/vale.vim
+++ b/ale_linters/asciidoc/vale.vim
@@ -1,9 +0,0 @@
 " Author: Jeff Kreeftmeijer https://github.com/jeffkreeftmeijer
 " Description: vale for AsciiDoc files
 call ale#linter#Define('asciidoc', {
 \   'name': 'vale',
 \   'executable': 'vale',
 \   'command': 'vale --output=line %t',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})
--- a/ale_linters/asm/gcc.vim
+++ b/ale_linters/asm/gcc.vim
@@ -5,10 +5,7 @@ call ale#Set('asm_gcc_executable', 'gcc')
 call ale#Set('asm_gcc_options', '-Wall')
 function! ale_linters#asm#gcc#GetCommand(buffer) abort
-    " `-o /dev/null` or `-o null` is needed to catch all errors,
+    return '%e -x assembler -fsyntax-only '
    " -fsyntax-only doesn't catch everything.
    return '%e -x assembler'
    \   . ' -o ' . g:ale#util#nul_file
    \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
    \   . ' ' . ale#Var(a:buffer, 'asm_gcc_options') . ' -'
 endfunction
@@ -31,7 +28,7 @@ endfunction
 call ale#linter#Define('asm', {
 \    'name': 'gcc',
 \    'output_stream': 'stderr',
-\    'executable': {b -> ale#Var(b, 'asm_gcc_executable')},
+\    'executable_callback': ale#VarFunc('asm_gcc_executable'),
-\    'command': function('ale_linters#asm#gcc#GetCommand'),
+\    'command_callback': 'ale_linters#asm#gcc#GetCommand',
 \    'callback': 'ale_linters#asm#gcc#Handle',
 \})
--- a/ale_linters/awk/gawk.vim
+++ b/ale_linters/awk/gawk.vim
@@ -15,8 +15,8 @@ endfunction
 call ale#linter#Define('awk', {
 \   'name': 'gawk',
-\   'executable': {b -> ale#Var(b, 'awk_gawk_executable')},
+\   'executable_callback': ale#VarFunc('awk_gawk_executable'),
-\   'command': function('ale_linters#awk#gawk#GetCommand'),
+\   'command_callback': 'ale_linters#awk#gawk#GetCommand',
 \   'callback': 'ale#handlers#gawk#HandleGawkFormat',
 \   'output_stream': 'both'
 \})
--- a/ale_linters/bib/bibclean.vim
+++ b/ale_linters/bib/bibclean.vim
@@ -1,75 +0,0 @@
 " Author: Horacio Sanson - https://github.com/hsanson
 " Description: Support for bibclean linter for BibTeX files.
 call ale#Set('bib_bibclean_executable', 'bibclean')
 function! ale_linters#bib#bibclean#GetCommand(buffer) abort
    let l:executable = ale#Var(a:buffer, 'bib_bibclean_executable')
    return ale#Escape(l:executable) . ' -file-position '
 endfunction
 function! ale_linters#bib#bibclean#get_type(str) abort
    if a:str is# '??'
        return 'E'
    else
        return 'W'
    endif
 endfunction
 function! ale_linters#bib#bibclean#match_msg(line) abort
    return matchlist(a:line, '^\(.*\) "stdin", line \(.*\): \(.*\)$')
 endfunction
 function! ale_linters#bib#bibclean#match_entry(line) abort
    return matchlist(a:line, 'Entry   input byte=.* line=\(.*\) column=\(.*\) output .*$')
 endfunction
 function! ale_linters#bib#bibclean#match_value(line) abort
    return matchlist(a:line, 'Value   input byte=.* line=\(.*\) column=\(.*\) output .*$')
 endfunction
 function! ale_linters#bib#bibclean#Handle(buffer, lines) abort
    let l:output = []
    let l:type = 'E'
    let l:msg  = ''
    for l:line in a:lines
        if empty(l:msg)
            let l:mlist = ale_linters#bib#bibclean#match_msg(l:line)
            if !empty(l:mlist)
                let l:msg = l:mlist[3]
                let l:type = ale_linters#bib#bibclean#get_type(l:mlist[1])
            endif
        else
            if l:type is# 'E'
                let l:mlist = ale_linters#bib#bibclean#match_entry(l:line)
            else
                let l:mlist = ale_linters#bib#bibclean#match_value(l:line)
            endif
            if !empty(l:mlist)
                call add(l:output, {
                \ 'lnum': l:mlist[1],
                \ 'col': l:mlist[2],
                \ 'text': l:msg,
                \ 'type': l:type
                \})
                let l:msg = ''
            endif
        endif
    endfor
    return l:output
 endfunction
 call ale#linter#Define('bib', {
 \   'name': 'bibclean',
 \   'executable': {b -> ale#Var(b, 'bib_bibclean_executable')},
 \   'command': function('ale_linters#bib#bibclean#GetCommand'),
 \   'output_stream': 'stderr',
 \   'callback': 'ale_linters#bib#bibclean#Handle',
 \})
--- a/ale_linters/c/ccls.vim
+++ b/ale_linters/c/ccls.vim
@@ -1,14 +0,0 @@
 " Author: Ye Jingchen <ye.jingchen@gmail.com>, Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
 " Description: A language server for C
 call ale#Set('c_ccls_executable', 'ccls')
 call ale#Set('c_ccls_init_options', {})
 call ale#linter#Define('c', {
 \   'name': 'ccls',
 \   'lsp': 'stdio',
 \   'executable': {b -> ale#Var(b, 'c_ccls_executable')},
 \   'command': '%e',
 \   'project_root': function('ale#handlers#ccls#GetProjectRoot'),
 \   'initialization_options': {b -> ale#Var(b, 'c_ccls_init_options')},
 \})
--- a/ale_linters/c/clang.vim
+++ b/ale_linters/c/clang.vim
@@ -18,7 +18,10 @@ endfunction
 call ale#linter#Define('c', {
 \   'name': 'clang',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'c_clang_executable')},
+\   'executable_callback': ale#VarFunc('c_clang_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#clang#GetCommand'))},
+\   'command_chain': [
 \       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#c#clang#GetCommand'}
 \   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
 \})
--- a/ale_linters/c/clangd.vim
+++ b/ale_linters/c/clangd.vim
@@ -4,6 +4,12 @@
 call ale#Set('c_clangd_executable', 'clangd')
 call ale#Set('c_clangd_options', '')
 function! ale_linters#c#clangd#GetProjectRoot(buffer) abort
    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
 endfunction
 function! ale_linters#c#clangd#GetCommand(buffer) abort
    return '%e' . ale#Pad(ale#Var(a:buffer, 'c_clangd_options'))
 endfunction
@@ -11,7 +17,7 @@ endfunction
 call ale#linter#Define('c', {
 \   'name': 'clangd',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'c_clangd_executable')},
+\   'executable_callback': ale#VarFunc('c_clangd_executable'),
-\   'command': function('ale_linters#c#clangd#GetCommand'),
+\   'command_callback': 'ale_linters#c#clangd#GetCommand',
-\   'project_root': function('ale#c#FindProjectRoot'),
+\   'project_root_callback': 'ale_linters#c#clangd#GetProjectRoot',
 \})
--- a/ale_linters/c/clangtidy.vim
+++ b/ale_linters/c/clangtidy.vim
@@ -10,33 +10,23 @@ call ale#Set('c_clangtidy_executable', 'clang-tidy')
 " Consult the check list in clang-tidy's documentation:
 " http://clang.llvm.org/extra/clang-tidy/checks/list.html
-call ale#Set('c_clangtidy_checks', [])
+call ale#Set('c_clangtidy_checks', ['*'])
-" Set this option to manually set some options for clang-tidy to use as compile
+" Set this option to manually set some options for clang-tidy.
 " flags.
 " This will disable compile_commands.json detection.
 call ale#Set('c_clangtidy_options', '')
 " Set this option to manually set options for clang-tidy directly.
 call ale#Set('c_clangtidy_extra_options', '')
 call ale#Set('c_build_dir', '')
-function! ale_linters#c#clangtidy#GetCommand(buffer, output) abort
+function! ale_linters#c#clangtidy#GetCommand(buffer) abort
    let l:checks = join(ale#Var(a:buffer, 'c_clangtidy_checks'), ',')
    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
    let l:options = ''
    " Get the extra options if we couldn't find a build directory.
-    if empty(l:build_dir)
+    let l:options = empty(l:build_dir)
-        let l:options = ale#Var(a:buffer, 'c_clangtidy_options')
+    \   ? ale#Var(a:buffer, 'c_clangtidy_options')
-        let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    \   : ''
        let l:options .= !empty(l:options) ? ale#Pad(l:cflags) : l:cflags
    endif
    " Get the options to pass directly to clang-tidy
    let l:extra_options = ale#Var(a:buffer, 'c_clangtidy_extra_options')
    return '%e'
    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
    \   . (!empty(l:extra_options) ? ' ' . ale#Escape(l:extra_options) : '')
    \   . ' %s'
    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
    \   . (!empty(l:options) ? ' -- ' . l:options : '')
@@ -45,8 +35,8 @@ endfunction
 call ale#linter#Define('c', {
 \   'name': 'clangtidy',
 \   'output_stream': 'stdout',
-\   'executable': {b -> ale#Var(b, 'c_clangtidy_executable')},
+\   'executable_callback': ale#VarFunc('c_clangtidy_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#clangtidy#GetCommand'))},
+\   'command_callback': 'ale_linters#c#clangtidy#GetCommand',
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/c/cppcheck.vim
+++ b/ale_linters/c/cppcheck.vim
@@ -5,24 +5,30 @@ call ale#Set('c_cppcheck_executable', 'cppcheck')
 call ale#Set('c_cppcheck_options', '--enable=style')
 function! ale_linters#c#cppcheck#GetCommand(buffer) abort
-    let l:cd_command = ale#handlers#cppcheck#GetCdCommand(a:buffer)
+    " Search upwards from the file for compile_commands.json.
-    let l:compile_commands_option = ale#handlers#cppcheck#GetCompileCommandsOptions(a:buffer)
+    "
-    let l:buffer_path_include = empty(l:compile_commands_option)
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
-    \   ? ale#handlers#cppcheck#GetBufferPathIncludeOptions(a:buffer)
+    " then use the file to set up import paths, etc.
    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    let l:cd_command = !empty(l:compile_commmands_path)
    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
    \   : ''
    let l:compile_commands_option = !empty(l:compile_commmands_path)
    \   ? '--project=compile_commands.json '
    \   : ''
    return l:cd_command
-    \   . '%e -q --language=c'
+    \   . '%e -q --language=c '
-    \   . ale#Pad(l:compile_commands_option)
+    \   . l:compile_commands_option
-    \   . ale#Pad(ale#Var(a:buffer, 'c_cppcheck_options'))
+    \   . ale#Var(a:buffer, 'c_cppcheck_options')
    \   . l:buffer_path_include
    \   . ' %t'
 endfunction
 call ale#linter#Define('c', {
 \   'name': 'cppcheck',
 \   'output_stream': 'both',
-\   'executable': {b -> ale#Var(b, 'c_cppcheck_executable')},
+\   'executable_callback': ale#VarFunc('c_cppcheck_executable'),
-\   'command': function('ale_linters#c#cppcheck#GetCommand'),
+\   'command_callback': 'ale_linters#c#cppcheck#GetCommand',
 \   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
 \})
--- a/ale_linters/c/cquery.vim
+++ b/ale_linters/c/cquery.vim
@@ -5,15 +5,13 @@ call ale#Set('c_cquery_executable', 'cquery')
 call ale#Set('c_cquery_cache_directory', expand('~/.cache/cquery'))
 function! ale_linters#c#cquery#GetProjectRoot(buffer) abort
-    " Try to find cquery configuration files first.
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    let l:config = ale#path#FindNearestFile(a:buffer, '.cquery')
-    if !empty(l:config)
+    if empty(l:project_root)
-        return fnamemodify(l:config, ':h')
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
    endif
-    " Fall back on default project root detection.
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
    return ale#c#FindProjectRoot(a:buffer)
 endfunction
 function! ale_linters#c#cquery#GetInitializationOptions(buffer) abort
@@ -23,8 +21,8 @@ endfunction
 call ale#linter#Define('c', {
 \   'name': 'cquery',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'c_cquery_executable')},
+\   'executable_callback': ale#VarFunc('c_cquery_executable'),
 \   'command': '%e',
-\   'project_root': function('ale_linters#c#cquery#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#c#cquery#GetProjectRoot',
-\   'initialization_options': function('ale_linters#c#cquery#GetInitializationOptions'),
+\   'initialization_options_callback': 'ale_linters#c#cquery#GetInitializationOptions',
 \})
--- a/ale_linters/c/flawfinder.vim
+++ b/ale_linters/c/flawfinder.vim
@@ -7,19 +7,19 @@ call ale#Set('c_flawfinder_minlevel', 1)
 call ale#Set('c_flawfinder_error_severity', 6)
 function! ale_linters#c#flawfinder#GetCommand(buffer) abort
-    " Set the minimum vulnerability level for flawfinder to bother with
+   " Set the minimum vulnerability level for flawfinder to bother with
-    let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'c_flawfinder_minlevel')
+   let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'c_flawfinder_minlevel')
-    return '%e -CDQS'
+   return '%e -CDQS'
-    \  . ale#Pad(ale#Var(a:buffer, 'c_flawfinder_options'))
+   \  . ale#Pad(ale#Var(a:buffer, 'c_flawfinder_options'))
-    \  . l:minlevel
+   \  . l:minlevel
-    \  . ' %t'
+   \  . ' %t'
 endfunction
 call ale#linter#Define('c', {
 \  'name': 'flawfinder',
 \  'output_stream': 'stdout',
-\  'executable': {b -> ale#Var(b, 'c_flawfinder_executable')},
+\  'executable_callback': ale#VarFunc('c_flawfinder_executable'),
-\  'command': function('ale_linters#c#flawfinder#GetCommand'),
+\  'command_callback': 'ale_linters#c#flawfinder#GetCommand',
 \  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
 \})
--- a/ale_linters/c/gcc.vim
+++ b/ale_linters/c/gcc.vim
@@ -9,11 +9,7 @@ function! ale_linters#c#gcc#GetCommand(buffer, output) abort
    " -iquote with the directory the file is in makes #include work for
    "  headers in the same directory.
-    "
+    return '%e -S -x c -fsyntax-only'
    " `-o /dev/null` or `-o null` is needed to catch all errors,
    " -fsyntax-only doesn't catch everything.
    return '%e -S -x c'
    \   . ' -o ' . g:ale#util#nul_file
    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
    \   . ale#Pad(l:cflags)
    \   . ale#Pad(ale#Var(a:buffer, 'c_gcc_options')) . ' -'
@@ -22,7 +18,10 @@ endfunction
 call ale#linter#Define('c', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'c_gcc_executable')},
+\   'executable_callback': ale#VarFunc('c_gcc_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#c#gcc#GetCommand'))},
+\   'command_chain': [
 \       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#c#gcc#GetCommand'}
 \   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
 \})
--- a/ale_linters/chef/cookstyle.vim
+++ b/ale_linters/chef/cookstyle.vim
@@ -1,54 +0,0 @@
 " Author: Raphael Hoegger - https://github.com/pfuender
 " Description: Cookstyle (RuboCop based), a code style analyzer for Ruby files
 call ale#Set('chef_cookstyle_executable', 'cookstyle')
 call ale#Set('chef_cookstyle_options', '')
 function! ale_linters#chef#cookstyle#GetCommand(buffer) abort
    let l:options = ale#Var(a:buffer, 'chef_cookstyle_options')
    return '%e' . ale#Pad(escape(l:options, '~')) . ' --force-exclusion --format json --stdin ' . ' %s'
 endfunction
 function! ale_linters#chef#cookstyle#Handle(buffer, lines) abort
    if len(a:lines) == 0
        return []
    endif
    let l:errors = ale#util#FuzzyJSONDecode(a:lines[0], {})
    if !has_key(l:errors, 'summary')
    \|| l:errors['summary']['offense_count'] == 0
    \|| empty(l:errors['files'])
        return []
    endif
    let l:output = []
    for l:error in l:errors['files'][0]['offenses']
        let l:start_col = str2nr(l:error['location']['start_column'])
        let l:end_col = str2nr(l:error['location']['last_column'])
        if !l:end_col
            let l:end_col = l:start_col + 1
        endif
        call add(l:output, {
        \   'lnum': str2nr(l:error['location']['line']),
        \   'col': l:start_col,
        \   'end_col': l:end_col,
        \   'code': l:error['cop_name'],
        \   'text': l:error['message'],
        \   'type': l:error['severity'] is? 'convention' ? 'W' : 'E',
        \})
    endfor
    return l:output
 endfunction
 call ale#linter#Define('chef', {
 \   'name': 'cookstyle',
 \   'executable': {b -> ale#Var(b, 'chef_cookstyle_executable')},
 \   'command': function('ale_linters#chef#cookstyle#GetCommand'),
 \   'callback': 'ale_linters#chef#cookstyle#Handle',
 \})
--- a/ale_linters/chef/foodcritic.vim
+++ b/ale_linters/chef/foodcritic.vim
@@ -34,8 +34,8 @@ endfunction
 call ale#linter#Define('chef', {
 \   'name': 'foodcritic',
-\   'executable': {b -> ale#Var(b, 'chef_foodcritic_executable')},
+\   'executable_callback': ale#VarFunc('chef_foodcritic_executable'),
-\   'command': function('ale_linters#chef#foodcritic#GetCommand'),
+\   'command_callback': 'ale_linters#chef#foodcritic#GetCommand',
 \   'callback': 'ale_linters#chef#foodcritic#Handle',
 \   'lint_file': 1,
 \})
--- a/ale_linters/clojure/clj_kondo.vim
+++ b/ale_linters/clojure/clj_kondo.vim
@@ -1,34 +0,0 @@
 " Author: Masashi Iizuka <liquidz.uo@gmail.com>
 " Description: linter for clojure using clj-kondo https://github.com/borkdude/clj-kondo
 function! ale_linters#clojure#clj_kondo#HandleCljKondoFormat(buffer, lines) abort
    " output format
    " <filename>:<line>:<column>: <issue type>: <message>
    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):(\d+):? ((Exception|error|warning): ?(.+))$'
    let l:output = []
    for l:match in ale#util#GetMatches(a:lines, l:pattern)
        let l:type = 'E'
        if l:match[4] is? 'warning'
            let l:type = 'W'
        endif
        call add(l:output, {
        \   'lnum': l:match[1] + 0,
        \   'col': l:match[2] + 0,
        \   'text': l:match[3],
        \   'type': l:type,
        \})
    endfor
    return l:output
 endfunction
 call ale#linter#Define('clojure', {
 \   'name': 'clj-kondo',
 \   'output_stream': 'stdout',
 \   'executable': 'clj-kondo',
 \   'command': 'clj-kondo --lint %t',
 \   'callback': 'ale_linters#clojure#clj_kondo#HandleCljKondoFormat',
 \})
--- a/ale_linters/clojure/joker.vim
+++ b/ale_linters/clojure/joker.vim
@@ -11,7 +11,7 @@ function! ale_linters#clojure#joker#HandleJokerFormat(buffer, lines) abort
        let l:type = 'E'
        if l:match[4] is? 'Parse warning'
-            let l:type = 'W'
+          let l:type = 'W'
        endif
        call add(l:output, {
--- a/ale_linters/cmake/cmakelint.vim
+++ b/ale_linters/cmake/cmakelint.vim
@@ -18,7 +18,7 @@ endfunction
 call ale#linter#Define('cmake', {
 \   'name': 'cmakelint',
-\   'executable': function('ale_linters#cmake#cmakelint#Executable'),
+\   'executable_callback': 'ale_linters#cmake#cmakelint#Executable',
-\   'command': function('ale_linters#cmake#cmakelint#Command'),
+\   'command_callback': 'ale_linters#cmake#cmakelint#Command',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})
--- a/ale_linters/coffee/coffee.vim
+++ b/ale_linters/coffee/coffee.vim
@@ -16,8 +16,8 @@ endfunction
 call ale#linter#Define('coffee', {
 \   'name': 'coffee',
-\   'executable': function('ale_linters#coffee#coffee#GetExecutable'),
+\   'executable_callback': 'ale_linters#coffee#coffee#GetExecutable',
-\   'command': function('ale_linters#coffee#coffee#GetCommand'),
+\   'command_callback': 'ale_linters#coffee#coffee#GetCommand',
 \   'output_stream': 'stderr',
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})
--- a/ale_linters/coffee/coffeelint.vim
+++ b/ale_linters/coffee/coffeelint.vim
@@ -37,7 +37,7 @@ endfunction
 call ale#linter#Define('coffee', {
 \   'name': 'coffeelint',
-\   'executable': function('ale_linters#coffee#coffeelint#GetExecutable'),
+\   'executable_callback': 'ale_linters#coffee#coffeelint#GetExecutable',
-\   'command': function('ale_linters#coffee#coffeelint#GetCommand'),
+\   'command_callback': 'ale_linters#coffee#coffeelint#GetCommand',
 \   'callback': 'ale_linters#coffee#coffeelint#Handle',
 \})
--- a/ale_linters/cpp/ccls.vim
+++ b/ale_linters/cpp/ccls.vim
@@ -1,14 +0,0 @@
 " Author: Ye Jingchen <ye.jingchen@gmail.com>, Ben Falconer <ben@falconers.me.uk>, jtalowell <jtalowell@protonmail.com>
 " Description: A language server for C++
 call ale#Set('cpp_ccls_executable', 'ccls')
 call ale#Set('cpp_ccls_init_options', {})
 call ale#linter#Define('cpp', {
 \   'name': 'ccls',
 \   'lsp': 'stdio',
 \   'executable': {b -> ale#Var(b, 'cpp_ccls_executable')},
 \   'command': '%e',
 \   'project_root': function('ale#handlers#ccls#GetProjectRoot'),
 \   'initialization_options': {b -> ale#Var(b, 'cpp_ccls_init_options')},
 \})
--- a/ale_linters/cpp/clang.vim
+++ b/ale_linters/cpp/clang.vim
@@ -18,7 +18,10 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'clang',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cpp_clang_executable')},
+\   'executable_callback': ale#VarFunc('cpp_clang_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#clang#GetCommand'))},
+\   'command_chain': [
 \       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#cpp#clang#GetCommand'},
 \   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
 \})
--- a/ale_linters/cpp/clangcheck.vim
+++ b/ale_linters/cpp/clangcheck.vim
@@ -12,8 +12,7 @@ function! ale_linters#cpp#clangcheck#GetCommand(buffer) abort
    let l:build_dir = ale#Var(a:buffer, 'c_build_dir')
    if empty(l:build_dir)
-        let [l:root, l:json_file] = ale#c#FindCompileCommands(a:buffer)
+        let l:build_dir = ale#path#Dirname(ale#c#FindCompileCommands(a:buffer))
        let l:build_dir = ale#path#Dirname(l:json_file)
    endif
    " The extra arguments in the command are used to prevent .plist files from
@@ -28,8 +27,8 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'clangcheck',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cpp_clangcheck_executable')},
+\   'executable_callback': ale#VarFunc('cpp_clangcheck_executable'),
-\   'command': function('ale_linters#cpp#clangcheck#GetCommand'),
+\   'command_callback': 'ale_linters#cpp#clangcheck#GetCommand',
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/cpp/clangd.vim
+++ b/ale_linters/cpp/clangd.vim
@@ -4,6 +4,12 @@
 call ale#Set('cpp_clangd_executable', 'clangd')
 call ale#Set('cpp_clangd_options', '')
 function! ale_linters#cpp#clangd#GetProjectRoot(buffer) abort
    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
 endfunction
 function! ale_linters#cpp#clangd#GetCommand(buffer) abort
    return '%e' . ale#Pad(ale#Var(a:buffer, 'cpp_clangd_options'))
 endfunction
@@ -11,7 +17,7 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'clangd',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'cpp_clangd_executable')},
+\   'executable_callback': ale#VarFunc('cpp_clangd_executable'),
-\   'command': function('ale_linters#cpp#clangd#GetCommand'),
+\   'command_callback': 'ale_linters#cpp#clangd#GetCommand',
-\   'project_root': function('ale#c#FindProjectRoot'),
+\   'project_root_callback': 'ale_linters#cpp#clangd#GetProjectRoot',
 \})
--- a/ale_linters/cpp/clangtidy.vim
+++ b/ale_linters/cpp/clangtidy.vim
@@ -4,33 +4,23 @@
 call ale#Set('cpp_clangtidy_executable', 'clang-tidy')
 " Set this option to check the checks clang-tidy will apply.
-call ale#Set('cpp_clangtidy_checks', [])
+call ale#Set('cpp_clangtidy_checks', ['*'])
-" Set this option to manually set some options for clang-tidy to use as compile
+" Set this option to manually set some options for clang-tidy.
 " flags.
 " This will disable compile_commands.json detection.
 call ale#Set('cpp_clangtidy_options', '')
 " Set this option to manually set options for clang-tidy directly.
 call ale#Set('cpp_clangtidy_extra_options', '')
 call ale#Set('c_build_dir', '')
-function! ale_linters#cpp#clangtidy#GetCommand(buffer, output) abort
+function! ale_linters#cpp#clangtidy#GetCommand(buffer) abort
    let l:checks = join(ale#Var(a:buffer, 'cpp_clangtidy_checks'), ',')
    let l:build_dir = ale#c#GetBuildDirectory(a:buffer)
    let l:options = ''
    " Get the extra options if we couldn't find a build directory.
-    if empty(l:build_dir)
+    let l:options = empty(l:build_dir)
-        let l:options = ale#Var(a:buffer, 'cpp_clangtidy_options')
+    \   ? ale#Var(a:buffer, 'cpp_clangtidy_options')
-        let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    \   : ''
        let l:options .= !empty(l:options) ? ale#Pad(l:cflags) : l:cflags
    endif
    " Get the options to pass directly to clang-tidy
    let l:extra_options = ale#Var(a:buffer, 'cpp_clangtidy_extra_options')
    return '%e'
    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
    \   . (!empty(l:extra_options) ? ' ' . ale#Escape(l:extra_options) : '')
    \   . ' %s'
    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
    \   . (!empty(l:options) ? ' -- ' . l:options : '')
@@ -39,8 +29,8 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'clangtidy',
 \   'output_stream': 'stdout',
-\   'executable': {b -> ale#Var(b, 'cpp_clangtidy_executable')},
+\   'executable_callback': ale#VarFunc('cpp_clangtidy_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#clangtidy#GetCommand'))},
+\   'command_callback': 'ale_linters#cpp#clangtidy#GetCommand',
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/cpp/clazy.vim
+++ b/ale_linters/cpp/clazy.vim
@@ -25,8 +25,8 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'clazy',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cpp_clazy_executable')},
+\   'executable_callback': ale#VarFunc('cpp_clazy_executable'),
-\   'command': function('ale_linters#cpp#clazy#GetCommand'),
+\   'command_callback': 'ale_linters#cpp#clazy#GetCommand',
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/cpp/cppcheck.vim
+++ b/ale_linters/cpp/cppcheck.vim
@@ -5,24 +5,30 @@ call ale#Set('cpp_cppcheck_executable', 'cppcheck')
 call ale#Set('cpp_cppcheck_options', '--enable=style')
 function! ale_linters#cpp#cppcheck#GetCommand(buffer) abort
-    let l:cd_command = ale#handlers#cppcheck#GetCdCommand(a:buffer)
+    " Search upwards from the file for compile_commands.json.
-    let l:compile_commands_option = ale#handlers#cppcheck#GetCompileCommandsOptions(a:buffer)
+    "
-    let l:buffer_path_include = empty(l:compile_commands_option)
+    " If we find it, we'll `cd` to where the compile_commands.json file is,
-    \   ? ale#handlers#cppcheck#GetBufferPathIncludeOptions(a:buffer)
+    " then use the file to set up import paths, etc.
    let l:compile_commmands_path = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    let l:cd_command = !empty(l:compile_commmands_path)
    \   ? ale#path#CdString(fnamemodify(l:compile_commmands_path, ':h'))
    \   : ''
    let l:compile_commands_option = !empty(l:compile_commmands_path)
    \   ? '--project=compile_commands.json '
    \   : ''
    return l:cd_command
-    \   . '%e -q --language=c++'
+    \   . '%e -q --language=c++ '
-    \   . ale#Pad(l:compile_commands_option)
+    \   . l:compile_commands_option
-    \   . ale#Pad(ale#Var(a:buffer, 'cpp_cppcheck_options'))
+    \   . ale#Var(a:buffer, 'cpp_cppcheck_options')
    \   . l:buffer_path_include
    \   . ' %t'
 endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'cppcheck',
 \   'output_stream': 'both',
-\   'executable': {b -> ale#Var(b, 'cpp_cppcheck_executable')},
+\   'executable_callback': ale#VarFunc('cpp_cppcheck_executable'),
-\   'command': function('ale_linters#cpp#cppcheck#GetCommand'),
+\   'command_callback': 'ale_linters#cpp#cppcheck#GetCommand',
 \   'callback': 'ale#handlers#cppcheck#HandleCppCheckFormat',
 \})
--- a/ale_linters/cpp/cpplint.vim
+++ b/ale_linters/cpp/cpplint.vim
@@ -13,8 +13,8 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'cpplint',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cpp_cpplint_executable')},
+\   'executable_callback': ale#VarFunc('cpp_cpplint_executable'),
-\   'command': function('ale_linters#cpp#cpplint#GetCommand'),
+\   'command_callback': 'ale_linters#cpp#cpplint#GetCommand',
 \   'callback': 'ale#handlers#cpplint#HandleCppLintFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/cpp/cquery.vim
+++ b/ale_linters/cpp/cquery.vim
@@ -5,15 +5,13 @@ call ale#Set('cpp_cquery_executable', 'cquery')
 call ale#Set('cpp_cquery_cache_directory', expand('~/.cache/cquery'))
 function! ale_linters#cpp#cquery#GetProjectRoot(buffer) abort
-    " Try to find cquery configuration files first.
+    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
    let l:config = ale#path#FindNearestFile(a:buffer, '.cquery')
-    if !empty(l:config)
+    if empty(l:project_root)
-        return fnamemodify(l:config, ':h')
+        let l:project_root = ale#path#FindNearestFile(a:buffer, '.cquery')
    endif
-    " Fall back on default project root detection.
+    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
    return ale#c#FindProjectRoot(a:buffer)
 endfunction
 function! ale_linters#cpp#cquery#GetInitializationOptions(buffer) abort
@@ -23,8 +21,8 @@ endfunction
 call ale#linter#Define('cpp', {
 \   'name': 'cquery',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'cpp_cquery_executable')},
+\   'executable_callback': ale#VarFunc('cpp_cquery_executable'),
 \   'command': '%e',
-\   'project_root': function('ale_linters#cpp#cquery#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#cpp#cquery#GetProjectRoot',
-\   'initialization_options': function('ale_linters#cpp#cquery#GetInitializationOptions'),
+\   'initialization_options_callback': 'ale_linters#cpp#cquery#GetInitializationOptions',
 \})
--- a/ale_linters/cpp/flawfinder.vim
+++ b/ale_linters/cpp/flawfinder.vim
@@ -7,19 +7,19 @@ call ale#Set('cpp_flawfinder_minlevel', 1)
 call ale#Set('c_flawfinder_error_severity', 6)
 function! ale_linters#cpp#flawfinder#GetCommand(buffer) abort
-    " Set the minimum vulnerability level for flawfinder to bother with
+   " Set the minimum vulnerability level for flawfinder to bother with
-    let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'cpp_flawfinder_minlevel')
+   let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'cpp_flawfinder_minlevel')
-    return '%e -CDQS'
+   return '%e -CDQS'
-    \  . ale#Var(a:buffer, 'cpp_flawfinder_options')
+   \  . ale#Var(a:buffer, 'cpp_flawfinder_options')
-    \  . l:minlevel
+   \  . l:minlevel
-    \  . ' %t'
+   \  . ' %t'
 endfunction
 call ale#linter#Define('cpp', {
 \  'name': 'flawfinder',
 \  'output_stream': 'stdout',
-\  'executable': {b -> ale#Var(b, 'cpp_flawfinder_executable')},
+\  'executable_callback': ale#VarFunc('cpp_flawfinder_executable'),
-\  'command': function('ale_linters#cpp#flawfinder#GetCommand'),
+\  'command_callback': 'ale_linters#cpp#flawfinder#GetCommand',
 \  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
 \})
--- a/ale_linters/cpp/gcc.vim
+++ b/ale_linters/cpp/gcc.vim
@@ -9,11 +9,7 @@ function! ale_linters#cpp#gcc#GetCommand(buffer, output) abort
    " -iquote with the directory the file is in makes #include work for
    "  headers in the same directory.
-    "
+    return '%e -S -x c++ -fsyntax-only'
    " `-o /dev/null` or `-o null` is needed to catch all errors,
    " -fsyntax-only doesn't catch everything.
    return '%e -S -x c++'
    \   . ' -o ' . g:ale#util#nul_file
    \   . ' -iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
    \   . ale#Pad(l:cflags)
    \   . ale#Pad(ale#Var(a:buffer, 'cpp_gcc_options')) . ' -'
@@ -23,7 +19,10 @@ call ale#linter#Define('cpp', {
 \   'name': 'gcc',
 \   'aliases': ['g++'],
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cpp_gcc_executable')},
+\   'executable_callback': ale#VarFunc('cpp_gcc_executable'),
-\   'command': {b -> ale#c#RunMakeCommand(b, function('ale_linters#cpp#gcc#GetCommand'))},
+\   'command_chain': [
 \       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#cpp#gcc#GetCommand'},
 \   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormatWithIncludes',
 \})
--- a/ale_linters/crystal/ameba.vim
+++ b/ale_linters/crystal/ameba.vim
@@ -1,57 +0,0 @@
 " Author: Harrison Bachrach - https://github.com/HarrisonB
 " Description: Ameba, a linter for crystal files
 call ale#Set('crystal_ameba_executable', 'bin/ameba')
 function! ale_linters#crystal#ameba#GetCommand(buffer) abort
    let l:executable = ale#Var(a:buffer, 'crystal_ameba_executable')
    return ale#Escape(l:executable)
    \   . ' --format json '
    \   .  ale#Escape(expand('#' . a:buffer . ':p'))
 endfunction
 " Handle output from ameba
 function! ale_linters#crystal#ameba#HandleAmebaOutput(buffer, lines) abort
    if len(a:lines) == 0
        return []
    endif
    let l:errors = ale#util#FuzzyJSONDecode(a:lines[0], {})
    if !has_key(l:errors, 'summary')
    \|| l:errors['summary']['issues_count'] == 0
    \|| empty(l:errors['sources'])
        return []
    endif
    let l:output = []
    for l:error in l:errors['sources'][0]['issues']
        let l:start_col = str2nr(l:error['location']['column'])
        let l:end_col = str2nr(l:error['end_location']['column'])
        if !l:end_col
            let l:end_col = l:start_col + 1
        endif
        call add(l:output, {
        \   'lnum': str2nr(l:error['location']['line']),
        \   'col': l:start_col,
        \   'end_col': l:end_col,
        \   'code': l:error['rule_name'],
        \   'text': l:error['message'],
        \   'type': 'W',
        \})
    endfor
    return l:output
 endfunction
 call ale#linter#Define('crystal', {
 \   'name': 'ameba',
 \   'executable': {b -> ale#Var(b, 'crystal_ameba_executable')},
 \   'command': function('ale_linters#crystal#ameba#GetCommand'),
 \   'callback': 'ale_linters#crystal#ameba#HandleAmebaOutput',
 \   'lint_file': 1,
 \})
--- a/ale_linters/crystal/crystal.vim
+++ b/ale_linters/crystal/crystal.vim
@@ -26,6 +26,6 @@ call ale#linter#Define('crystal', {
 \   'executable': 'crystal',
 \   'output_stream': 'both',
 \   'lint_file': 1,
-\   'command': function('ale_linters#crystal#crystal#GetCommand'),
+\   'command_callback': 'ale_linters#crystal#crystal#GetCommand',
 \   'callback': 'ale_linters#crystal#crystal#Handle',
 \})
--- a/ale_linters/cs/csc.vim
+++ b/ale_linters/cs/csc.vim
@@ -1,95 +0,0 @@
 call ale#Set('cs_csc_options', '')
 call ale#Set('cs_csc_source', '')
 call ale#Set('cs_csc_assembly_path', [])
 call ale#Set('cs_csc_assemblies', [])
 function! s:GetWorkingDirectory(buffer) abort
    let l:working_directory = ale#Var(a:buffer, 'cs_csc_source')
    if !empty(l:working_directory)
        return l:working_directory
    endif
    return expand('#' . a:buffer . ':p:h')
 endfunction
 function! ale_linters#cs#csc#GetCommand(buffer) abort
    " Pass assembly paths via the -lib: parameter.
    let l:path_list = ale#Var(a:buffer, 'cs_csc_assembly_path')
    let l:lib_option = !empty(l:path_list)
    \   ? '/lib:' . join(map(copy(l:path_list), 'ale#Escape(v:val)'), ',')
    \   : ''
    " Pass paths to DLL files via the -r: parameter.
    let l:assembly_list = ale#Var(a:buffer, 'cs_csc_assemblies')
    let l:r_option = !empty(l:assembly_list)
    \   ? '/r:' . join(map(copy(l:assembly_list), 'ale#Escape(v:val)'), ',')
    \   : ''
    " register temporary module target file with ale
    " register temporary module target file with ALE.
    let l:out = ale#command#CreateFile(a:buffer)
    " The code is compiled as a module and the output is redirected to a
    " temporary file.
    return ale#path#CdString(s:GetWorkingDirectory(a:buffer))
    \    . 'csc /unsafe'
    \    . ale#Pad(ale#Var(a:buffer, 'cs_csc_options'))
    \    . ale#Pad(l:lib_option)
    \    . ale#Pad(l:r_option)
    \    . ' /out:' . l:out
    \    . ' /t:module'
    \    . ' /recurse:' . ale#Escape('*.cs')
 endfunction
 function! ale_linters#cs#csc#Handle(buffer, lines) abort
    " Look for lines like the following.
    "
    " Tests.cs(12,29): error CSXXXX: ; expected
    "
    " NOTE: pattern also captures file name as linter compiles all
    " files within the source tree rooted at the specified source
    " path and not just the file loaded in the buffer
    let l:patterns = [
    \    '^\v(.+\.cs)\((\d+),(\d+)\)\:\s+([^ ]+)\s+([cC][sS][^ ]+):\s(.+)$',
    \    '^\v([^ ]+)\s+([Cc][sS][^ ]+):\s+(.+)$',
    \]
    let l:output = []
    let l:dir = s:GetWorkingDirectory(a:buffer)
    for l:match in ale#util#GetMatches(a:lines, l:patterns)
        if len(l:match) > 6 && strlen(l:match[5]) > 2 && l:match[5][:1] is? 'CS'
            call add(l:output, {
            \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
            \   'lnum': l:match[2] + 0,
            \   'col': l:match[3] + 0,
            \   'type': l:match[4] is# 'error' ? 'E' : 'W',
            \   'code': l:match[5],
            \   'text': l:match[6] ,
            \})
        elseif strlen(l:match[2]) > 2 && l:match[2][:1] is? 'CS'
            call add(l:output, {
            \   'filename':'<csc>',
            \   'lnum': -1,
            \   'col': -1,
            \   'type': l:match[1] is# 'error' ? 'E' : 'W',
            \   'code': l:match[2],
            \   'text': l:match[3],
            \})
        endif
    endfor
    return l:output
 endfunction
 call ale#linter#Define('cs',{
 \   'name': 'csc',
 \   'output_stream': 'stdout',
 \   'executable': 'csc',
 \   'command': function('ale_linters#cs#csc#GetCommand'),
 \   'callback': 'ale_linters#cs#csc#Handle',
 \   'lint_file': 1
 \})
--- a/ale_linters/cs/mcs.vim
+++ b/ale_linters/cs/mcs.vim
@@ -32,6 +32,6 @@ call ale#linter#Define('cs',{
 \   'name': 'mcs',
 \   'output_stream': 'stderr',
 \   'executable': 'mcs',
-\   'command': function('ale_linters#cs#mcs#GetCommand'),
+\   'command_callback': 'ale_linters#cs#mcs#GetCommand',
 \   'callback': 'ale_linters#cs#mcs#Handle',
 \})
--- a/ale_linters/cs/mcsc.vim
+++ b/ale_linters/cs/mcsc.vim
@@ -30,7 +30,7 @@ function! ale_linters#cs#mcsc#GetCommand(buffer) abort
    " register temporary module target file with ale
    " register temporary module target file with ALE.
-    let l:out = ale#command#CreateFile(a:buffer)
+    let l:out = ale#engine#CreateFile(a:buffer)
    " The code is compiled as a module and the output is redirected to a
    " temporary file.
@@ -52,34 +52,20 @@ function! ale_linters#cs#mcsc#Handle(buffer, lines) abort
    " NOTE: pattern also captures file name as linter compiles all
    " files within the source tree rooted at the specified source
    " path and not just the file loaded in the buffer
-    let l:patterns = [
+    let l:pattern = '^\v(.+\.cs)\((\d+),(\d+)\)\: ([^ ]+) ([^ ]+): (.+)$'
    \    '^\v(.+\.cs)\((\d+),(\d+)\)\:\s+([^ ]+)\s+([cC][sS][^ ]+):\s(.+)$',
    \    '^\v([^ ]+)\s+([Cc][sS][^ ]+):\s+(.+)$',
    \]
    let l:output = []
    let l:dir = s:GetWorkingDirectory(a:buffer)
-    for l:match in ale#util#GetMatches(a:lines, l:patterns)
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        if len(l:match) > 6 && strlen(l:match[5]) > 2 && l:match[5][:1] is? 'CS'
+        call add(l:output, {
-            call add(l:output, {
+        \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
-            \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
+        \   'lnum': l:match[2] + 0,
-            \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
-            \   'col': l:match[3] + 0,
+        \   'type': l:match[4] is# 'error' ? 'E' : 'W',
-            \   'type': l:match[4] is# 'error' ? 'E' : 'W',
+        \   'code': l:match[5],
-            \   'code': l:match[5],
+        \   'text': l:match[6],
-            \   'text': l:match[6] ,
+        \})
            \})
        elseif strlen(l:match[2]) > 2 && l:match[2][:1] is? 'CS'
            call add(l:output, {
            \   'filename':'<mcs>',
            \   'lnum': -1,
            \   'col': -1,
            \   'type': l:match[1] is# 'error' ? 'E' : 'W',
            \   'code': l:match[2],
            \   'text': l:match[3],
            \})
        endif
    endfor
    return l:output
@@ -89,7 +75,7 @@ call ale#linter#Define('cs',{
 \   'name': 'mcsc',
 \   'output_stream': 'stderr',
 \   'executable': 'mcs',
-\   'command': function('ale_linters#cs#mcsc#GetCommand'),
+\   'command_callback': 'ale_linters#cs#mcsc#GetCommand',
 \   'callback': 'ale_linters#cs#mcsc#Handle',
 \   'lint_file': 1
 \})
--- a/ale_linters/css/csslint.vim
+++ b/ale_linters/css/csslint.vim
@@ -13,6 +13,6 @@ endfunction
 call ale#linter#Define('css', {
 \   'name': 'csslint',
 \   'executable': 'csslint',
-\   'command': function('ale_linters#css#csslint#GetCommand'),
+\   'command_callback': 'ale_linters#css#csslint#GetCommand',
 \   'callback': 'ale#handlers#css#HandleCSSLintFormat',
 \})
--- a/ale_linters/css/fecs.vim
+++ b/ale_linters/css/fecs.vim
@@ -1,9 +0,0 @@
 " Author: harttle <yangjvn@126.com>
 " Description: fecs for CSS files
 call ale#linter#Define('css', {
 \   'name': 'fecs',
 \   'executable': function('ale#handlers#fecs#GetExecutable'),
 \   'command': function('ale#handlers#fecs#GetCommand'),
 \   'callback': 'ale#handlers#fecs#Handle',
 \})
--- a/ale_linters/css/stylelint.vim
+++ b/ale_linters/css/stylelint.vim
@@ -11,9 +11,9 @@ endfunction
 call ale#linter#Define('css', {
 \   'name': 'stylelint',
-\   'executable': {b -> ale#node#FindExecutable(b, 'css_stylelint', [
+\   'executable_callback': ale#node#FindExecutableFunc('css_stylelint', [
 \       'node_modules/.bin/stylelint',
-\   ])},
+\   ]),
-\   'command': function('ale_linters#css#stylelint#GetCommand'),
+\   'command_callback': 'ale_linters#css#stylelint#GetCommand',
 \   'callback': 'ale#handlers#css#HandleStyleLintFormat',
 \})
--- a/ale_linters/cucumber/cucumber.vim
+++ b/ale_linters/cucumber/cucumber.vim
@@ -41,6 +41,6 @@ endfunction
 call ale#linter#Define('cucumber', {
 \   'name': 'cucumber',
 \   'executable': 'cucumber',
-\   'command': function('ale_linters#cucumber#cucumber#GetCommand'),
+\   'command_callback': 'ale_linters#cucumber#cucumber#GetCommand',
 \   'callback': 'ale_linters#cucumber#cucumber#Handle'
 \})
--- a/ale_linters/cuda/nvcc.vim
+++ b/ale_linters/cuda/nvcc.vim
@@ -7,7 +7,7 @@ call ale#Set('cuda_nvcc_options', '-std=c++11')
 function! ale_linters#cuda#nvcc#GetCommand(buffer) abort
    " Unused: use ale#util#nul_file
    " let l:output_file = ale#util#Tempname() . '.ii'
-    " call ale#command#ManageFile(a:buffer, l:output_file)
+    " call ale#engine#ManageFile(a:buffer, l:output_file)
    return '%e -cuda'
    \   . ale#Pad(ale#c#IncludeOptions(ale#c#FindLocalHeaderPaths(a:buffer)))
    \   . ale#Pad(ale#Var(a:buffer, 'cuda_nvcc_options'))
@@ -42,8 +42,8 @@ endfunction
 call ale#linter#Define('cuda', {
 \   'name': 'nvcc',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'cuda_nvcc_executable')},
+\   'executable_callback': ale#VarFunc('cuda_nvcc_executable'),
-\   'command': function('ale_linters#cuda#nvcc#GetCommand'),
+\   'command_callback': 'ale_linters#cuda#nvcc#GetCommand',
 \   'callback': 'ale_linters#cuda#nvcc#HandleNVCCFormat',
 \   'lint_file': 1,
 \})
--- a/ale_linters/cypher/cypher_lint.vim
+++ b/ale_linters/cypher/cypher_lint.vim
@@ -1,26 +0,0 @@
 " Author: Francisco Lopes <francisco@oblita.com>
 " Description: Linting for Neo4j's Cypher
 function! ale_linters#cypher#cypher_lint#Handle(buffer, lines) abort
    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):(\d+): (.*)$'
    let l:output = []
    for l:match in ale#util#GetMatches(a:lines, l:pattern)
        call add(l:output, {
        \   'lnum': l:match[2] + 0,
        \   'col': l:match[3] + 0,
        \   'text': l:match[4],
        \   'type': 'E',
        \})
    endfor
    return l:output
 endfunction
 call ale#linter#Define('cypher', {
 \   'name': 'cypher_lint',
 \   'executable': 'cypher-lint',
 \   'command': 'cypher-lint',
 \   'output_stream': 'stderr',
 \   'callback': 'ale_linters#cypher#cypher_lint#Handle',
 \})
--- a/ale_linters/d/dls.vim
+++ b/ale_linters/d/dls.vim
@@ -1,22 +0,0 @@
 " Author: aurieh <me@aurieh.me>
 " Description: A Language Server implementation for D
 call ale#Set('d_dls_executable', 'dls')
 function! ale_linters#d#dls#GetExecutable(buffer) abort
    return ale#Var(a:buffer, 'd_dls_executable')
 endfunction
 function! ale_linters#d#dls#FindProjectRoot(buffer) abort
    " Note: this will return . if dub config is empty
    " dls can run outside DUB projects just fine
    return fnamemodify(ale#d#FindDUBConfig(a:buffer), ':h')
 endfunction
 call ale#linter#Define('d', {
 \   'name': 'dls',
 \   'lsp': 'stdio',
 \   'executable': function('ale_linters#d#dls#GetExecutable'),
 \   'command': function('ale_linters#d#dls#GetExecutable'),
 \   'project_root': function('ale_linters#d#dls#FindProjectRoot'),
 \})
--- a/ale_linters/d/dmd.vim
+++ b/ale_linters/d/dmd.vim
@@ -1,14 +1,28 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: "dmd for D files"
-function! ale_linters#d#dmd#GetDUBCommand(buffer) abort
+function! s:FindDUBConfig(buffer) abort
    " Find a DUB configuration file in ancestor paths.
    " The most DUB-specific names will be tried first.
    for l:possible_filename in ['dub.sdl', 'dub.json', 'package.json']
        let l:dub_file = ale#path#FindNearestFile(a:buffer, l:possible_filename)
        if !empty(l:dub_file)
            return l:dub_file
        endif
    endfor
    return ''
 endfunction
 function! ale_linters#d#dmd#DUBCommand(buffer) abort
    " If we can't run dub, then skip this command.
    if !executable('dub')
        " Returning an empty string skips to the DMD command.
        return ''
    endif
-    let l:dub_file = ale#d#FindDUBConfig(a:buffer)
+    let l:dub_file = s:FindDUBConfig(a:buffer)
    if empty(l:dub_file)
        return ''
@@ -21,18 +35,7 @@ function! ale_linters#d#dmd#GetDUBCommand(buffer) abort
    \   . ' && dub describe --import-paths'
 endfunction
-function! ale_linters#d#dmd#RunDUBCommand(buffer) abort
+function! ale_linters#d#dmd#DMDCommand(buffer, dub_output) abort
    let l:command = ale_linters#d#dmd#GetDUBCommand(a:buffer)
    if empty(l:command)
        " If we can't run DUB, just run DMD.
        return ale_linters#d#dmd#DMDCommand(a:buffer, [], {})
    endif
    return ale#command#Run(a:buffer, l:command, function('ale_linters#d#dmd#DMDCommand'))
 endfunction
 function! ale_linters#d#dmd#DMDCommand(buffer, dub_output, meta) abort
    let l:import_list = []
    " Build a list of import paths generated from DUB, if available.
@@ -68,7 +71,9 @@ endfunction
 call ale#linter#Define('d', {
 \   'name': 'dmd',
 \   'executable': 'dmd',
-\   'command': function('ale_linters#d#dmd#RunDUBCommand'),
+\   'command_chain': [
 \       {'callback': 'ale_linters#d#dmd#DUBCommand', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#d#dmd#DMDCommand', 'output_stream': 'stderr'},
 \   ],
 \   'callback': 'ale_linters#d#dmd#Handle',
 \   'output_stream': 'stderr',
 \})
--- a/ale_linters/dart/dartanalyzer.vim
+++ b/ale_linters/dart/dartanalyzer.vim
@@ -29,8 +29,8 @@ endfunction
 call ale#linter#Define('dart', {
 \   'name': 'dartanalyzer',
-\   'executable': {b -> ale#Var(b, 'dart_dartanalyzer_executable')},
+\   'executable_callback': ale#VarFunc('dart_dartanalyzer_executable'),
-\   'command': function('ale_linters#dart#dartanalyzer#GetCommand'),
+\   'command_callback': 'ale_linters#dart#dartanalyzer#GetCommand',
 \   'callback': 'ale_linters#dart#dartanalyzer#Handle',
 \   'lint_file': 1,
 \})
--- a/ale_linters/dart/language_server.vim
+++ b/ale_linters/dart/language_server.vim
@@ -14,7 +14,7 @@ endfunction
 call ale#linter#Define('dart', {
 \   'name': 'language_server',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'dart_language_server_executable')},
+\   'executable_callback': ale#VarFunc('dart_language_server_executable'),
 \   'command': '%e',
-\   'project_root': function('ale_linters#dart#language_server#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#dart#language_server#GetProjectRoot',
 \})
--- a/ale_linters/dockerfile/dockerfile_lint.vim
+++ b/ale_linters/dockerfile/dockerfile_lint.vim
@@ -1,61 +0,0 @@
 " Author: Alexander Olofsson <alexander.olofsson@liu.se>
 call ale#Set('dockerfile_dockerfile_lint_executable', 'dockerfile_lint')
 call ale#Set('dockerfile_dockerfile_lint_options', '')
 function! ale_linters#dockerfile#dockerfile_lint#GetType(type) abort
    if a:type is? 'error'
        return 'E'
    elseif a:type is? 'warn'
        return 'W'
    endif
    return 'I'
 endfunction
 function! ale_linters#dockerfile#dockerfile_lint#Handle(buffer, lines) abort
    try
        let l:data = json_decode(join(a:lines, ''))
    catch
        return []
    endtry
    if empty(l:data)
        " Should never happen, but it's better to be on the safe side
        return []
    endif
    let l:messages = []
    for l:type in ['error', 'warn', 'info']
        for l:object in l:data[l:type]['data']
            let l:line = get(l:object, 'line', -1)
            let l:message = l:object['message']
            if get(l:object, 'description', 'None') isnot# 'None'
                let l:message = l:message . '. ' . l:object['description']
            endif
            call add(l:messages, {
            \   'lnum': l:line,
            \   'text': l:message,
            \   'type': ale_linters#dockerfile#dockerfile_lint#GetType(l:type),
            \})
        endfor
    endfor
    return l:messages
 endfunction
 function! ale_linters#dockerfile#dockerfile_lint#GetCommand(buffer) abort
    return '%e' . ale#Pad(ale#Var(a:buffer, 'dockerfile_dockerfile_lint_options'))
    \   . ' -p -j -f'
    \   . ' %t'
 endfunction
 call ale#linter#Define('dockerfile', {
 \   'name': 'dockerfile_lint',
 \   'executable': {b -> ale#Var(b, 'dockerfile_dockerfile_lint_executable')},
 \   'command': function('ale_linters#dockerfile#dockerfile_lint#GetCommand'),
 \   'callback': 'ale_linters#dockerfile#dockerfile_lint#Handle',
 \})
--- a/ale_linters/dockerfile/hadolint.vim
+++ b/ale_linters/dockerfile/hadolint.vim
@@ -93,7 +93,7 @@ endfunction
 call ale#linter#Define('dockerfile', {
 \   'name': 'hadolint',
-\   'executable': function('ale_linters#dockerfile#hadolint#GetExecutable'),
+\   'executable_callback': 'ale_linters#dockerfile#hadolint#GetExecutable',
-\   'command': function('ale_linters#dockerfile#hadolint#GetCommand'),
+\   'command_callback': 'ale_linters#dockerfile#hadolint#GetCommand',
 \   'callback': 'ale_linters#dockerfile#hadolint#Handle',
 \})
--- a/ale_linters/elixir/credo.vim
+++ b/ale_linters/elixir/credo.vim
@@ -11,18 +11,10 @@ function! ale_linters#elixir#credo#Handle(buffer, lines) abort
        let l:type = l:match[3]
        let l:text = l:match[4]
-        " Refactoring opportunities
+        if l:type is# 'C'
-        if l:type is# 'F'
+            let l:type = 'E'
            let l:type = 'W'
        " Consistency
        elseif l:type is# 'C'
            let l:type = 'W'
        " Software Design
        elseif l:type is# 'D'
            let l:type = 'I'
        " Code Readability
        elseif l:type is# 'R'
-            let l:type = 'I'
+            let l:type = 'W'
        endif
        call add(l:output, {
@@ -37,27 +29,16 @@ function! ale_linters#elixir#credo#Handle(buffer, lines) abort
    return l:output
 endfunction
 function! ale_linters#elixir#credo#GetMode() abort
    if get(g:, 'ale_elixir_credo_strict', 0)
        return '--strict'
    else
        return 'suggest'
    endif
 endfunction
 function! ale_linters#elixir#credo#GetCommand(buffer) abort
    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
    let l:mode = ale_linters#elixir#credo#GetMode()
    return ale#path#CdString(l:project_root)
-    \ . 'mix help credo && '
+    \ . ' mix help credo && mix credo suggest --format=flycheck --read-from-stdin %s'
    \ . 'mix credo ' . ale_linters#elixir#credo#GetMode()
    \ . ' --format=flycheck --read-from-stdin %s'
 endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'credo',
 \   'executable': 'mix',
-\   'command': function('ale_linters#elixir#credo#GetCommand'),
+\   'command_callback': 'ale_linters#elixir#credo#GetCommand',
 \   'callback': 'ale_linters#elixir#credo#Handle',
 \})
--- a/ale_linters/elixir/dialyxir.vim
+++ b/ale_linters/elixir/dialyxir.vim
@@ -35,7 +35,7 @@ endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'dialyxir',
 \   'executable': 'mix',
-\   'command': function('ale_linters#elixir#dialyxir#GetCommand'),
+\   'command_callback': 'ale_linters#elixir#dialyxir#GetCommand',
 \   'callback': 'ale_linters#elixir#dialyxir#Handle',
 \})
--- a/ale_linters/elixir/dogma.vim
+++ b/ale_linters/elixir/dogma.vim
@@ -39,7 +39,7 @@ endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'dogma',
 \   'executable': 'mix',
-\   'command': function('ale_linters#elixir#dogma#GetCommand'),
+\   'command_callback': 'ale_linters#elixir#dogma#GetCommand',
 \   'lint_file': 1,
 \   'callback': 'ale_linters#elixir#dogma#Handle',
 \})
--- a/ale_linters/elixir/elixir_ls.vim
+++ b/ale_linters/elixir/elixir_ls.vim
@@ -1,21 +0,0 @@
 " Author: Jon Parise <jon@indelible.org>
 " Description: ElixirLS integration (https://github.com/JakeBecker/elixir-ls)
 call ale#Set('elixir_elixir_ls_release', 'elixir-ls')
 call ale#Set('elixir_elixir_ls_config', {})
 function! ale_linters#elixir#elixir_ls#GetExecutable(buffer) abort
    let l:dir = ale#path#Simplify(ale#Var(a:buffer, 'elixir_elixir_ls_release'))
    let l:cmd = has('win32') ? '\language_server.bat' : '/language_server.sh'
    return l:dir . l:cmd
 endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'elixir-ls',
 \   'lsp': 'stdio',
 \   'executable': function('ale_linters#elixir#elixir_ls#GetExecutable'),
 \   'command': function('ale_linters#elixir#elixir_ls#GetExecutable'),
 \   'project_root': function('ale#handlers#elixir#FindMixUmbrellaRoot'),
 \   'lsp_config': {b -> ale#Var(b, 'elixir_elixir_ls_config')},
 \})
--- a/ale_linters/elixir/mix.vim
+++ b/ale_linters/elixir/mix.vim
@@ -32,7 +32,7 @@ endfunction
 function! ale_linters#elixir#mix#GetCommand(buffer) abort
    let l:project_root = ale#handlers#elixir#FindMixProjectRoot(a:buffer)
-    let l:temp_dir = ale#command#CreateDirectory(a:buffer)
+    let l:temp_dir = ale#engine#CreateDirectory(a:buffer)
    let l:mix_build_path = has('win32')
    \   ? 'set MIX_BUILD_PATH=' . ale#Escape(l:temp_dir) . ' &&'
@@ -46,7 +46,7 @@ endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'mix',
 \   'executable': 'mix',
-\   'command': function('ale_linters#elixir#mix#GetCommand'),
+\   'command_callback': 'ale_linters#elixir#mix#GetCommand',
 \   'callback': 'ale_linters#elixir#mix#Handle',
 \   'lint_file': 1,
 \})
--- a/ale_linters/elm/elm_ls.vim
+++ b/ale_linters/elm/elm_ls.vim
@@ -1,40 +0,0 @@
 " Author: antew - https://github.com/antew
 " Description: elm-language-server integration for elm (diagnostics, formatting, and more)
 call ale#Set('elm_ls_executable', 'elm-language-server')
 call ale#Set('elm_ls_use_global', get(g:, 'ale_use_global_executables', 1))
 " elm-language-server will search for local and global binaries, if empty
 call ale#Set('elm_ls_elm_path', '')
 call ale#Set('elm_ls_elm_format_path', '')
 call ale#Set('elm_ls_elm_test_path', '')
 call ale#Set('elm_ls_elm_analyse_trigger', 'change')
 function! elm_ls#GetRootDir(buffer) abort
    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
    return !empty(l:elm_json) ? fnamemodify(l:elm_json, ':p:h') : ''
 endfunction
 function! elm_ls#GetOptions(buffer) abort
    return {
    \   'elmPath': ale#Var(a:buffer, 'elm_ls_elm_path'),
    \   'elmFormatPath': ale#Var(a:buffer, 'elm_ls_elm_format_path'),
    \   'elmTestPath': ale#Var(a:buffer, 'elm_ls_elm_test_path'),
    \   'elmAnalyseTrigger': ale#Var(a:buffer, 'elm_ls_elm_analyse_trigger'),
    \}
 endfunction
 call ale#linter#Define('elm', {
 \   'name': 'elm_ls',
 \   'lsp': 'stdio',
 \   'executable': {b -> ale#node#FindExecutable(b, 'elm_ls', [
 \       'node_modules/.bin/elm-language-server',
 \       'node_modules/.bin/elm-lsp',
 \       'elm-lsp'
 \   ])},
 \   'command': '%e --stdio',
 \   'project_root': function('elm_ls#GetRootDir'),
 \   'language': 'elm',
 \   'initialization_options': function('elm_ls#GetOptions')
 \})
--- a/ale_linters/elm/make.vim
+++ b/ale_linters/elm/make.vim
@@ -137,7 +137,9 @@ function! ale_linters#elm#make#ParseMessageItem(item) abort
    endif
 endfunction
-function! ale_linters#elm#make#GetPackageFile(buffer) abort
+" Return the command to execute the linter in the projects directory.
 " If it doesn't, then this will fail when imports are needed.
 function! ale_linters#elm#make#GetCommand(buffer) abort
    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
    if empty(l:elm_json)
@@ -145,96 +147,26 @@ function! ale_linters#elm#make#GetPackageFile(buffer) abort
        let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm-package.json')
    endif
    return l:elm_json
 endfunction
 function! ale_linters#elm#make#IsVersionGte19(buffer) abort
    let l:elm_json = ale_linters#elm#make#GetPackageFile(a:buffer)
    if l:elm_json =~# '-package'
        return 0
    else
        return 1
    endif
 endfunction
 function! ale_linters#elm#make#GetRootDir(buffer) abort
    let l:elm_json = ale_linters#elm#make#GetPackageFile(a:buffer)
    if empty(l:elm_json)
        return ''
    else
        return fnamemodify(l:elm_json, ':p:h')
    endif
 endfunction
 function! ale_linters#elm#make#IsTest(buffer) abort
    let l:root_dir = ale_linters#elm#make#GetRootDir(a:buffer)
    if empty(l:root_dir)
        return 0
    endif
    let l:tests_dir = join([l:root_dir, 'tests', ''], has('win32') ? '\' : '/')
    let l:buffer_path = fnamemodify(bufname(a:buffer), ':p')
    if stridx(l:buffer_path, l:tests_dir) == 0
        return 1
    else
        return 0
    endif
 endfunction
 " Return the command to execute the linter in the projects directory.
 " If it doesn't, then this will fail when imports are needed.
 function! ale_linters#elm#make#GetCommand(buffer) abort
    let l:executable = ale_linters#elm#make#GetExecutable(a:buffer)
    let l:root_dir = ale_linters#elm#make#GetRootDir(a:buffer)
    let l:is_v19 = ale_linters#elm#make#IsVersionGte19(a:buffer)
    let l:is_using_elm_test = l:executable =~# 'elm-test$'
    if empty(l:root_dir)
        let l:dir_set_cmd = ''
    else
        let l:root_dir = fnamemodify(l:elm_json, ':p:h')
        let l:dir_set_cmd = 'cd ' . ale#Escape(l:root_dir) . ' && '
    endif
    " elm-test needs to know the path of elm-make if elm isn't installed globally.
    " https://github.com/rtfeldman/node-test-runner/blob/57728f10668f2d2ab3179e7e3208bcfa9a1f19aa/README.md#--compiler
    if l:is_v19 && l:is_using_elm_test
        let l:elm_make_executable = ale#node#FindExecutable(a:buffer, 'elm_make', ['node_modules/.bin/elm'])
        let l:elm_test_compiler_flag = ' --compiler ' . l:elm_make_executable . ' '
    else
        let l:elm_test_compiler_flag = ' '
    endif
    " The elm compiler, at the time of this writing, uses '/dev/null' as
    " a sort of flag to tell the compiler not to generate an output file,
    " which is why this is hard coded here.
    " Source: https://github.com/elm-lang/elm-compiler/blob/19d5a769b30ec0b2fc4475985abb4cd94cd1d6c3/builder/src/Generate/Output.hs#L253
-    return l:dir_set_cmd . '%e make --report=json --output=/dev/null' . l:elm_test_compiler_flag . '%t'
+    return l:dir_set_cmd . '%e make --report=json --output=/dev/null %t'
 endfunction
 function! ale_linters#elm#make#GetExecutable(buffer) abort
    let l:is_test = ale_linters#elm#make#IsTest(a:buffer)
    let l:is_v19 = ale_linters#elm#make#IsVersionGte19(a:buffer)
    if l:is_test && l:is_v19
        return ale#node#FindExecutable(
        \   a:buffer,
        \   'elm_make',
        \   ['node_modules/.bin/elm-test', 'node_modules/.bin/elm']
        \)
    else
        return ale#node#FindExecutable(a:buffer, 'elm_make', ['node_modules/.bin/elm'])
    endif
 endfunction
 call ale#linter#Define('elm', {
 \   'name': 'make',
-\   'executable': function('ale_linters#elm#make#GetExecutable'),
+\   'executable_callback': ale#node#FindExecutableFunc('elm_make', [
 \       'node_modules/.bin/elm',
 \   ]),
 \   'output_stream': 'both',
-\   'command': function('ale_linters#elm#make#GetCommand'),
+\   'command_callback': 'ale_linters#elm#make#GetCommand',
 \   'callback': 'ale_linters#elm#make#Handle'
 \})
--- a/ale_linters/erlang/dialyzer.vim
+++ b/ale_linters/erlang/dialyzer.vim
@@ -1,93 +0,0 @@
 " Author: Autoine Gagne - https://github.com/AntoineGagne
 " Description: Define a checker that runs dialyzer on Erlang files.
 let g:ale_erlang_dialyzer_executable =
 \   get(g:, 'ale_erlang_dialyzer_executable', 'dialyzer')
 let g:ale_erlang_dialyzer_plt_file =
 \   get(g:, 'ale_erlang_dialyzer_plt_file', '')
 let g:ale_erlang_dialyzer_rebar3_profile =
 \   get(g:, 'ale_erlang_dialyzer_rebar3_profile', 'default')
 function! ale_linters#erlang#dialyzer#GetRebar3Profile(buffer) abort
    return ale#Var(a:buffer, 'erlang_dialyzer_rebar3_profile')
 endfunction
 function! ale_linters#erlang#dialyzer#FindPlt(buffer) abort
    let l:plt_file = ''
    let l:rebar3_profile = ale_linters#erlang#dialyzer#GetRebar3Profile(a:buffer)
    let l:plt_file_directory = ale#path#FindNearestDirectory(a:buffer, '_build/' . l:rebar3_profile)
    if !empty(l:plt_file_directory)
        let l:plt_file = globpath(l:plt_file_directory, '*_plt', 0, 1)
    endif
    if !empty(l:plt_file)
        return l:plt_file[0]
    endif
    if !empty($REBAR_PLT_DIR)
        return expand('$REBAR_PLT_DIR/dialyzer/plt')
    endif
    return expand('$HOME/.dialyzer_plt')
 endfunction
 function! ale_linters#erlang#dialyzer#GetPlt(buffer) abort
    let l:plt_file = ale#Var(a:buffer, 'erlang_dialyzer_plt_file')
    if !empty(l:plt_file)
        return l:plt_file
    endif
    return ale_linters#erlang#dialyzer#FindPlt(a:buffer)
 endfunction
 function! ale_linters#erlang#dialyzer#GetExecutable(buffer) abort
    return ale#Var(a:buffer, 'erlang_dialyzer_executable')
 endfunction
 function! ale_linters#erlang#dialyzer#GetCommand(buffer) abort
    let l:command = ale#Escape(ale_linters#erlang#dialyzer#GetExecutable(a:buffer))
    \   . ' -n'
    \   . ' --plt ' . ale#Escape(ale_linters#erlang#dialyzer#GetPlt(a:buffer))
    \   . ' -Wunmatched_returns'
    \   . ' -Werror_handling'
    \   . ' -Wrace_conditions'
    \   . ' -Wunderspecs'
    \   . ' %s'
    return l:command
 endfunction
 function! ale_linters#erlang#dialyzer#Handle(buffer, lines) abort
    " Match patterns like the following:
    "
    " erl_tidy_prv_fmt.erl:3: Callback info about the provider behaviour is not available
    let l:pattern = '^\S\+:\(\d\+\): \(.\+\)$'
    let l:output = []
    for l:line in a:lines
        let l:match = matchlist(l:line, l:pattern)
        if len(l:match) != 0
            let l:code = l:match[2]
            call add(l:output, {
            \   'lnum': str2nr(l:match[1]),
            \   'lcol': 0,
            \   'text': l:code,
            \   'type': 'W'
            \})
        endif
    endfor
    return l:output
 endfunction
 call ale#linter#Define('erlang', {
 \   'name': 'dialyzer',
 \   'executable': function('ale_linters#erlang#dialyzer#GetExecutable'),
 \   'command': function('ale_linters#erlang#dialyzer#GetCommand'),
 \   'callback': function('ale_linters#erlang#dialyzer#Handle'),
 \   'lint_file': 1
 \})
--- a/ale_linters/erlang/erlc.vim
+++ b/ale_linters/erlang/erlc.vim
@@ -4,7 +4,7 @@ let g:ale_erlang_erlc_options = get(g:, 'ale_erlang_erlc_options', '')
 function! ale_linters#erlang#erlc#GetCommand(buffer) abort
    let l:output_file = ale#util#Tempname()
-    call ale#command#ManageFile(a:buffer, l:output_file)
+    call ale#engine#ManageFile(a:buffer, l:output_file)
    return 'erlc -o ' . ale#Escape(l:output_file)
    \   . ' ' . ale#Var(a:buffer, 'erlang_erlc_options')
@@ -91,6 +91,6 @@ endfunction
 call ale#linter#Define('erlang', {
 \   'name': 'erlc',
 \   'executable': 'erlc',
-\   'command': function('ale_linters#erlang#erlc#GetCommand'),
+\   'command_callback': 'ale_linters#erlang#erlc#GetCommand',
 \   'callback': 'ale_linters#erlang#erlc#Handle',
 \})
--- a/ale_linters/erlang/syntaxerl.vim
+++ b/ale_linters/erlang/syntaxerl.vim
@@ -3,17 +3,7 @@
 call ale#Set('erlang_syntaxerl_executable', 'syntaxerl')
-function! ale_linters#erlang#syntaxerl#RunHelpCommand(buffer) abort
+function! ale_linters#erlang#syntaxerl#GetCommand(buffer, output) abort
    let l:executable = ale#Var(a:buffer, 'erlang_syntaxerl_executable')
    return ale#command#Run(
    \   a:buffer,
    \   ale#Escape(l:executable) . ' -h',
    \   function('ale_linters#erlang#syntaxerl#GetCommand'),
    \)
 endfunction
 function! ale_linters#erlang#syntaxerl#GetCommand(buffer, output, meta) abort
    let l:use_b_option = match(a:output, '\C\V-b, --base\>') > -1
    return '%e' . (l:use_b_option ? ' -b %s %t' : ' %t')
@@ -36,7 +26,10 @@ endfunction
 call ale#linter#Define('erlang', {
 \   'name': 'syntaxerl',
-\   'executable': {b -> ale#Var(b, 'erlang_syntaxerl_executable')},
+\   'executable_callback': ale#VarFunc('erlang_syntaxerl_executable'),
-\   'command': {b -> ale_linters#erlang#syntaxerl#RunHelpCommand(b)},
+\   'command_chain': [
 \       {'callback': {-> '%e -h'}},
 \       {'callback': 'ale_linters#erlang#syntaxerl#GetCommand'},
 \   ],
 \   'callback': 'ale_linters#erlang#syntaxerl#Handle',
 \})
--- a/ale_linters/eruby/erb.vim
+++ b/ale_linters/eruby/erb.vim
@@ -19,7 +19,7 @@ call ale#linter#Define('eruby', {
 \   'aliases': ['erubylint'],
 \   'executable': 'erb',
 \   'output_stream': 'stderr',
-\   'command': function('ale_linters#eruby#erb#GetCommand'),
+\   'command_callback': 'ale_linters#eruby#erb#GetCommand',
 \   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
 \})
--- a/ale_linters/eruby/erubi.vim
+++ b/ale_linters/eruby/erubi.vim
@@ -1,10 +1,14 @@
 " Author: Eddie Lebow https://github.com/elebow
 " Description: eruby checker using `erubi`
-function! ale_linters#eruby#erubi#GetCommand(buffer, output, meta) abort
+function! ale_linters#eruby#erubi#CheckErubi(buffer) abort
    return 'ruby -r erubi/capture_end -e ' . ale#Escape('""')
 endfunction
 function! ale_linters#eruby#erubi#GetCommand(buffer, check_erubi_output) abort
    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
-    if !empty(a:output)
+    if (!empty(a:check_erubi_output))
        " The empty command in CheckErubi returns nothing if erubi runs and
        " emits an error if erubi is not present
        return ''
@@ -23,10 +27,9 @@ endfunction
 call ale#linter#Define('eruby', {
 \   'name': 'erubi',
 \   'executable': 'ruby',
-\   'command': {buffer -> ale#command#Run(
+\   'command_chain': [
-\       buffer,
+\     {'callback': 'ale_linters#eruby#erubi#CheckErubi'},
-\       'ruby -r erubi/capture_end -e ' . ale#Escape('""'),
+\     {'callback': 'ale_linters#eruby#erubi#GetCommand', 'output_stream': 'stderr'},
-\       function('ale_linters#eruby#erubi#GetCommand'),
+\   ],
 \   )},
 \   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
 \})
--- a/ale_linters/eruby/erubis.vim
+++ b/ale_linters/eruby/erubis.vim
@@ -18,6 +18,6 @@ call ale#linter#Define('eruby', {
 \   'name': 'erubis',
 \   'executable': 'erubis',
 \   'output_stream': 'stderr',
-\   'command': function('ale_linters#eruby#erubis#GetCommand'),
+\   'command_callback': 'ale_linters#eruby#erubis#GetCommand',
 \   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
 \})
--- a/ale_linters/eruby/ruumba.vim
+++ b/ale_linters/eruby/ruumba.vim
@@ -1,62 +0,0 @@
 " Author: aclemons - https://github.com/aclemons
 " based on the ale rubocop linter
 " Description: Ruumba, RuboCop linting for ERB templates.
 call ale#Set('eruby_ruumba_executable', 'ruumba')
 call ale#Set('eruby_ruumba_options', '')
 function! ale_linters#eruby#ruumba#GetCommand(buffer) abort
    let l:executable = ale#Var(a:buffer, 'eruby_ruumba_executable')
    return ale#ruby#EscapeExecutable(l:executable, 'ruumba')
    \   . ' --format json --force-exclusion '
    \   . ale#Var(a:buffer, 'eruby_ruumba_options')
    \   . ' --stdin ' . ale#Escape(expand('#' . a:buffer . ':p'))
 endfunction
 function! ale_linters#eruby#ruumba#Handle(buffer, lines) abort
    try
        let l:errors = json_decode(a:lines[0])
    catch
        return []
    endtry
    if !has_key(l:errors, 'summary')
    \|| l:errors['summary']['offense_count'] == 0
    \|| empty(l:errors['files'])
        return []
    endif
    let l:output = []
    for l:error in l:errors['files'][0]['offenses']
        let l:start_col = l:error['location']['column'] + 0
        call add(l:output, {
        \   'lnum': l:error['location']['line'] + 0,
        \   'col': l:start_col,
        \   'end_col': l:start_col + l:error['location']['length'] - 1,
        \   'code': l:error['cop_name'],
        \   'text': l:error['message'],
        \   'type': ale_linters#eruby#ruumba#GetType(l:error['severity']),
        \})
    endfor
    return l:output
 endfunction
 function! ale_linters#eruby#ruumba#GetType(severity) abort
    if a:severity is? 'convention'
    \|| a:severity is? 'warning'
    \|| a:severity is? 'refactor'
        return 'W'
    endif
    return 'E'
 endfunction
 call ale#linter#Define('eruby', {
 \   'name': 'ruumba',
 \   'executable': {b -> ale#Var(b, 'eruby_ruumba_executable')},
 \   'command': function('ale_linters#eruby#ruumba#GetCommand'),
 \   'callback': 'ale_linters#eruby#ruumba#Handle',
 \})
--- a/ale_linters/fortran/gcc.vim
+++ b/ale_linters/fortran/gcc.vim
@@ -66,7 +66,7 @@ endfunction
 call ale#linter#Define('fortran', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'fortran_gcc_executable')},
+\   'executable_callback': ale#VarFunc('fortran_gcc_executable'),
-\   'command': function('ale_linters#fortran#gcc#GetCommand'),
+\   'command_callback': 'ale_linters#fortran#gcc#GetCommand',
 \   'callback': 'ale_linters#fortran#gcc#Handle',
 \})
--- a/ale_linters/fortran/language_server.vim
+++ b/ale_linters/fortran/language_server.vim
@@ -13,7 +13,7 @@ endfunction
 call ale#linter#Define('fortran', {
 \   'name': 'language_server',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'fortran_language_server_executable')},
+\   'executable_callback': ale#VarFunc('fortran_language_server_executable'),
 \   'command': '%e',
-\   'project_root': function('ale_linters#fortran#language_server#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#fortran#language_server#GetProjectRoot',
 \})
--- a/ale_linters/fuse/fusionlint.vim
+++ b/ale_linters/fuse/fusionlint.vim
@@ -27,7 +27,7 @@ endfunction
 call ale#linter#Define('fuse', {
 \   'name': 'fusionlint',
-\   'executable': {b -> ale#Var(b, 'fuse_fusionlint_executable')},
+\   'executable_callback': ale#VarFunc('fuse_fusionlint_executable'),
-\   'command': function('ale_linters#fuse#fusionlint#GetCommand'),
+\   'command_callback': 'ale_linters#fuse#fusionlint#GetCommand',
 \   'callback': 'ale_linters#fuse#fusionlint#Handle',
 \})
--- a/ale_linters/gitcommit/gitlint.vim
+++ b/ale_linters/gitcommit/gitlint.vim
@@ -45,7 +45,7 @@ endfunction
 call ale#linter#Define('gitcommit', {
 \   'name': 'gitlint',
 \   'output_stream': 'stderr',
-\   'executable': function('ale_linters#gitcommit#gitlint#GetExecutable'),
+\   'executable_callback': 'ale_linters#gitcommit#gitlint#GetExecutable',
-\   'command': function('ale_linters#gitcommit#gitlint#GetCommand'),
+\   'command_callback': 'ale_linters#gitcommit#gitlint#GetCommand',
 \   'callback': 'ale_linters#gitcommit#gitlint#Handle',
 \})
--- a/ale_linters/glsl/glslang.vim
+++ b/ale_linters/glsl/glslang.vim
@@ -34,7 +34,7 @@ endfunction
 call ale#linter#Define('glsl', {
 \   'name': 'glslang',
-\   'executable': {b -> ale#Var(b, 'glsl_glslang_executable')},
+\   'executable_callback': ale#VarFunc('glsl_glslang_executable'),
-\   'command': function('ale_linters#glsl#glslang#GetCommand'),
+\   'command_callback': 'ale_linters#glsl#glslang#GetCommand',
 \   'callback': 'ale_linters#glsl#glslang#Handle',
 \})
--- a/ale_linters/glsl/glslls.vim
+++ b/ale_linters/glsl/glslls.vim
@@ -24,7 +24,7 @@ endfunction
 call ale#linter#Define('glsl', {
 \   'name': 'glslls',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'glsl_glslls_executable')},
+\   'executable_callback': ale#VarFunc('glsl_glslls_executable'),
-\   'command': function('ale_linters#glsl#glslls#GetCommand'),
+\   'command_callback': 'ale_linters#glsl#glslls#GetCommand',
-\   'project_root': function('ale_linters#glsl#glslls#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#glsl#glslls#GetProjectRoot',
 \})
--- a/ale_linters/go/bingo.vim
+++ b/ale_linters/go/bingo.vim
@@ -1,31 +0,0 @@
 " Author: Jerko Steiner <https://github.com/jeremija>
 " Description: https://github.com/saibing/bingo
 call ale#Set('go_bingo_executable', 'bingo')
 call ale#Set('go_bingo_options', '--mode stdio')
 function! ale_linters#go#bingo#GetCommand(buffer) abort
    return ale#go#EnvString(a:buffer) . '%e' . ale#Pad(ale#Var(a:buffer, 'go_bingo_options'))
 endfunction
 function! ale_linters#go#bingo#FindProjectRoot(buffer) abort
    let l:go_modules_off = ale#Var(a:buffer, 'go_go111module') is# 'off'
    let l:project_root = l:go_modules_off ?
    \ '' : ale#path#FindNearestFile(a:buffer, 'go.mod')
    let l:mods = ':h'
    if empty(l:project_root)
        let l:project_root = ale#path#FindNearestDirectory(a:buffer, '.git')
        let l:mods = ':h:h'
    endif
    return !empty(l:project_root) ? fnamemodify(l:project_root, l:mods) : ''
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'bingo',
 \   'lsp': 'stdio',
 \   'executable': {b -> ale#Var(b, 'go_bingo_executable')},
 \   'command': function('ale_linters#go#bingo#GetCommand'),
 \   'project_root': function('ale_linters#go#bingo#FindProjectRoot'),
 \})
--- a/ale_linters/go/gobuild.vim
+++ b/ale_linters/go/gobuild.vim
@@ -11,7 +11,6 @@ function! ale_linters#go#gobuild#GetCommand(buffer) abort
    " Run go test in local directory with relative path
    return ale#path#BufferCdString(a:buffer)
    \   . ale#go#EnvString(a:buffer)
    \   . ale#Var(a:buffer, 'go_go_executable') . ' test'
    \   . (!empty(l:options) ? ' ' . l:options : '')
    \   . ' -c -o /dev/null ./'
@@ -49,8 +48,8 @@ endfunction
 call ale#linter#Define('go', {
 \   'name': 'gobuild',
 \   'aliases': ['go build'],
-\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'executable_callback': ale#VarFunc('go_go_executable'),
-\   'command': function('ale_linters#go#gobuild#GetCommand'),
+\   'command_callback': 'ale_linters#go#gobuild#GetCommand',
 \   'output_stream': 'stderr',
 \   'callback': 'ale_linters#go#gobuild#Handler',
 \   'lint_file': 1,
--- a/ale_linters/go/gofmt.vim
+++ b/ale_linters/go/gofmt.vim
@@ -1,16 +1,10 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: gofmt for Go files
 function! ale_linters#go#gofmt#GetCommand(buffer) abort
    return ale#go#EnvString(a:buffer)
    \   . '%e -e %t'
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'gofmt',
 \   'output_stream': 'stderr',
 \   'executable': 'gofmt',
-\   'command': function('ale_linters#go#gofmt#GetCommand'),
+\   'command': 'gofmt -e %t',
 \   'callback': 'ale#handlers#unix#HandleAsError',
 \})
--- a/ale_linters/go/golangci_lint.vim
+++ b/ale_linters/go/golangci_lint.vim
@@ -10,16 +10,13 @@ function! ale_linters#go#golangci_lint#GetCommand(buffer) abort
    let l:options = ale#Var(a:buffer, 'go_golangci_lint_options')
    let l:lint_package = ale#Var(a:buffer, 'go_golangci_lint_package')
    if l:lint_package
        return ale#path#BufferCdString(a:buffer)
        \   . ale#go#EnvString(a:buffer)
        \   . '%e run '
        \   .  l:options
    endif
    return ale#path#BufferCdString(a:buffer)
    \   . ale#go#EnvString(a:buffer)
    \   . '%e run '
    \   . ale#Escape(l:filename)
    \   . ' ' . l:options
@@ -52,8 +49,8 @@ endfunction
 call ale#linter#Define('go', {
 \   'name': 'golangci-lint',
-\   'executable': {b -> ale#Var(b, 'go_golangci_lint_executable')},
+\   'executable_callback': ale#VarFunc('go_golangci_lint_executable'),
-\   'command': function('ale_linters#go#golangci_lint#GetCommand'),
+\   'command_callback': 'ale_linters#go#golangci_lint#GetCommand',
 \   'callback': 'ale_linters#go#golangci_lint#Handler',
 \   'lint_file': 1,
 \})
--- a/ale_linters/go/golint.vim
+++ b/ale_linters/go/golint.vim
@@ -1,21 +1,10 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: golint for Go files
 call ale#Set('go_golint_executable', 'golint')
 call ale#Set('go_golint_options', '')
 function! ale_linters#go#golint#GetCommand(buffer) abort
    let l:options = ale#Var(a:buffer, 'go_golint_options')
    return ale#go#EnvString(a:buffer) . '%e'
    \   . (!empty(l:options) ? ' ' . l:options : '')
    \   . ' %t'
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'golint',
 \   'output_stream': 'both',
-\   'executable': {b -> ale#Var(b, 'go_golint_executable')},
+\   'executable': 'golint',
-\   'command': function('ale_linters#go#golint#GetCommand'),
+\   'command': 'golint %t',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})
--- a/ale_linters/go/gometalinter.vim
+++ b/ale_linters/go/gometalinter.vim
@@ -14,13 +14,11 @@ function! ale_linters#go#gometalinter#GetCommand(buffer) abort
    " be calculated to absolute paths in the Handler
    if l:lint_package
        return ale#path#BufferCdString(a:buffer)
        \   . ale#go#EnvString(a:buffer)
        \   . '%e'
        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
    endif
    return ale#path#BufferCdString(a:buffer)
    \   . ale#go#EnvString(a:buffer)
    \   . '%e'
    \   . ' --include=' . ale#Escape(ale#util#EscapePCRE(l:filename))
    \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
@@ -52,8 +50,8 @@ endfunction
 call ale#linter#Define('go', {
 \   'name': 'gometalinter',
-\   'executable': {b -> ale#Var(b, 'go_gometalinter_executable')},
+\   'executable_callback': ale#VarFunc('go_gometalinter_executable'),
-\   'command': function('ale_linters#go#gometalinter#GetCommand'),
+\   'command_callback': 'ale_linters#go#gometalinter#GetCommand',
 \   'callback': 'ale_linters#go#gometalinter#Handler',
 \   'lint_file': 1,
 \})
--- a/ale_linters/go/gopls.vim
+++ b/ale_linters/go/gopls.vim
@@ -1,34 +0,0 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Author: Jerko Steiner <https://github.com/jeremija>
 " Description: https://github.com/saibing/gopls
 call ale#Set('go_gopls_executable', 'gopls')
 call ale#Set('go_gopls_options', '--mode stdio')
 function! ale_linters#go#gopls#GetCommand(buffer) abort
    return ale#go#EnvString(a:buffer)
    \   . '%e'
    \   . ale#Pad(ale#Var(a:buffer, 'go_gopls_options'))
 endfunction
 function! ale_linters#go#gopls#FindProjectRoot(buffer) abort
    let l:go_modules_off = ale#Var(a:buffer, 'go_go111module') is# 'off'
    let l:project_root = l:go_modules_off ?
    \ '' : ale#path#FindNearestFile(a:buffer, 'go.mod')
    let l:mods = ':h'
    if empty(l:project_root)
        let l:project_root = ale#path#FindNearestDirectory(a:buffer, '.git')
        let l:mods = ':h:h'
    endif
    return !empty(l:project_root) ? fnamemodify(l:project_root, l:mods) : ''
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'gopls',
 \   'lsp': 'stdio',
 \   'executable': {b -> ale#Var(b, 'go_gopls_executable')},
 \   'command': function('ale_linters#go#gopls#GetCommand'),
 \   'project_root': function('ale_linters#go#gopls#FindProjectRoot'),
 \})
--- a/ale_linters/go/gosimple.vim
+++ b/ale_linters/go/gosimple.vim
@@ -2,14 +2,13 @@
 " Description: gosimple for Go files
 function! ale_linters#go#gosimple#GetCommand(buffer) abort
-    return ale#path#BufferCdString(a:buffer) . ' '
+    return ale#path#BufferCdString(a:buffer) . ' gosimple .'
    \   . ale#go#EnvString(a:buffer) . 'gosimple .'
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'gosimple',
 \   'executable': 'gosimple',
-\   'command': function('ale_linters#go#gosimple#GetCommand'),
+\   'command_callback': 'ale_linters#go#gosimple#GetCommand',
 \   'callback': 'ale#handlers#go#Handler',
 \   'output_stream': 'both',
 \   'lint_file': 1,
--- a/ale_linters/go/gotype.vim
+++ b/ale_linters/go/gotype.vim
@@ -6,15 +6,14 @@ function! ale_linters#go#gotype#GetCommand(buffer) abort
        return ''
    endif
-    return ale#path#BufferCdString(a:buffer) . ' '
+    return ale#path#BufferCdString(a:buffer) . ' gotype .'
    \   . ale#go#EnvString(a:buffer) . 'gotype -e .'
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'gotype',
 \   'output_stream': 'stderr',
 \   'executable': 'gotype',
-\   'command': function('ale_linters#go#gotype#GetCommand'),
+\   'command_callback': 'ale_linters#go#gotype#GetCommand',
 \   'callback': 'ale#handlers#go#Handler',
 \   'lint_file': 1,
 \})
--- a/ale_linters/go/govet.vim
+++ b/ale_linters/go/govet.vim
@@ -11,7 +11,6 @@ function! ale_linters#go#govet#GetCommand(buffer) abort
    let l:options = ale#Var(a:buffer, 'go_govet_options')
    return ale#path#BufferCdString(a:buffer) . ' '
    \   . ale#go#EnvString(a:buffer)
    \   . ale#Var(a:buffer, 'go_go_executable') . ' vet '
    \   . (!empty(l:options) ? ' ' . l:options : '')
    \   . ' .'
@@ -21,8 +20,8 @@ call ale#linter#Define('go', {
 \   'name': 'govet',
 \   'aliases': ['go vet'],
 \   'output_stream': 'stderr',
-\   'executable': {b -> ale#Var(b, 'go_go_executable')},
+\   'executable_callback': ale#VarFunc('go_go_executable'),
-\   'command': function('ale_linters#go#govet#GetCommand'),
+\   'command_callback': 'ale_linters#go#govet#GetCommand',
 \   'callback': 'ale#handlers#go#Handler',
 \   'lint_file': 1,
 \})
--- a/ale_linters/go/langserver.vim
+++ b/ale_linters/go/langserver.vim
@@ -10,20 +10,19 @@ function! ale_linters#go#langserver#GetCommand(buffer) abort
    let l:options = substitute(l:options, '-gocodecompletion', '', 'g')
    let l:options = filter(split(l:options, ' '), 'empty(v:val) != 1')
-    if ale#Var(a:buffer, 'completion_enabled')
+    if(ale#Var(a:buffer, 'completion_enabled') == 1)
-        call add(l:options, '-gocodecompletion')
+      call add(l:options, '-gocodecompletion')
    endif
    let l:options = uniq(sort(l:options))
    let l:env = ale#go#EnvString(a:buffer)
-    return l:env . join(extend(l:executable, l:options), ' ')
+    return join(extend(l:executable, l:options), ' ')
 endfunction
 call ale#linter#Define('go', {
 \   'name': 'golangserver',
 \   'lsp': 'stdio',
-\   'executable': {b -> ale#Var(b, 'go_langserver_executable')},
+\   'executable_callback': ale#VarFunc('go_langserver_executable'),
-\   'command': function('ale_linters#go#langserver#GetCommand'),
+\   'command_callback': 'ale_linters#go#langserver#GetCommand',
-\   'project_root': function('ale#go#FindProjectRoot'),
+\   'project_root_callback': 'ale#go#FindProjectRoot',
 \})
--- a/ale_linters/go/staticcheck.vim
+++ b/ale_linters/go/staticcheck.vim
@@ -8,18 +8,17 @@ function! ale_linters#go#staticcheck#GetCommand(buffer) abort
    let l:filename = expand('#' . a:buffer . ':t')
    let l:options = ale#Var(a:buffer, 'go_staticcheck_options')
    let l:lint_package = ale#Var(a:buffer, 'go_staticcheck_lint_package')
    let l:env = ale#go#EnvString(a:buffer)
    " BufferCdString is used so that we can be sure the paths output from
    " staticcheck can be calculated to absolute paths in the Handler
    if l:lint_package
        return ale#path#BufferCdString(a:buffer)
-        \   . l:env . 'staticcheck'
+        \   . 'staticcheck'
        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
    endif
    return ale#path#BufferCdString(a:buffer)
-    \   . l:env . 'staticcheck'
+    \   . 'staticcheck'
    \   . (!empty(l:options) ? ' ' . l:options : '')
    \   . ' ' . ale#Escape(l:filename)
 endfunction
@@ -27,7 +26,7 @@ endfunction
 call ale#linter#Define('go', {
 \   'name': 'staticcheck',
 \   'executable': 'staticcheck',
-\   'command': function('ale_linters#go#staticcheck#GetCommand'),
+\   'command_callback': 'ale_linters#go#staticcheck#GetCommand',
 \   'callback': 'ale#handlers#go#Handler',
 \   'output_stream': 'both',
 \   'lint_file': 1,
--- a/ale_linters/graphql/eslint.vim
+++ b/ale_linters/graphql/eslint.vim
@@ -3,7 +3,7 @@
 call ale#linter#Define('graphql', {
 \   'name': 'eslint',
-\   'executable': function('ale#handlers#eslint#GetExecutable'),
+\   'executable_callback': 'ale#handlers#eslint#GetExecutable',
-\   'command': function('ale#handlers#eslint#GetCommand'),
+\   'command_callback': 'ale#handlers#eslint#GetCommand',
 \   'callback': 'ale#handlers#eslint#Handle',
 \})
--- a/ale_linters/graphql/gqlint.vim
+++ b/ale_linters/graphql/gqlint.vim
@@ -1,15 +1,9 @@
 " Author: Michiel Westerbeek <happylinks@gmail.com>
 " Description: Linter for GraphQL Schemas
 function! ale_linters#graphql#gqlint#GetCommand(buffer) abort
    return ale#path#BufferCdString(a:buffer)
    \   . 'gqlint'
    \   . ' --reporter=simple %t'
 endfunction
 call ale#linter#Define('graphql', {
 \   'name': 'gqlint',
 \   'executable': 'gqlint',
-\   'command': function('ale_linters#graphql#gqlint#GetCommand'),
+\   'command': 'gqlint --reporter=simple %t',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
 \})
--- a/ale_linters/hack/hack.vim
+++ b/ale_linters/hack/hack.vim
@@ -16,7 +16,7 @@ endfunction
 call ale#linter#Define('hack', {
 \   'name': 'hack',
 \   'lsp': 'stdio',
-\   'executable': function('ale_linters#hack#hack#GetExecutable'),
+\   'executable_callback': 'ale_linters#hack#hack#GetExecutable',
 \   'command': '%e lsp --from vim-ale',
-\   'project_root': function('ale_linters#hack#hack#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#hack#hack#GetProjectRoot',
 \})
--- a/ale_linters/hack/hhast.vim
+++ b/ale_linters/hack/hhast.vim
@@ -9,7 +9,7 @@ function! ale_linters#hack#hhast#GetProjectRoot(buffer) abort
    let l:hhconfig = ale#path#FindNearestFile(a:buffer, '.hhconfig')
    if empty(l:hhconfig)
-        return ''
+      return ''
    endif
    let l:root = fnamemodify(l:hhconfig, ':h')
@@ -33,8 +33,8 @@ endfunction
 call ale#linter#Define('hack', {
 \   'name': 'hhast',
 \   'lsp': 'stdio',
-\   'executable': function('ale_linters#hack#hhast#GetExecutable'),
+\   'executable_callback': 'ale_linters#hack#hhast#GetExecutable',
 \   'command': '%e --mode lsp --from vim-ale',
-\   'project_root': function('ale_linters#hack#hhast#GetProjectRoot'),
+\   'project_root_callback': 'ale_linters#hack#hhast#GetProjectRoot',
-\   'initialization_options': function('ale_linters#hack#hhast#GetInitializationOptions'),
+\   'initialization_options_callback': 'ale_linters#hack#hhast#GetInitializationOptions',
 \})
--- a/ale_linters/haml/hamllint.vim
+++ b/ale_linters/haml/hamllint.vim
@@ -1,12 +1,6 @@
 " Author: Patrick Lewis - https://github.com/patricklewis, thenoseman - https://github.com/thenoseman
 " Description: haml-lint for Haml files
 call ale#Set('haml_hamllint_executable', 'haml-lint')
 function! ale_linters#haml#hamllint#GetExecutable(buffer) abort
    return ale#Var(a:buffer, 'haml_hamllint_executable')
 endfunction
 function! ale_linters#haml#hamllint#GetCommand(buffer) abort
    let l:prefix = ''
@@ -19,7 +13,7 @@ function! ale_linters#haml#hamllint#GetCommand(buffer) abort
    " See https://github.com/brigade/haml-lint/blob/master/lib/haml_lint/linter/rubocop.rb#L89
    "     HamlLint::Linter::RuboCop#rubocop_flags
    if !empty(l:rubocop_config_file_path)
-        if has('win32')
+        if ale#Has('win32')
            let l:prefix = 'set HAML_LINT_RUBOCOP_CONF=' . ale#Escape(l:rubocop_config_file_path) . ' &&'
        else
            let l:prefix = 'HAML_LINT_RUBOCOP_CONF=' . ale#Escape(l:rubocop_config_file_path)
@@ -27,7 +21,7 @@ function! ale_linters#haml#hamllint#GetCommand(buffer) abort
    endif
    return (!empty(l:prefix) ? l:prefix . ' ' : '')
-    \   . ale_linters#haml#hamllint#GetExecutable(a:buffer)
+    \   . 'haml-lint'
    \   . (!empty(l:hamllint_config_file_path) ? ' --config ' . ale#Escape(l:hamllint_config_file_path) : '')
    \   . ' %t'
 endfunction
@@ -51,7 +45,7 @@ endfunction
 call ale#linter#Define('haml', {
 \   'name': 'hamllint',
-\   'executable': function('ale_linters#haml#hamllint#GetExecutable'),
+\   'executable': 'haml-lint',
-\   'command': function('ale_linters#haml#hamllint#GetCommand'),
+\   'command_callback': 'ale_linters#haml#hamllint#GetCommand',
 \   'callback': 'ale_linters#haml#hamllint#Handle'
 \})
--- a/ale_linters/handlebars/embertemplatelint.vim
+++ b/ale_linters/handlebars/embertemplatelint.vim
@@ -31,9 +31,9 @@ endfunction
 call ale#linter#Define('handlebars', {
 \   'name': 'ember-template-lint',
-\   'executable': {b -> ale#node#FindExecutable(b, 'handlebars_embertemplatelint', [
+\   'executable_callback': ale#node#FindExecutableFunc('handlebars_embertemplatelint', [
 \       'node_modules/.bin/ember-template-lint',
-\   ])},
+\   ]),
 \   'command': '%e --json %t',
 \   'callback': 'ale_linters#handlebars#embertemplatelint#Handle',
 \})
--- a/ale_linters/haskell/cabal_ghc.vim
+++ b/ale_linters/haskell/cabal_ghc.vim
@@ -4,8 +4,7 @@
 call ale#Set('haskell_cabal_ghc_options', '-fno-code -v0')
 function! ale_linters#haskell#cabal_ghc#GetCommand(buffer) abort
-    return ale#path#BufferCdString(a:buffer)
+    return 'cabal exec -- ghc '
    \   . 'cabal exec -- ghc '
    \   . ale#Var(a:buffer, 'haskell_cabal_ghc_options')
    \   . ' %t'
 endfunction
@@ -15,6 +14,6 @@ call ale#linter#Define('haskell', {
 \   'aliases': ['cabal-ghc'],
 \   'output_stream': 'stderr',
 \   'executable': 'cabal',
-\   'command': function('ale_linters#haskell#cabal_ghc#GetCommand'),
+\   'command_callback': 'ale_linters#haskell#cabal_ghc#GetCommand',
 \   'callback': 'ale#handlers#haskell#HandleGHCFormat',
 \})
--- a/ale_linters/haskell/ghc-mod.vim
+++ b/ale_linters/haskell/ghc-mod.vim
@@ -0,0 +1,18 @@
 " Author: wizzup <wizzup@gmail.com>
 " Description: ghc-mod for Haskell files
 call ale#linter#Define('haskell', {
 \   'name': 'ghc_mod',
 \   'aliases': ['ghc-mod'],
 \   'executable': 'ghc-mod',
 \   'command': 'ghc-mod --map-file %s=%t check %s',
 \   'callback': 'ale#handlers#haskell#HandleGHCFormat',
 \})
 call ale#linter#Define('haskell', {
 \   'name': 'stack_ghc_mod',
 \   'aliases': ['stack-ghc-mod'],
 \   'executable': 'stack',
 \   'command': 'stack exec ghc-mod -- --map-file %s=%t check %s',
 \   'callback': 'ale#handlers#haskell#HandleGHCFormat',
 \})
--- a/ale_linters/haskell/ghc.vim
+++ b/ale_linters/haskell/ghc.vim
@@ -13,6 +13,6 @@ call ale#linter#Define('haskell', {
 \   'name': 'ghc',
 \   'output_stream': 'stderr',
 \   'executable': 'ghc',
-\   'command': function('ale_linters#haskell#ghc#GetCommand'),
+\   'command_callback': 'ale_linters#haskell#ghc#GetCommand',
 \   'callback': 'ale#handlers#haskell#HandleGHCFormat',
 \})
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
w0rp	0c17ba2a0f	Merge pull request #2016 from terryding77/master fix: change google_java_format_* to java_google_java_format_*	2018-10-25 15:34:58 +01:00
w0rp	2dbfbe7b02	Merge pull request #2012 from paihu/fix-cdstring-win32-change-drive Fix #2011 MS Windows, lint error when current drive and target file drive is different.	2018-10-25 14:25:27 +01:00
Linda_pp	ceb2e8d350	Fix E523 on asynchronous truncated echo (#1987 )	2018-10-11 15:01:46 +01:00
Matteo Centenaro	96d84aec8f	FIX: use mix from the project root directory (#1954 ) * FIX: use mix from the project root directory * Move find root project function to autoloaded handlers * add tests for #ale#handlers#elixr#FindMixProjectRoot	2018-10-10 17:23:21 +01:00