Stop the completion tests from failing randomly

* windows compatible warning match pattern for erlc

.appveyor.yml

@@ -0,0 +1,40 @@
+---
+# Disabling building for AppVeyor. We are just testing things.
+build: false
+clone_depth: 10
+# Use the directory C:\testplugin so test directories will mostly work.
+clone_folder: C:\testplugin
+
+# Cache the vim and vader directories between builds.
+cache:
+  - C:\vim -> .appveyor.yml
+  - C:\vader -> .appveyor.yml
+
+init:
+  # Stop git from changing newlines
+  - git config --global core.autocrlf input
+
+install:
+  # Download and unpack Vim
+  - ps: >-
+      if (!(Test-Path -Path C:\vim)){
+        Add-Type -A System.IO.Compression.FileSystem
+        Invoke-WebRequest ftp://ftp.vim.org/pub/vim/pc/vim80-586w32.zip `
+          -OutFile C:\vim.zip
+        [IO.Compression.ZipFile]::ExtractToDirectory('C:\vim.zip', 'C:\vim')
+        Invoke-WebRequest ftp://ftp.vim.org/pub/vim/pc/vim80-586rt.zip `
+          -OutFile C:\rt.zip
+        [IO.Compression.ZipFile]::ExtractToDirectory('C:\rt.zip', 'C:\vim')
+      }
+  # Clone Vader and check out the commit we want
+  - ps: >-
+      if (!(Test-Path -Path C:\vader)){
+        git clone https://github.com/junegunn/vader.vim C:\vader 2> $null
+        cd C:\vader
+        git checkout -qf c6243dd81c98350df4dec608fa972df98fa2a3af 2> $null
+      }
+
+test_script:
+  - cd C:\testplugin
+  - 'C:\vim\vim\vim80\vim.exe -u test\vimrc "+Vader!
+    test/*.vader test/*/*.vader test/*/*/*.vader test/*/*/*.vader"'

.editorconfig

@@ -0,0 +1,14 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# Top-most EditorConfig file
+root = true
+
+# Match and apply these rules for all file
+# types you open in your code editor
+[*]
+# Unix-style newlines
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true

.gitattributes

@@ -6,7 +6,7 @@
 /Makefile export-ignore
 /PULL_REQUEST_TEMPLATE.md export-ignore
 /README.md export-ignore
-/custom-checks export-ignore
 /img export-ignore
 /run-tests export-ignore
+/run-tests.bat export-ignore
 /test export-ignore

.gitignore

@@ -1,5 +1,6 @@
 /init.vim
 /doc/tags
 .*
+!.editorconfig
 *.obj
 tags

CONTRIBUTING.md

@@ -129,7 +129,7 @@ giving some unfair preference to any particular tool or language.
 
 The "online documentation" file used for this project lives in `doc/ale.txt`.
 This is the file used for generating `:help` text inside Vim itself. There are
-some guidlines to follow for this file.
+some guidelines to follow for this file.
 
 1. Keep all text within a column size of 79 characters, inclusive.
 2. Open a section with 79 `=` or `-` characters, for headings and subheadings.
@@ -160,7 +160,7 @@ to look up the default value easily by typing `:echo g:ale_...`.
 Should the principal author of the ALE project and all collaborators with the
 required access needed to properly administrate the project on GitHub or any
 other website either perish or disappear, whether by tragic traffic accident
-or government adduction, etc., action should be taken to ensure that the
+or government abduction, etc., action should be taken to ensure that the
 project continues. If no one is left to administer the project where it is
 hosted, please fork the project and nominate someone capable to administer it.
 Preferably, in such an event, a single fork of the project will replace the

README.md

@@ -1,4 +1,5 @@
-# Asynchronous Lint Engine [![Build Status](https://travis-ci.org/w0rp/ale.svg?branch=master)](https://travis-ci.org/w0rp/ale)
+# 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/github/w0rp/ale?svg=true)](https://ci.appveyor.com/project/w0rp/ale)
+
 
 ![ALE Logo by Mark Grealish - https://www.bhalash.com/](img/logo.jpg?raw=true)
 
@@ -36,13 +37,14 @@ servers with similar enough protocols, like `tsserver`.
     2. [How can I keep the sign gutter open?](#faq-keep-signs)
     3. [How can I change the signs ALE uses?](#faq-change-signs)
     4. [How can I show errors or warnings in my statusline?](#faq-statusline)
-    5. [How can I change the format for echo messages?](#faq-echo-format)
-    6. [How can I execute some code when ALE stops linting?](#faq-autocmd)
-    7. [How can I navigate between errors quickly?](#faq-navigation)
-    8. [How can I run linters only when I save files?](#faq-lint-on-save)
-    9. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
-    10. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
-    11. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
+    5. [How can I show errors or warnings in my lightline?](#faq-lightline)
+    6. [How can I change the format for echo messages?](#faq-echo-format)
+    7. [How can I execute some code when ALE stops linting?](#faq-autocmd)
+    8. [How can I navigate between errors quickly?](#faq-navigation)
+    9. [How can I run linters only when I save files?](#faq-lint-on-save)
+    10. [How can I use the quickfix list instead of the loclist?](#faq-quickfix)
+    11. [How can I check JSX files with both stylelint and eslint?](#faq-jsx-stylelint-eslint)
+    12. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
 
 <a name="supported-languages"></a>
 
@@ -55,88 +57,99 @@ tools will be run in combination, so they can be complementary.
 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) |
-| AsciiDoc | [proselint](http://proselint.com/)|
+| AsciiDoc | [proselint](http://proselint.com/) |
 | Awk | [gawk](https://www.gnu.org/software/gawk/)|
-| Bash | [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/) |
-| Bourne Shell | [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/) |
-| C | [cppcheck](http://cppcheck.sourceforge.net), [gcc](https://gcc.gnu.org/), [clang](http://clang.llvm.org/), [clang-format](https://clang.llvm.org/docs/ClangFormat.html)|
-| C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangcheck](http://clang.llvm.org/docs/ClangCheck.html), [clangtidy](http://clang.llvm.org/extra/clang-tidy/), [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint), [gcc](https://gcc.gnu.org/), [clang-format](https://clang.llvm.org/docs/ClangFormat.html)|
-| C# | [mcs](http://www.mono-project.com/docs/about-mono/languages/csharp/) |
+| Bash | shell [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/) |
+| Bourne Shell | shell [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/) |
+| C | [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint), [gcc](https://gcc.gnu.org/), [clang](http://clang.llvm.org/), [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html)|
+| C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangcheck](http://clang.llvm.org/docs/ClangCheck.html) !!, [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint) !!, [gcc](https://gcc.gnu.org/), [clang-format](https://clang.llvm.org/docs/ClangFormat.html)|
+| 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|
 | Chef | [foodcritic](http://www.foodcritic.io/) |
 | 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/), [stylelint](https://github.com/stylelint/stylelint) |
+| Crystal | [crystal](https://crystal-lang.org/) !! |
+| CSS | [csslint](http://csslint.net/), [stylelint](https://github.com/stylelint/stylelint), [prettier](https://github.com/prettier/prettier) |
 | Cython (pyrex filetype) | [cython](http://cython.org/) |
 | D | [dmd](https://dlang.org/dmd-linux.html) |
 | Dart | [dartanalyzer](https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_cli) |
 | Dockerfile | [hadolint](https://github.com/lukasmartinelli/hadolint) |
-| Elixir | [credo](https://github.com/rrrene/credo), [dogma](https://github.com/lpil/dogma) |
-| Elm | [elm-make](https://github.com/elm-lang/elm-make) |
+| Elixir | [credo](https://github.com/rrrene/credo), [dogma](https://github.com/lpil/dogma) !! |
+| Elm | [elm-format](https://github.com/avh4/elm-format), [elm-make](https://github.com/elm-lang/elm-make) |
 | Erb | [erb](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) |
 | Fortran | [gcc](https://gcc.gnu.org/) |
 | FusionScript | [fusion-lint](https://github.com/RyanSquared/fusionscript) |
-| Go | [gofmt -e](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint), [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) |
+| GLSL | [glslang](https://github.com/KhronosGroup/glslang) |
+| Go | [gofmt](https://golang.org/cmd/gofmt/), [go vet](https://golang.org/cmd/vet/), [golint](https://godoc.org/github.com/golang/lint), [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) !! |
 | GraphQL | [gqlint](https://github.com/happylinks/gqlint) |
-| Haml | [haml-lint](https://github.com/brigade/haml-lint)
+| Haml | [haml-lint](https://github.com/brigade/haml-lint) |
 | Handlebars | [ember-template-lint](https://github.com/rwjblue/ember-template-lint) |
-| Haskell | [ghc](https://www.haskell.org/ghc/), [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) |
+| Haskell | [ghc](https://www.haskell.org/ghc/), [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) |
 | HTML | [HTMLHint](http://htmlhint.com/), [proselint](http://proselint.com/), [tidy](http://www.html-tidy.org/) |
 | Idris | [idris](http://www.idris-lang.org/) |
 | Java | [checkstyle](http://checkstyle.sourceforge.net), [javac](http://www.oracle.com/technetwork/java/javase/downloads/index.html) |
-| JavaScript | [eslint](http://eslint.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [flow](https://flowtype.org/), [standard](http://standardjs.com/), [prettier](https://github.com/prettier/prettier) (and `prettier-eslint`, `prettier-standard`), [xo](https://github.com/sindresorhus/xo)
-| JSON | [jsonlint](http://zaa.ch/jsonlint/) |
-| Kotlin | [kotlinc](https://kotlinlang.org), [ktlint](https://ktlint.github.io) see `:help ale-integration-kotlin` for configuration instructions
+| JavaScript | [eslint](http://eslint.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [flow](https://flowtype.org/), [prettier](https://github.com/prettier/prettier), prettier-eslint >= 4.2.0, prettier-standard, [standard](http://standardjs.com/), [xo](https://github.com/sindresorhus/xo)
+| JSON | [jsonlint](http://zaa.ch/jsonlint/), [prettier](https://github.com/prettier/prettier) |
+| Kotlin | [kotlinc](https://kotlinlang.org) !!, [ktlint](https://ktlint.github.io) !! see `:help ale-integration-kotlin` for configuration instructions |
 | LaTeX | [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck), [proselint](http://proselint.com/) |
+| LLVM | [llc](https://llvm.org/docs/CommandGuide/llc.html) |
 | Lua | [luacheck](https://github.com/mpeterv/luacheck) |
-| Markdown | [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
+| Markdown | [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale), [remark-lint](https://github.com/wooorm/remark-lint) !! |
 | MATLAB | [mlint](https://www.mathworks.com/help/matlab/ref/mlint.html) |
-| Nim | [nim](https://nim-lang.org/docs/nimc.html) |
+| Nim | [nim check](https://nim-lang.org/docs/nimc.html) !! |
 | nix | [nix-instantiate](http://nixos.org/nix/manual/#sec-nix-instantiate) |
 | nroff | [proselint](http://proselint.com/)|
 | Objective-C | [clang](http://clang.llvm.org/) |
 | Objective-C++ | [clang](http://clang.llvm.org/) |
-| OCaml | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-ocaml-merlin` for configuration instructions
+| OCaml | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-ocaml-merlin` for configuration instructions |
 | Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic) |
 | PHP | [hack](http://hacklang.org/), [langserver](https://github.com/felixfbecker/php-language-server), [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) |
 | Pod | [proselint](http://proselint.com/)|
 | Pug | [pug-lint](https://github.com/pugjs/pug-lint) |
 | Puppet | [puppet](https://puppet.com), [puppet-lint](https://puppet-lint.com) |
-| Python | [autopep8](https://github.com/hhatto/autopep8), [flake8](http://flake8.pycqa.org/en/latest/), [isort](https://github.com/timothycrosley/isort), [mypy](http://mypy-lang.org/), [pycodestyle](https://github.com/PyCQA/pycodestyle), [pylint](https://www.pylint.org/), [yapf](https://github.com/google/yapf) |
+| Python | [autopep8](https://github.com/hhatto/autopep8), [flake8](http://flake8.pycqa.org/en/latest/), [isort](https://github.com/timothycrosley/isort), [mypy](http://mypy-lang.org/), [pycodestyle](https://github.com/PyCQA/pycodestyle), [pylint](https://www.pylint.org/) !!, [yapf](https://github.com/google/yapf) |
 | R | [lintr](https://github.com/jimhester/lintr) |
-| ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-reason-merlin` for configuration instructions
-| reStructuredText | [proselint](http://proselint.com/)|
+| ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-reason-merlin` for configuration instructions |
+| reStructuredText | [proselint](http://proselint.com/) |
 | 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) |
-| Rust |  cargo (see `:help ale-integration-rust` for configuration instructions), [rls](https://github.com/rust-lang-nursery/rls), [rustc](https://www.rust-lang.org/) |
+| 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) |
+| Rust |  cargo !! (see `:help ale-integration-rust` for configuration instructions), [rls](https://github.com/rust-lang-nursery/rls), [rustc](https://www.rust-lang.org/) |
 | SASS | [sass-lint](https://www.npmjs.com/package/sass-lint), [stylelint](https://github.com/stylelint/stylelint) |
-| SCSS | [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint), [stylelint](https://github.com/stylelint/stylelint) |
+| SCSS | [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint), [stylelint](https://github.com/stylelint/stylelint), [prettier](https://github.com/prettier/prettier) |
 | Scala | [scalac](http://scala-lang.org), [scalastyle](http://www.scalastyle.org) |
-| Slim | [slim-lint](https://github.com/sds/slim-lint)
+| Slim | [slim-lint](https://github.com/sds/slim-lint) |
 | SML | [smlnj](http://www.smlnj.org/) |
+| Solidity | [solium](https://github.com/duaraghav8/Solium) |
 | Stylus | [stylelint](https://github.com/stylelint/stylelint) |
 | SQL | [sqlint](https://github.com/purcell/sqlint) |
 | Swift | [swiftlint](https://github.com/realm/SwiftLint), [swiftformat](https://github.com/nicklockwood/SwiftFormat) |
-| Tcl | [nagelfar](http://nagelfar.sourceforge.net)|
+| Tcl | [nagelfar](http://nagelfar.sourceforge.net) !! |
 | Texinfo | [proselint](http://proselint.com/)|
 | Text^ | [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
-| TypeScript | [eslint](http://eslint.org/), [tslint](https://github.com/palantir/tslint), tsserver, typecheck |
+| Thrift | [thrift](http://thrift.apache.org/) |
+| TypeScript | [eslint](http://eslint.org/), [tslint](https://github.com/palantir/tslint), tsserver, typecheck, [prettier](https://github.com/prettier/prettier) |
 | 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^ | [proselint](http://proselint.com/)|
 | XHTML | [proselint](http://proselint.com/)|
-| XML | [xmllint](http://xmlsoft.org/xmllint.html/)|
+| XML | [xmllint](http://xmlsoft.org/xmllint.html)|
 | YAML | [swaglint](https://github.com/byCedric/swaglint), [yamllint](https://yamllint.readthedocs.io/) |
 
-* *^ No linters for text or Vim help filetypes are enabled by default.*
-
 <a name="usage"></a>
 
 ## 2. Usage
@@ -397,9 +410,70 @@ set statusline=%{LinterStatus()}
 
 See `:help ale#statusline#Count()` for more information.
 
+<a name="faq-lightline"></a>
+
+### 5.v. How can I show errors or warnings in my lightline?
+
+[lightline](https://github.com/itchyny/lightline.vim) does not have built-in
+support for ALE, nevertheless it's easy to do it yourself:
+
+```vim
+" This is regular lightline configuration, we just added
+" 'linter_warnings', 'linter_errors' and 'linter_ok' to
+" the active right panel. Feel free to move it anywhere.
+" `component_expand' and `component_type' are required.
+"
+" For more info on how this works, see lightline documentation.
+let g:lightline = {
+      \ 'active': {
+      \   'right': [ [ 'lineinfo' ],
+      \              [ 'percent' ],
+      \              [ 'linter_warnings', 'linter_errors', 'linter_ok' ],
+      \              [ 'fileformat', 'fileencoding', 'filetype' ] ]
+      \ },
+      \ 'component_expand': {
+      \   'linter_warnings': 'LightlineLinterWarnings',
+      \   'linter_errors': 'LightlineLinterErrors',
+      \   'linter_ok': 'LightlineLinterOK'
+      \ },
+      \ 'component_type': {
+      \   'linter_warnings': 'warning',
+      \   'linter_errors': 'error',
+      \   'linter_ok': 'ok'
+      \ },
+      \ }
+
+autocmd User ALELint call lightline#update()
+
+" ale + lightline
+function! LightlineLinterWarnings() abort
+  let l:counts = ale#statusline#Count(bufnr(''))
+  let l:all_errors = l:counts.error + l:counts.style_error
+  let l:all_non_errors = l:counts.total - l:all_errors
+  return l:counts.total == 0 ? '' : printf('%d --', all_non_errors)
+endfunction
+
+function! LightlineLinterErrors() abort
+  let l:counts = ale#statusline#Count(bufnr(''))
+  let l:all_errors = l:counts.error + l:counts.style_error
+  let l:all_non_errors = l:counts.total - l:all_errors
+  return l:counts.total == 0 ? '' : printf('%d >>', all_errors)
+endfunction
+
+function! LightlineLinterOK() abort
+  let l:counts = ale#statusline#Count(bufnr(''))
+  let l:all_errors = l:counts.error + l:counts.style_error
+  let l:all_non_errors = l:counts.total - l:all_errors
+  return l:counts.total == 0 ? '✓' : ''
+endfunction
+```
+
+See `:help ale#statusline#Count()` and [lightline documentation](https://github.com/itchyny/lightline.vim#advanced-configuration)
+for more information.
+
 <a name="faq-echo-format"></a>
 
-### 5.v. How can I change the format for echo messages?
+### 5.vi. How can I change the format for echo messages?
 
 There are 3 global options that allow customizing the echoed message.
 
@@ -424,7 +498,7 @@ Will give you:
 
 <a name="faq-autocmd"></a>
 
-### 5.vi. How can I execute some code when ALE stops linting?
+### 5.vii. How can I execute some code when ALE stops linting?
 
 ALE runs its own [autocmd](http://vimdoc.sourceforge.net/htmldoc/autocmd.html)
 event whenever has a linter has been successfully executed and processed. This
@@ -439,7 +513,7 @@ augroup END
 
 <a name="faq-navigation"></a>
 
-### 5.vii. How can I navigate between errors quickly?
+### 5.viii. How can I navigate between errors quickly?
 
 ALE offers some commands with `<Plug>` keybinds for moving between warnings and
 errors quickly. You can map the keys Ctrl+j and Ctrl+k to moving between errors
@@ -455,7 +529,7 @@ For more information, consult the online documentation with
 
 <a name="faq-lint-on-save"></a>
 
-### 5.viii. How can I run linters only when I save files?
+### 5.ix. How can I run linters only when I save files?
 
 ALE offers an option `g:ale_lint_on_save` for enabling running the linters
 when files are saved. This option is enabled by default. If you only
@@ -475,7 +549,7 @@ files, you can set `g:ale_lint_on_save` to `0`.
 
 <a name="faq-quickfix"></a>
 
-### 5.ix. How can I use the quickfix list instead of the loclist?
+### 5.x. How can I use the quickfix list instead of the loclist?
 
 The quickfix list can be enabled by turning the `g:ale_set_quickfix`
 option on. If you wish to also disable the loclist, you can disable
@@ -502,7 +576,7 @@ let g:ale_keep_list_window_open = 1
 
 <a name="faq-jsx-stylelint-eslint"></a>
 
-### 5.x. How can I check JSX files with both stylelint and eslint?
+### 5.xi. How can I check JSX files with both stylelint and eslint?
 
 If you configure ALE options correctly in your vimrc file, and install
 the right tools, you can check JSX files with stylelint and eslint.
@@ -535,7 +609,7 @@ no linter will be run twice for the same file.
 
 <a name="faq-my-battery-is-sad"></a>
 
-### 5.xi. Will this plugin eat all of my laptop battery power?
+### 5.xii. 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

ale_linters/c/clangtidy.vim

@@ -0,0 +1,64 @@
+" Author: vdeurzen <tim@kompiler.org>, w0rp <devw0rp@gmail.com>,
+" gagbo <gagbobada@gmail.com>, Andrej Radovic <r.andrej@gmail.com>
+" Description: clang-tidy linter for c files
+
+call ale#Set('c_clangtidy_executable', 'clang-tidy')
+" Set this option to check the checks clang-tidy will apply.
+" The number of checks that can be applied to C files is limited in contrast to
+" C++
+"
+" 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', ['*'])
+" Set this option to manually set some options for clang-tidy.
+" This will disable compile_commands.json detection.
+call ale#Set('c_clangtidy_options', '')
+call ale#Set('c_build_dir', '')
+
+function! ale_linters#c#clangtidy#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'c_clangtidy_executable')
+endfunction
+
+function! s:GetBuildDirectory(buffer) abort
+    " Don't include build directory for header files, as compile_commands.json
+    " files don't consider headers to be translation units, and provide no
+    " commands for compiling header files.
+    if expand('#' . a:buffer) =~# '\v\.(h|hpp)$'
+        return ''
+    endif
+
+    let l:build_dir = ale#Var(a:buffer, 'c_build_dir')
+
+    " c_build_dir has the priority if defined
+    if !empty(l:build_dir)
+        return l:build_dir
+    endif
+
+    return ale#c#FindCompileCommands(a:buffer)
+endfunction
+
+function! ale_linters#c#clangtidy#GetCommand(buffer) abort
+    let l:checks = join(ale#Var(a:buffer, 'c_clangtidy_checks'), ',')
+    let l:build_dir = s:GetBuildDirectory(a:buffer)
+
+    " Get the extra options if we couldn't find a build directory.
+    let l:options = empty(l:build_dir)
+    \   ? ale#Var(a:buffer, 'c_clangtidy_options')
+    \   : ''
+
+    return ale#Escape(ale_linters#c#clangtidy#GetExecutable(a:buffer))
+    \   . (!empty(l:checks) ? ' -checks=' . ale#Escape(l:checks) : '')
+    \   . ' %s'
+    \   . (!empty(l:build_dir) ? ' -p ' . ale#Escape(l:build_dir) : '')
+    \   . (!empty(l:options) ? ' -- ' . l:options : '')
+endfunction
+
+call ale#linter#Define('c', {
+\   'name': 'clangtidy',
+\   'output_stream': 'stdout',
+\   'executable_callback': 'ale_linters#c#clangtidy#GetExecutable',
+\   'command_callback': 'ale_linters#c#clangtidy#GetCommand',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/cs/mcsc.vim

@@ -0,0 +1,87 @@
+" general mcs options which are likely to stay constant across
+" source trees like -pkg:dotnet
+let g:ale_cs_mcsc_options = get(g:, 'ale_cs_mcsc_options', '')
+
+" path string pointing the linter to the base path of the
+" source tree to check
+let g:ale_cs_mcsc_source = get(g:, 'ale_cs_mcsc_source','.')
+
+" list of search paths for additional assemblies to consider
+let g:ale_cs_mcsc_assembly_path = get(g:, 'ale_cs_mcsc_assembly_path',[])
+
+" list of assemblies to consider
+let g:ale_cs_mcsc_assemblies = get(g:, 'ale_cs_mcsc_assemblies',[])
+function! ale_linters#cs#mcsc#GetCommand(buffer) abort
+
+    " if list of assembly search paths is not empty convert it to
+    " appropriate -lib: parameter of mcs
+    let l:path = ale#Var(a:buffer, 'cs_mcsc_assembly_path')
+
+    if !empty(l:path)
+         let l:path = '-lib:"' . join(l:path, '","') .'"'
+    else
+        let l:path =''
+    endif
+
+    " if list of assemblies to link is not empty convert it to the
+    " appropriate -r: parameter of mcs
+    let l:assemblies = ale#Var(a:buffer, 'cs_mcsc_assemblies')
+
+    if !empty(l:assemblies)
+        let l:assemblies = '-r:"' . join(l:assemblies, '","') . '"'
+    else
+        let l:assemblies =''
+    endif
+
+    " register temporary module target file with ale
+    let l:out = tempname()
+    call ale#engine#ManageFile(a:buffer, l:out)
+
+    " assemble linter command string to be executed by ale
+    " implicitly set -unsafe mcs flag set compilation
+    " target to module (-t:module), direct mcs output to
+    " temporary file (-out)
+    "
+    return 'cd "' . ale#Var(a:buffer, 'cs_mcsc_source') . '";'
+    \    . 'mcs -unsafe'
+    \    . ' ' . ale#Var(a:buffer, 'cs_mcsc_options')
+    \    . ' ' . l:path
+    \    . ' ' . l:assemblies
+    \    . ' -out:' . l:out
+    \    . ' -t:module'
+    \    . ' -recurse:"*.cs"'
+endfunction
+
+function! ale_linters#cs#mcsc#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:pattern = '^\(.\+\.cs\)(\(\d\+\),\(\d\+\)): \(.\+\): \(.\+\)'
+    let l:output = []
+    let l:source = ale#Var(a:buffer, 'cs_mcsc_source')
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'filename': fnamemodify(l:source . '/' . l:match[1], ':p'),
+        \   'lnum': l:match[2] + 0,
+        \   'col': l:match[3] + 0,
+        \   'text': l:match[4] . ': ' . l:match[5],
+        \   'type': l:match[4] =~# '^error' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cs',{
+\   'name': 'mcsc',
+\   'output_stream': 'stderr',
+\   'executable': 'mcs',
+\   'command_callback': 'ale_linters#cs#mcsc#GetCommand',
+\   'callback': 'ale_linters#cs#mcsc#Handle',
+\   'lint_file': 1
+\})

ale_linters/cuda/nvcc.vim

@@ -0,0 +1,56 @@
+" Author: blahgeek <i@blahgeek.com>
+" Description: NVCC linter for cuda files
+
+call ale#Set('cuda_nvcc_executable', 'nvcc')
+call ale#Set('cuda_nvcc_options', '-std=c++11')
+
+function! ale_linters#cuda#nvcc#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'cuda_nvcc_executable')
+endfunction
+
+function! ale_linters#cuda#nvcc#GetCommand(buffer) abort
+    " Unused: use ale#util#nul_file
+    " let l:output_file = tempname() . '.ii'
+    " call ale#engine#ManageFile(a:buffer, l:output_file)
+
+    return ale#Escape(ale_linters#cuda#nvcc#GetExecutable(a:buffer))
+    \   . ' -cuda '
+    \   . ale#c#IncludeOptions(ale#c#FindLocalHeaderPaths(a:buffer))
+    \   . ale#Var(a:buffer, 'cuda_nvcc_options') . ' %s'
+    \   . ' -o ' . g:ale#util#nul_file
+endfunction
+
+function! ale_linters#cuda#nvcc#HandleNVCCFormat(buffer, lines) abort
+    " Look for lines like the following.
+    "
+    " test.cu(8): error: argument of type "void *" is incompatible with parameter of type "int *"
+    let l:pattern = '\v^([^:\(\)]+):?\(?(\d+)\)?:(\d+)?:?\s*\w*\s*(error|warning): (.+)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+
+        let l:item = {
+        \   'lnum': str2nr(l:match[2]),
+        \   'type': l:match[4] =~# 'error' ? 'E' : 'W',
+        \   'text': l:match[5],
+        \   'filename': fnamemodify(l:match[1], ':p'),
+        \}
+
+        if !empty(l:match[3])
+            let l:item.col = str2nr(l:match[3])
+        endif
+
+        call add(l:output, l:item)
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('cuda', {
+\   'name': 'nvcc',
+\   'output_stream': 'stderr',
+\   'executable_callback': 'ale_linters#cuda#nvcc#GetExecutable',
+\   'command_callback': 'ale_linters#cuda#nvcc#GetCommand',
+\   'callback': 'ale_linters#cuda#nvcc#HandleNVCCFormat',
+\   'lint_file': 1,
+\})

ale_linters/elm/make.vim

@@ -1,6 +1,15 @@
-" Author: buffalocoder - https://github.com/buffalocoder
+" Author: buffalocoder - https://github.com/buffalocoder, soywod - https://github.com/soywod
 " Description: Elm linting in Ale. Closely follows the Syntastic checker in https://github.com/ElmCast/elm-vim.
 
+call ale#Set('elm_make_executable', 'elm-make')
+call ale#Set('elm_make_use_global', 0)
+
+function! ale_linters#elm#make#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'elm_make', [
+    \   'node_modules/.bin/elm-make',
+    \])
+endfunction
+
 function! ale_linters#elm#make#Handle(buffer, lines) abort
     let l:output = []
     let l:is_windows = has('win32')
@@ -52,6 +61,7 @@ endfunction
 " If it doesn't, then this will fail when imports are needed.
 function! ale_linters#elm#make#GetCommand(buffer) abort
     let l:elm_package = ale#path#FindNearestFile(a:buffer, 'elm-package.json')
+    let l:elm_exe = ale_linters#elm#make#GetExecutable(a:buffer)
     if empty(l:elm_package)
         let l:dir_set_cmd = ''
     else
@@ -61,16 +71,18 @@ function! ale_linters#elm#make#GetCommand(buffer) abort
 
     " The elm-make 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.
+    " which is why this is hard coded here. It does not use NUL on Windows.
     " Source: https://github.com/elm-lang/elm-make/blob/master/src/Flags.hs
-    let l:elm_cmd = 'elm-make --report=json --output='.ale#Escape('/dev/null')
+    let l:elm_cmd = ale#Escape(l:elm_exe)
+    \   . ' --report=json'
+    \   . ' --output=/dev/null'
 
     return l:dir_set_cmd . ' ' . l:elm_cmd . ' %t'
 endfunction
 
 call ale#linter#Define('elm', {
 \    'name': 'make',
-\    'executable': 'elm-make',
+\    'executable_callback': 'ale_linters#elm#make#GetExecutable',
 \    'output_stream': 'both',
 \    'command_callback': 'ale_linters#elm#make#GetCommand',
 \    'callback': 'ale_linters#elm#make#Handle'

ale_linters/erlang/erlc.vim

@@ -17,7 +17,7 @@ function! ale_linters#erlang#erlc#Handle(buffer, lines) abort
     " error.erl:4: variable 'B' is unbound
     " error.erl:3: Warning: function main/0 is unused
     " error.erl:4: Warning: variable 'A' is unused
-    let l:pattern = '\v^([^:]+):(\d+): (Warning: )?(.+)$'
+    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+): (Warning: )?(.+)$'
 
     " parse_transforms are a special case. The error message does not indicate a location:
     " error.erl: undefined parse transform 'some_parse_transform'

ale_linters/glsl/glslang.vim

@@ -0,0 +1,46 @@
+" Author: Sven-Hendrik Haase <svenstaro@gmail.com>
+" Description: glslang-based linter for glsl files
+"
+" TODO: Once https://github.com/KhronosGroup/glslang/pull/1047 is accepted,
+" we can use stdin.
+
+let g:ale_glsl_glslang_executable =
+\ get(g:, 'ale_glsl_glslang_executable', 'glslangValidator')
+
+let g:ale_glsl_glslang_options = get(g:, 'ale_glsl_glslang_options', '')
+
+function! ale_linters#glsl#glslang#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'glsl_glslang_executable')
+endfunction
+
+function! ale_linters#glsl#glslang#GetCommand(buffer) abort
+    return ale_linters#glsl#glslang#GetExecutable(a:buffer)
+    \   . ' ' . ale#Var(a:buffer, 'glsl_glslang_options')
+    \   . ' ' . '-C %t'
+endfunction
+
+function! ale_linters#glsl#glslang#Handle(buffer, lines) abort
+    " Matches patterns like the following:
+    "
+    " ERROR: 0:5: 'foo' : undeclared identifier
+    let l:pattern = '^\(.\+\): \(\d\+\):\(\d\+\): \(.\+\)'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': str2nr(l:match[3]),
+        \   'col': str2nr(l:match[2]),
+        \   'text': l:match[4],
+        \   'type': l:match[1] is# 'ERROR' ? 'E' : 'W',
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('glsl', {
+\   'name': 'glslang',
+\   'executable_callback': 'ale_linters#glsl#glslang#GetExecutable',
+\   'command_callback': 'ale_linters#glsl#glslang#GetCommand',
+\   'callback': 'ale_linters#glsl#glslang#Handle',
+\})

ale_linters/go/gosimple.vim

@@ -4,6 +4,8 @@
 call ale#linter#Define('go', {
 \   'name': 'gosimple',
 \   'executable': 'gosimple',
-\   'command': 'gosimple %t',
+\   'command': 'gosimple %s',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
+\   'output_stream': 'both',
+\   'lint_file': 1,
 \})

ale_linters/go/staticcheck.vim

@@ -4,6 +4,8 @@
 call ale#linter#Define('go', {
 \   'name': 'staticcheck',
 \   'executable': 'staticcheck',
-\   'command': 'staticcheck %t',
+\   'command': 'staticcheck %s',
 \   'callback': 'ale#handlers#unix#HandleAsWarning',
+\   'output_stream': 'both',
+\   'lint_file': 1,
 \})

ale_linters/haskell/stack_build.vim

@@ -6,7 +6,7 @@
 
 call ale#Set('haskell_stack_build_options', '--fast')
 
-function ale_linters#haskell#stack_build#GetCommand(buffer) abort
+function! ale_linters#haskell#stack_build#GetCommand(buffer) abort
     let l:flags = ale#Var(a:buffer, 'haskell_stack_build_options')
 
     return 'stack build ' . l:flags

ale_linters/java/javac.vim

@@ -14,6 +14,11 @@ function! ale_linters#java#javac#GetImportPaths(buffer) abort
         \ . 'mvn dependency:build-classpath'
     endif
 
+    let l:classpath_command = ale#gradle#BuildClasspathCommand(a:buffer)
+    if !empty(l:classpath_command)
+        return l:classpath_command
+    endif
+
     return ''
 endfunction
 
@@ -44,7 +49,10 @@ function! ale_linters#java#javac#GetCommand(buffer, import_paths) abort
     " Create .class files in a temporary directory, which we will delete later.
     let l:class_file_directory = ale#engine#CreateDirectory(a:buffer)
 
-    return 'javac -Xlint'
+    " Always run javac from the directory the file is in, so we can resolve
+    " relative paths correctly.
+    return ale#path#BufferCdString(a:buffer)
+    \ . 'javac -Xlint'
     \ . ' ' . l:cp_option
     \ . ' ' . l:sp_option
     \ . ' -d ' . ale#Escape(l:class_file_directory)
@@ -58,14 +66,15 @@ function! ale_linters#java#javac#Handle(buffer, lines) abort
     " Main.java:13: warning: [deprecation] donaught() in Testclass has been deprecated
     " Main.java:16: error: ';' expected
 
-    let l:pattern = '\v^.*:(\d+): (.+):(.+)$'
+    let l:directory = expand('#' . a:buffer . ':p:h')
+    let l:pattern = '\v^(.*):(\d+): (.+):(.+)$'
     let l:col_pattern = '\v^(\s*\^)$'
     let l:symbol_pattern = '\v^ +symbol: *(class|method) +([^ ]+)'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, [l:pattern, l:col_pattern, l:symbol_pattern])
         if empty(l:match[2]) && empty(l:match[3])
-                let l:output[-1].col = len(l:match[1])
+            let l:output[-1].col = len(l:match[1])
         elseif empty(l:match[3])
             " Add symbols to 'cannot find symbol' errors.
             if l:output[-1].text is# 'error: cannot find symbol'
@@ -73,9 +82,10 @@ function! ale_linters#java#javac#Handle(buffer, lines) abort
             endif
         else
             call add(l:output, {
-            \   'lnum': l:match[1] + 0,
-            \   'text': l:match[2] . ':' . l:match[3],
-            \   'type': l:match[2] is# 'error' ? 'E' : 'W',
+            \   'filename': ale#path#GetAbsPath(l:directory, l:match[1]),
+            \   'lnum': l:match[2] + 0,
+            \   'text': l:match[3] . ':' . l:match[4],
+            \   'type': l:match[3] is# 'error' ? 'E' : 'W',
             \})
         endif
     endfor

ale_linters/javascript/standard.vim

@@ -14,17 +14,9 @@ endfunction
 
 function! ale_linters#javascript#standard#GetCommand(buffer) abort
     let l:executable = ale_linters#javascript#standard#GetExecutable(a:buffer)
-
-    if ale#Has('win32') && l:executable =~? '\.js$'
-        " .js files have to be executed with Node on Windows.
-        let l:head = 'node ' . ale#Escape(l:executable)
-    else
-        let l:head = ale#Escape(l:executable)
-    endif
-
     let l:options = ale#Var(a:buffer, 'javascript_standard_options')
 
-    return l:head
+    return ale#node#Executable(a:buffer, l:executable)
     \   . (!empty(l:options) ? ' ' . l:options : '')
     \   . ' --stdin %s'
 endfunction

ale_linters/llvm/llc.vim

@@ -0,0 +1,35 @@
+" Author: rhysd <https://rhysd.github.io>
+" Description: Support for checking LLVM IR with llc
+
+call ale#Set('llvm_llc_executable', 'llc')
+
+function! ale_linters#llvm#llc#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'llvm_llc_executable')
+endfunction
+
+function! ale_linters#llvm#llc#GetCommand(buffer) abort
+    return ale#Escape(ale_linters#llvm#llc#GetExecutable(a:buffer))
+    \   . ' -filetype=null -o='
+    \   . ale#Escape(g:ale#util#nul_file)
+endfunction
+
+function! ale_linters#llvm#llc#HandleErrors(buffer, lines) abort
+    " Handle '{path}: {file}:{line}:{col}: error: {message}' format
+    let l:pattern = '\v^[a-zA-Z]?:?[^:]+: [^:]+:(\d+):(\d+): (.+)$'
+    let l:matches = ale#util#GetMatches(a:lines, l:pattern)
+
+    return map(l:matches, "{
+    \   'lnum': str2nr(v:val[1]),
+    \   'col': str2nr(v:val[2]),
+    \   'text': v:val[3],
+    \   'type': 'E',
+    \}")
+endfunction
+
+call ale#linter#Define('llvm', {
+\   'name': 'llc',
+\   'executable_callback': 'ale_linters#llvm#llc#GetExecutable',
+\   'output_stream': 'stderr',
+\   'command_callback': 'ale_linters#llvm#llc#GetCommand',
+\   'callback': 'ale_linters#llvm#llc#HandleErrors',
+\})

ale_linters/lua/luacheck.vim

@@ -26,6 +26,12 @@ function! ale_linters#lua#luacheck#Handle(buffer, lines) abort
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        if !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
+        \   && l:match[3] is# 'W'
+        \   && index(range(611, 614), str2nr(l:match[4])) >= 0
+            continue
+        endif
+
         call add(l:output, {
         \   'lnum': l:match[1] + 0,
         \   'col': l:match[2] + 0,

ale_linters/markdown/remark_lint.vim

@@ -0,0 +1,28 @@
+" Author rhysd https://rhysd.github.io/
+" Description: remark-lint for Markdown files
+
+function! ale_linters#markdown#remark_lint#Handle(buffer, lines) abort
+    " matches: '  1:4  warning  Incorrect list-item indent: add 1 space  list-item-indent  remark-lint'
+    let l:pattern = '^ \+\(\d\+\):\(\d\+\)  \(warning\|error\)  \(.\+\)$'
+    let l:output = []
+
+    for l:match in ale#util#GetMatches(a:lines, l:pattern)
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:match[2] + 0,
+        \   'type': l:match[3] is# 'error' ? 'E' : 'W',
+        \   'text': l:match[4],
+        \})
+    endfor
+
+    return l:output
+endfunction
+
+call ale#linter#Define('markdown', {
+\   'name': 'remark-lint',
+\   'executable': 'remark',
+\   'command': 'remark --no-stdout --no-color %s',
+\   'callback': 'ale_linters#markdown#remark_lint#Handle',
+\   'lint_file': 1,
+\   'output_stream': 'stderr',
+\})

ale_linters/php/php.vim

@@ -30,6 +30,6 @@ call ale#linter#Define('php', {
 \   'name': 'php',
 \   'executable': 'php',
 \   'output_stream': 'stdout',
-\   'command': 'php -l -d error_reporting=E_ALL -d display_errors=1 --',
+\   'command': 'php -l -d error_reporting=E_ALL -d display_errors=1 -d log_errors=0 --',
 \   'callback': 'ale_linters#php#php#Handle',
 \})

ale_linters/php/phpmd.vim

@@ -14,7 +14,7 @@ function! ale_linters#php#phpmd#Handle(buffer, lines) abort
     " Matches against lines like the following:
     "
     " /path/to/some-filename.php:18 message
-    let l:pattern = '^.*:\(\d\+\)\t\(.\+\)$'
+    let l:pattern = '^.*:\(\d\+\)\s\+\(.\+\)$'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)

ale_linters/php/phpstan.vim

@@ -4,6 +4,7 @@
 " Set to change the ruleset
 let g:ale_php_phpstan_executable = get(g:, 'ale_php_phpstan_executable', 'phpstan')
 let g:ale_php_phpstan_level = get(g:, 'ale_php_phpstan_level', '4')
+let g:ale_php_phpstan_configuration = get(g:, 'ale_php_phpstan_configuration', '')
 
 function! ale_linters#php#phpstan#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'php_phpstan_executable')
@@ -12,10 +13,16 @@ endfunction
 function! ale_linters#php#phpstan#GetCommand(buffer) abort
     let l:executable = ale_linters#php#phpstan#GetExecutable(a:buffer)
 
+    let l:configuration = ale#Var(a:buffer, 'php_phpstan_configuration')
+    let l:configuration_option = !empty(l:configuration)
+    \   ? ' -c ' . l:configuration
+    \   : ''
+
     return ale#Escape(l:executable)
     \   . ' analyze -l'
     \   . ale#Var(a:buffer, 'php_phpstan_level')
     \   . ' --errorFormat raw'
+    \   . l:configuration_option
     \   . ' %s'
 endfunction
 

ale_linters/r/lintr.vim

@@ -1,9 +1,14 @@
 " Author: Michel Lang <michellang@gmail.com>, w0rp <devw0rp@gmail.com>
 " Description: This file adds support for checking R code with lintr.
 
+let g:ale_r_lintr_options =
+\   get(g:, 'ale_r_lintr_options', 'lintr::with_defaults()')
+" A reasonable alternative default:
+" \   get(g:, 'ale_r_lintr_options', 'lintr::with_defaults(object_usage_linter = NULL)')
+
 function! ale_linters#r#lintr#GetCommand(buffer) abort
     return ale#path#BufferCdString(a:buffer)
-    \   . 'Rscript -e ' . ale#Escape('lintr::lint(commandArgs(TRUE))') . ' %t'
+    \   . 'Rscript -e ' . ale#Escape('lintr::lint(commandArgs(TRUE)[1], eval(parse(text = commandArgs(TRUE)[2])))') . ' %t' . ' ' . ale#Escape(ale#Var(a:buffer, 'r_lintr_options'))
 endfunction
 
 call ale#linter#Define('r', {

ale_linters/ruby/brakeman.vim

@@ -7,23 +7,19 @@ let g:ale_ruby_brakeman_options =
 function! ale_linters#ruby#brakeman#Handle(buffer, lines) abort
     let l:output = []
     let l:json = ale#util#FuzzyJSONDecode(a:lines, {})
+    let l:sep = has('win32') ? '\' : '/'
+    " Brakeman always outputs paths relative to the Rails app root
+    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
 
     for l:warning in get(l:json, 'warnings', [])
-        " Brakeman always outputs paths relative to the Rails app root
-        let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
-        let l:warning_file = l:rails_root . '/' . l:warning.file
-
-        if !ale#path#IsBufferPath(a:buffer, l:warning_file)
-          continue
-        endif
-
         let l:text = l:warning.warning_type . ' ' . l:warning.message . ' (' . l:warning.confidence . ')'
         let l:line = l:warning.line != v:null ? l:warning.line : 1
 
         call add(l:output, {
-        \    'lnum': l:line,
-        \    'type': 'W',
-        \    'text': l:text,
+        \   'filename': l:rails_root . l:sep .  l:warning.file,
+        \   'lnum': l:line,
+        \   'type': 'W',
+        \   'text': l:text,
         \})
     endfor
 

ale_linters/rust/cargo.vim

@@ -26,6 +26,6 @@ call ale#linter#Define('rust', {
 \   'executable_callback': 'ale_linters#rust#cargo#GetCargoExecutable',
 \   'command_callback': 'ale_linters#rust#cargo#GetCommand',
 \   'callback': 'ale#handlers#rust#HandleRustErrors',
-\   'output_stream': 'stdout',
+\   'output_stream': 'both',
 \   'lint_file': 1,
 \})

ale_linters/scala/scalastyle.vim

@@ -8,10 +8,21 @@ let g:ale_scalastyle_config_loc =
 \   get(g:, 'ale_scalastyle_config_loc', '')
 
 function! ale_linters#scala#scalastyle#Handle(buffer, lines) abort
+    " Look for help output from scalastyle first, which indicates that no
+    " configuration file was found.
+    for l:line in a:lines[:10]
+        if l:line =~# '-c, --config'
+            return [{
+            \   'lnum': 1,
+            \   'text': '(See :help ale-scala-scalastyle)'
+            \       . ' No scalastyle configuration file was found.',
+            \}]
+        endif
+    endfor
+
     " Matches patterns like the following:
     "
     " warning file=/home/blurble/Doop.scala message=Missing or badly formed ScalaDoc: Extra @param foobles line=190
-
     let l:patterns = [
     \   '^\(.\+\) .\+ message=\(.\+\) line=\(\d\+\)$',
     \   '^\(.\+\) .\+ message=\(.\+\) line=\(\d\+\) column=\(\d\+\)$',

ale_linters/sh/shell.vim

@@ -17,18 +17,10 @@ if !exists('g:ale_sh_shell_default_shell')
 endif
 
 function! ale_linters#sh#shell#GetExecutable(buffer) abort
-    let l:banglines = getbufline(a:buffer, 1)
+    let l:shell_type = ale#handlers#sh#GetShellType(a:buffer)
 
-    " Take the shell executable from the hashbang, if we can.
-    if len(l:banglines) == 1 && l:banglines[0] =~# '^#!'
-        " Remove options like -e, etc.
-        let l:line = substitute(l:banglines[0], '--\?[a-zA-Z0-9]\+', '', 'g')
-
-        for l:possible_shell in ['bash', 'tcsh', 'csh', 'zsh', 'sh']
-            if l:line =~# l:possible_shell . '\s*$'
-                return l:possible_shell
-            endif
-        endfor
+    if !empty(l:shell_type)
+        return l:shell_type
     endif
 
     return ale#Var(a:buffer, 'sh_shell_default_shell')

ale_linters/sh/shellcheck.vim

@@ -2,7 +2,7 @@
 " Description: This file adds support for using the shellcheck linter with
 "   shell scripts.
 
-" This global variable can be set with a string of comma-seperated error
+" This global variable can be set with a string of comma-separated error
 " codes to exclude from shellcheck. For example:
 "
 " let g:ale_sh_shellcheck_exclusions = 'SC2002,SC2004'
@@ -19,25 +19,40 @@ function! ale_linters#sh#shellcheck#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'sh_shellcheck_executable')
 endfunction
 
-function! s:GetDialectArgument() abort
-    if exists('b:is_bash') && b:is_bash
-        return '-s bash'
-    elseif exists('b:is_sh') && b:is_sh
-        return '-s sh'
-    elseif exists('b:is_kornshell') && b:is_kornshell
-        return '-s ksh'
+function! ale_linters#sh#shellcheck#GetDialectArgument(buffer) abort
+    let l:shell_type = ale#handlers#sh#GetShellType(a:buffer)
+
+    if !empty(l:shell_type)
+        " Use the dash dialect for /bin/ash, etc.
+        if l:shell_type is# 'ash'
+            return 'dash'
+        endif
+
+        return l:shell_type
+    endif
+
+    " If there's no hashbang, try using Vim's buffer variables.
+    if getbufvar(a:buffer, 'is_bash', 0)
+        return 'bash'
+    elseif getbufvar(a:buffer, 'is_sh', 0)
+        return 'sh'
+    elseif getbufvar(a:buffer, 'is_kornshell', 0)
+        return 'ksh'
     endif
 
     return ''
 endfunction
 
 function! ale_linters#sh#shellcheck#GetCommand(buffer) abort
+    let l:options = ale#Var(a:buffer, 'sh_shellcheck_options')
     let l:exclude_option = ale#Var(a:buffer, 'sh_shellcheck_exclusions')
+    let l:dialect = ale_linters#sh#shellcheck#GetDialectArgument(a:buffer)
 
     return ale_linters#sh#shellcheck#GetExecutable(a:buffer)
-    \   . ' ' . ale#Var(a:buffer, 'sh_shellcheck_options')
-    \   . ' ' . (!empty(l:exclude_option) ? '-e ' . l:exclude_option : '')
-    \   . ' ' . s:GetDialectArgument() . ' -f gcc -'
+    \   . (!empty(l:dialect) ? ' -s ' . l:dialect : '')
+    \   . (!empty(l:options) ? ' ' . l:options : '')
+    \   . (!empty(l:exclude_option) ? ' -e ' . l:exclude_option : '')
+    \   . ' -f gcc -'
 endfunction
 
 call ale#linter#Define('sh', {

ale_linters/slim/slimlint.vim

@@ -1,5 +1,25 @@
 " Author: Markus Doits - https://github.com/doits
-" Description: slim-lint for Slim files, based on hamllint.vim
+" Description: slim-lint for Slim files
+
+function! ale_linters#slim#slimlint#GetCommand(buffer) abort
+    let l:command = 'slim-lint %t'
+
+    let l:rubocop_config = ale#path#FindNearestFile(a:buffer, '.rubocop.yml')
+
+    " Set SLIM_LINT_RUBOCOP_CONF variable as it is needed for slim-lint to
+    " pick up the rubocop config.
+    "
+    " See https://github.com/sds/slim-lint/blob/master/lib/slim_lint/linter/README.md#rubocop
+    if !empty(l:rubocop_config)
+      if ale#Has('win32')
+        let l:command = 'set SLIM_LINT_RUBOCOP_CONF=' . ale#Escape(l:rubocop_config) . ' && ' . l:command
+      else
+        let l:command = 'SLIM_LINT_RUBOCOP_CONF=' . ale#Escape(l:rubocop_config) . ' ' . l:command
+      endif
+    endif
+
+    return l:command
+endfunction
 
 function! ale_linters#slim#slimlint#Handle(buffer, lines) abort
     " Matches patterns like the following:
@@ -21,6 +41,6 @@ endfunction
 call ale#linter#Define('slim', {
 \   'name': 'slimlint',
 \   'executable': 'slim-lint',
-\   'command': 'slim-lint %t',
+\   'command_callback': 'ale_linters#slim#slimlint#GetCommand',
 \   'callback': 'ale_linters#slim#slimlint#Handle'
 \})

ale_linters/sml/smlnj.vim

@@ -1,47 +1,9 @@
-" Author: Paulo Alem    <paulo.alem@gmail.com>
-" Description: Rudimentary SML checking with smlnj compiler
-
-function! ale_linters#sml#smlnj#Handle(buffer, lines) abort
-    " Try to match basic sml errors
-
-    let l:out = []
-    let l:pattern = '^.*\:\([0-9\.]\+\)\ \(\w\+\)\:\ \(.*\)'
-    let l:pattern2 = '^.*\:\([0-9]\+\)\.\?\([0-9]\+\).* \(\(Warning\|Error\): .*\)'
-
-    for l:line in a:lines
-        let l:match2 = matchlist(l:line, l:pattern2)
-
-        if len(l:match2) != 0
-          call add(l:out, {
-          \   'bufnr': a:buffer,
-          \   'lnum': l:match2[1] + 0,
-          \   'col' : l:match2[2] - 1,
-          \   'text': l:match2[3],
-          \   'type': l:match2[3] =~# '^Warning' ? 'W' : 'E',
-          \})
-          continue
-        endif
-
-        let l:match = matchlist(l:line, l:pattern)
-
-        if len(l:match) != 0
-          call add(l:out, {
-          \   'bufnr': a:buffer,
-          \   'lnum': l:match[1] + 0,
-          \   'text': l:match[2] . ': ' . l:match[3],
-          \   'type': l:match[2] is# 'error' ? 'E' : 'W',
-          \})
-          continue
-        endif
-
-    endfor
-
-    return l:out
-endfunction
+" Author: Paulo Alem <paulo.alem@gmail.com>, Jake Zimmerman <jake@zimmerman.io>
+" Description: Single-file SML checking with SML/NJ compiler
 
 call ale#linter#Define('sml', {
 \   'name': 'smlnj',
-\   'executable': 'sml',
+\   'executable_callback': 'ale#handlers#sml#GetExecutableSmlnjFile',
 \   'command': 'sml',
-\   'callback': 'ale_linters#sml#smlnj#Handle',
+\   'callback': 'ale#handlers#sml#Handle',
 \})

ale_linters/sml/smlnj_cm.vim

@@ -0,0 +1,19 @@
+" Author: Jake Zimmerman <jake@zimmerman.io>
+" Description: SML checking with SML/NJ Compilation Manager
+
+function! ale_linters#sml#smlnj_cm#GetCommand(buffer) abort
+    let l:cmfile = ale#handlers#sml#GetCmFile(a:buffer)
+    return 'sml -m ' . l:cmfile . ' < /dev/null'
+endfunction
+
+" Using CM requires that we set "lint_file: 1", since it reads the files
+" from the disk itself.
+call ale#linter#Define('sml', {
+\   'name': 'smlnj-cm',
+\   'executable_callback': 'ale#handlers#sml#GetExecutableSmlnjCm',
+\   'lint_file': 1,
+\   'command_callback': 'ale_linters#sml#smlnj_cm#GetCommand',
+\   'callback': 'ale#handlers#sml#Handle',
+\})
+
+" vim:ts=4:sts=4:sw=4

ale_linters/solidity/solium.vim

@@ -0,0 +1,9 @@
+" Author: Jeff Sutherland - https://github.com/jdsutherland
+" Description: Report errors in Solidity code with solium
+
+call ale#linter#Define('solidity', {
+\   'name': 'solium',
+\   'executable': 'solium',
+\   'command': 'solium --reporter gcc --file %t',
+\   'callback': 'ale#handlers#gcc#HandleGCCFormat',
+\})

ale_linters/thrift/thrift.vim

@@ -0,0 +1,91 @@
+" Author: Jon Parise <jon@indelible.org>
+
+call ale#Set('thrift_thrift_executable', 'thrift')
+call ale#Set('thrift_thrift_generators', ['cpp'])
+call ale#Set('thrift_thrift_includes', [])
+call ale#Set('thrift_thrift_options', '-strict')
+
+function! ale_linters#thrift#thrift#GetExecutable(buffer) abort
+    return ale#Var(a:buffer, 'thrift_thrift_executable')
+endfunction
+
+function! ale_linters#thrift#thrift#GetCommand(buffer) abort
+    let l:generators = ale#Var(a:buffer, 'thrift_thrift_generators')
+    let l:includes = ale#Var(a:buffer, 'thrift_thrift_includes')
+
+    " The thrift compiler requires at least one generator. If none are set,
+    " fall back to our default value to avoid silently failing. We could also
+    " `throw` here, but that seems even less helpful.
+    if empty(l:generators)
+        let l:generators = ['cpp']
+    endif
+
+    let l:output_dir = tempname()
+    call mkdir(l:output_dir)
+    call ale#engine#ManageDirectory(a:buffer, l:output_dir)
+
+    return ale#Escape(ale_linters#thrift#thrift#GetExecutable(a:buffer))
+    \   . ' ' . join(map(copy(l:generators), "'--gen ' . v:val"))
+    \   . ' ' . join(map(copy(l:includes), "'-I ' . v:val"))
+    \   . ' ' . ale#Var(a:buffer, 'thrift_thrift_options')
+    \   . ' -out ' . ale#Escape(l:output_dir)
+    \   . ' %t'
+endfunction
+
+function! ale_linters#thrift#thrift#Handle(buffer, lines) abort
+    " Matches lines like the following:
+    "
+    " [SEVERITY:/path/filename.thrift:31] Message text
+    " [ERROR:/path/filename.thrift:31] (last token was ';')
+    let l:pattern = '\v^\[(\u+):(.*):(\d+)\] (.*)$'
+
+    let l:index = 0
+    let l:output = []
+
+    " Roll our own output-matching loop instead of using ale#util#GetMatches
+    " because we need to support error messages that span multiple lines.
+    while l:index < len(a:lines)
+        let l:line = a:lines[l:index]
+
+        let l:match = matchlist(l:line, l:pattern)
+        if empty(l:match)
+            let l:index += 1
+            continue
+        endif
+
+        let l:severity = l:match[1]
+        if l:severity is# 'WARNING'
+            let l:type = 'W'
+        else
+            let l:type = 'E'
+        endif
+
+        " If our text looks like "(last token was ';')", the *next* line
+        " should contain a more descriptive error message.
+        let l:text = l:match[4]
+        if l:text =~# '\(last token was .*\)'
+            let l:index += 1
+            let l:text = get(a:lines, l:index, 'Unknown error ' . l:text)
+        endif
+
+        call add(l:output, {
+        \   'lnum': l:match[3] + 0,
+        \   'col': 0,
+        \   'type': l:type,
+        \   'text': l:text,
+        \})
+
+        let l:index += 1
+    endwhile
+
+    return l:output
+endfunction
+
+call ale#linter#Define('thrift', {
+\   'name': 'thrift',
+\   'executable': 'thrift',
+\   'output_stream': 'both',
+\   'executable_callback': 'ale_linters#thrift#thrift#GetExecutable',
+\   'command_callback': 'ale_linters#thrift#thrift#GetCommand',
+\   'callback': 'ale_linters#thrift#thrift#Handle',
+\})

ale_linters/typescript/tslint.vim

@@ -1,9 +1,11 @@
-" Author: Prashanth Chandra https://github.com/prashcr
+" Author: Prashanth Chandra <https://github.com/prashcr>, Jonathan Clem <https://jclem.net>
 " Description: tslint for TypeScript files
 
 call ale#Set('typescript_tslint_executable', 'tslint')
 call ale#Set('typescript_tslint_config_path', '')
+call ale#Set('typescript_tslint_rules_dir', '')
 call ale#Set('typescript_tslint_use_global', 0)
+call ale#Set('typescript_tslint_ignore_empty_files', 0)
 
 function! ale_linters#typescript#tslint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'typescript_tslint', [
@@ -12,10 +14,20 @@ function! ale_linters#typescript#tslint#GetExecutable(buffer) abort
 endfunction
 
 function! ale_linters#typescript#tslint#Handle(buffer, lines) abort
+    " Do not output any errors for empty files if the option is on.
+    if ale#Var(a:buffer, 'typescript_tslint_ignore_empty_files')
+    \&& getbufline(a:buffer, 1, '$') == ['']
+        return []
+    endif
+
     let l:dir = expand('#' . a:buffer . ':p:h')
     let l:output = []
 
     for l:error in ale#util#FuzzyJSONDecode(a:lines, [])
+        if get(l:error, 'ruleName', '') is# 'no-implicit-dependencies'
+            continue
+        endif
+
         call add(l:output, {
         \   'filename': ale#path#GetAbsPath(l:dir, l:error.name),
         \   'type': (get(l:error, 'ruleSeverity', '') is# 'WARNING' ? 'W' : 'E'),
@@ -38,15 +50,20 @@ function! ale_linters#typescript#tslint#GetCommand(buffer) abort
     \   'tslint.json',
     \   ale#Var(a:buffer, 'typescript_tslint_config_path')
     \)
-
     let l:tslint_config_option = !empty(l:tslint_config_path)
     \   ? ' -c ' . ale#Escape(l:tslint_config_path)
     \   : ''
 
+    let l:tslint_rules_dir = ale#Var(a:buffer, 'typescript_tslint_rules_dir')
+    let l:tslint_rules_option = !empty(l:tslint_rules_dir)
+    \  ? ' -r ' . ale#Escape(l:tslint_rules_dir)
+    \  : ''
+
     return ale#path#BufferCdString(a:buffer)
     \   . ale_linters#typescript#tslint#GetExecutable(a:buffer)
     \   . ' --format json'
     \   . l:tslint_config_option
+    \   . l:tslint_rules_option
     \   . ' %t'
 endfunction
 

autoload/ale.vim

@@ -38,16 +38,57 @@ function! ale#FileTooLarge() abort
     return l:max > 0 ? (line2byte(line('$') + 1) > l:max) : 0
 endfunction
 
+let s:getcmdwintype_exists = exists('*getcmdwintype')
+
 " A function for checking various conditions whereby ALE just shouldn't
 " attempt to do anything, say if particular buffer types are open in Vim.
 function! ale#ShouldDoNothing(buffer) abort
+    " The checks are split into separate if statements to make it possible to
+    " profile each check individually with Vim's profiling tools.
+
+    " Don't perform any checks when newer NeoVim versions are exiting.
+    if get(v:, 'exiting', v:null) isnot v:null
+        return 1
+    endif
+
     " Do nothing for blacklisted files
-    " OR if ALE is running in the sandbox
-    return index(g:ale_filetype_blacklist, &filetype) >= 0
-    \   || (exists('*getcmdwintype') && !empty(getcmdwintype()))
-    \   || ale#util#InSandbox()
-    \   || !ale#Var(a:buffer, 'enabled')
-    \   || ale#FileTooLarge()
+    if index(g:ale_filetype_blacklist, getbufvar(a:buffer, '&filetype')) >= 0
+        return 1
+    endif
+
+    " Do nothing if running from command mode
+    if s:getcmdwintype_exists && !empty(getcmdwintype())
+        return 1
+    endif
+
+    let l:filename = fnamemodify(bufname(a:buffer), ':t')
+
+    if l:filename is# '.'
+        return 1
+    endif
+
+    " Do nothing if running in the sandbox
+    if ale#util#InSandbox()
+        return 1
+    endif
+
+    " Do nothing if ALE is disabled.
+    if !ale#Var(a:buffer, 'enabled')
+        return 1
+    endif
+
+    " Do nothing if the file is too large.
+    if ale#FileTooLarge()
+        return 1
+    endif
+
+    " Do nothing from CtrlP buffers with CtrlP-funky.
+    if exists(':CtrlPFunky') is 2
+    \&& getbufvar(a:buffer, '&l:statusline') =~# 'CtrlPMode.*funky'
+        return 1
+    endif
+
+    return 0
 endfunction
 
 " (delay, [linting_flag, buffer_number])
@@ -83,7 +124,7 @@ function! s:ALEQueueImpl(delay, linting_flag, buffer) abort
     " Remember that we want to check files for this buffer.
     " We will remember this until we finally run the linters, via any event.
     if a:linting_flag is# 'lint_file'
-        let s:should_lint_file_for_buffer[bufnr('%')] = 1
+        let s:should_lint_file_for_buffer[a:buffer] = 1
     endif
 
     if s:lint_timer != -1

autoload/ale/command.vim

@@ -28,7 +28,7 @@ function! ale#command#FormatCommand(buffer, command, pipe_file_if_needed) abort
     " with an ugly string.
     let l:command = substitute(l:command, '%%', '<<PERCENTS>>', 'g')
 
-    " Replace all %s occurences in the string with the name of the current
+    " Replace all %s occurrences in the string with the name of the current
     " file.
     if l:command =~# '%s'
         let l:filename = fnamemodify(bufname(a:buffer), ':p')

autoload/ale/completion.vim

@@ -282,7 +282,23 @@ function! s:TimerHandler(...) abort
     endif
 endfunction
 
+" Stop any completion timer that is queued. This is useful for tests.
+function! ale#completion#StopTimer() abort
+    if s:timer_id != -1
+        call timer_stop(s:timer_id)
+    endif
+
+    let s:timer_id = -1
+endfunction
+
 function! ale#completion#Queue() abort
+    let l:time = get(b:, 'ale_complete_done_time', 0)
+
+    if l:time && ale#util#ClockMilliseconds() - l:time < 100
+        " Do not ask for completions shortly after we just closed the menu.
+        return
+    endif
+
     let s:timer_pos = getcurpos()[1:2]
 
     " If we changed the text again while we're still waiting for a response,
@@ -291,9 +307,7 @@ function! ale#completion#Queue() abort
         let b:ale_completion_info.request_id = 0
     endif
 
-    if s:timer_id != -1
-        call timer_stop(s:timer_id)
-    endif
+    call ale#completion#StopTimer()
 
     let s:timer_id = timer_start(g:ale_completion_delay, function('s:TimerHandler'))
 endfunction
@@ -311,6 +325,9 @@ function! ale#completion#Done() abort
         let &l:completeopt = b:ale_old_completopt
         unlet b:ale_old_completopt
     endif
+
+    " Set a timestamp, so we can avoid requesting completions again.
+    let b:ale_complete_done_time = ale#util#ClockMilliseconds()
 endfunction
 
 function! s:Setup(enabled) abort

autoload/ale/cursor.vim

@@ -3,15 +3,6 @@
 
 let s:cursor_timer = -1
 let s:last_pos = [0, 0, 0]
-let s:error_delay_ms = 1000 * 60 * 2
-
-if !exists('s:dont_queue_until')
-    let s:dont_queue_until = -1
-endif
-
-if !exists('s:dont_echo_until')
-    let s:dont_echo_until = -1
-endif
 
 " Return a formatted message according to g:ale_echo_msg_format variable
 function! s:GetMessage(linter, type, text) abort
@@ -84,12 +75,12 @@ function! ale#cursor#EchoCursorWarning(...) abort
 endfunction
 
 function! s:EchoImpl() abort
-    if ale#ShouldDoNothing(bufnr(''))
+    " Only echo the warnings in normal mode, otherwise we will get problems.
+    if mode() isnot# 'n'
         return
     endif
 
-    " Only echo the warnings in normal mode, otherwise we will get problems.
-    if mode() isnot# 'n'
+    if ale#ShouldDoNothing(bufnr(''))
         return
     endif
 
@@ -108,15 +99,8 @@ function! s:EchoImpl() abort
 endfunction
 
 function! ale#cursor#EchoCursorWarningWithDelay() abort
-    return ale#CallWithCooldown(
-    \   'dont_echo_with_delay_until',
-    \   function('s:EchoWithDelayImpl'),
-    \   [],
-    \)
-endfunction
-
-function! s:EchoWithDelayImpl() abort
-    if ale#ShouldDoNothing(bufnr(''))
+    " Only echo the warnings in normal mode, otherwise we will get problems.
+    if mode() isnot# 'n'
         return
     endif
 
@@ -129,18 +113,23 @@ function! s:EchoWithDelayImpl() abort
     " we should echo something. Otherwise we can end up doing processing
     " the echo message far too frequently.
     if l:pos != s:last_pos
+        let l:delay = ale#Var(bufnr(''), 'echo_delay')
+
         let s:last_pos = l:pos
-        let s:cursor_timer = timer_start(10, function('ale#cursor#EchoCursorWarning'))
+        let s:cursor_timer = timer_start(
+        \   l:delay,
+        \   function('ale#cursor#EchoCursorWarning')
+        \)
     endif
 endfunction
 
 function! ale#cursor#ShowCursorDetail() abort
-    if ale#ShouldDoNothing(bufnr(''))
+    " Only echo the warnings in normal mode, otherwise we will get problems.
+    if mode() isnot# 'n'
         return
     endif
 
-    " Only echo the warnings in normal mode, otherwise we will get problems.
-    if mode() isnot# 'n'
+    if ale#ShouldDoNothing(bufnr(''))
         return
     endif
 

autoload/ale/engine.vim

@@ -286,10 +286,6 @@ function! ale#engine#SetResults(buffer, loclist) abort
 
     if g:ale_set_quickfix || g:ale_set_loclist
         call ale#list#SetLists(a:buffer, a:loclist)
-
-        if l:linting_is_done
-            call ale#list#CloseWindowIfNeeded(a:buffer)
-        endif
     endif
 
     if exists('*ale#statusline#Update')
@@ -379,7 +375,7 @@ function! ale#engine#FixLocList(buffer, linter_name, loclist) abort
         \}
 
         if has_key(l:old_item, 'filename')
-        \&& l:old_item.filename[:len(s:temp_dir) - 1] isnot# s:temp_dir
+        \&& !ale#path#IsTempName(l:old_item.filename)
             " Use the filename given.
             " Temporary files are assumed to be for this buffer,
             " and the filename is not included then, because it looks bad
@@ -577,7 +573,7 @@ function! ale#engine#ProcessChain(buffer, linter, chain_index, input) abort
 
     if has_key(a:linter, 'command_chain')
         while l:chain_index < len(a:linter.command_chain)
-            " Run a chain of commands, one asychronous command after the other,
+            " Run a chain of commands, one asynchronous command after the other,
             " so that many programs can be run in a sequence.
             let l:chain_item = a:linter.command_chain[l:chain_index]
 
@@ -805,6 +801,11 @@ endfunction
 " clear the state of everything, and remove the Dictionary for managing
 " the buffer.
 function! ale#engine#Cleanup(buffer) abort
+    " Don't bother with cleanup code when newer NeoVim versions are exiting.
+    if get(v:, 'exiting', v:null) isnot v:null
+        return
+    endif
+
     if !has_key(g:ale_buffer_info, a:buffer)
         return
     endif
@@ -840,7 +841,7 @@ function! ale#engine#WaitForJobs(deadline) abort
 
     " Gather all of the jobs from every buffer.
     for l:info in values(g:ale_buffer_info)
-        call extend(l:job_list, l:info.job_list)
+        call extend(l:job_list, get(l:info, 'job_list', []))
     endfor
 
     " NeoVim has a built-in API for this, so use that.
@@ -888,7 +889,7 @@ function! ale#engine#WaitForJobs(deadline) abort
 
     " Check again to see if any jobs are running.
     for l:info in values(g:ale_buffer_info)
-        for l:job_id in l:info.job_list
+        for l:job_id in get(l:info, 'job_list', [])
             if ale#job#IsRunning(l:job_id)
                 let l:has_new_jobs = 1
                 break

autoload/ale/events.vim

@@ -1,15 +1,27 @@
 " Author: w0rp <devw0rp@gmail.com>
 
+function! ale#events#QuitEvent(buffer) abort
+    " Remember when ALE is quitting for BufWrite, etc.
+    call setbufvar(a:buffer, 'ale_quitting', ale#util#ClockMilliseconds())
+endfunction
+
+function! ale#events#QuitRecently(buffer) abort
+    let l:time = getbufvar(a:buffer, 'ale_quitting', 0)
+
+    return l:time && ale#util#ClockMilliseconds() - l:time < 1000
+endfunction
+
 function! ale#events#SaveEvent(buffer) abort
     call setbufvar(a:buffer, 'ale_save_event_fired', 1)
-    let l:should_lint = ale#Var(a:buffer, 'enabled') && g:ale_lint_on_save
+    let l:should_lint = ale#Var(a:buffer, 'enabled')
+    \   && g:ale_lint_on_save
 
     if g:ale_fix_on_save
         let l:will_fix = ale#fix#Fix('save_file')
         let l:should_lint = l:should_lint && !l:will_fix
     endif
 
-    if l:should_lint
+    if l:should_lint && !ale#events#QuitRecently(a:buffer)
         call ale#Queue(0, 'lint_file', a:buffer)
     endif
 endfunction
@@ -24,6 +36,8 @@ function! s:LintOnEnter(buffer) abort
 endfunction
 
 function! ale#events#EnterEvent(buffer) abort
+    " When entering a buffer, we are no longer quitting it.
+    call setbufvar(a:buffer, 'ale_quitting', 0)
     let l:filetype = getbufvar(a:buffer, '&filetype')
     call setbufvar(a:buffer, 'ale_original_filetype', l:filetype)
 
@@ -33,7 +47,13 @@ endfunction
 function! ale#events#FileTypeEvent(buffer, new_filetype) abort
     let l:filetype = getbufvar(a:buffer, 'ale_original_filetype', '')
 
-    if a:new_filetype isnot# l:filetype
+    " If we're setting the filetype for the first time after it was blank,
+    " and the option for linting on enter is off, then we should set this
+    " filetype as the original filetype. Otherwise ALE will still appear to
+    " lint files because of the BufEnter event, etc.
+    if empty(l:filetype) && !ale#Var(a:buffer, 'lint_on_enter')
+        call setbufvar(a:buffer, 'ale_original_filetype', a:new_filetype)
+    elseif a:new_filetype isnot# l:filetype
         call ale#Queue(300, 'lint_file', a:buffer)
     endif
 endfunction

autoload/ale/fix.vim

@@ -56,7 +56,9 @@ function! ale#fix#ApplyQueuedFixes() abort
 
     " If ALE linting is enabled, check for problems with the file again after
     " fixing problems.
-    if g:ale_enabled && l:should_lint
+    if g:ale_enabled
+    \&& l:should_lint
+    \&& !ale#events#QuitRecently(l:buffer)
         call ale#Queue(0, l:data.should_save ? 'lint_file' : '')
     endif
 endfunction
@@ -96,6 +98,11 @@ function! s:HandleExit(job_id, exit_code) abort
     endif
 
     let l:job_info = remove(s:job_info_map, a:job_id)
+    let l:buffer = l:job_info.buffer
+
+    if g:ale_history_enabled
+        call ale#history#SetExitCode(l:buffer, a:job_id, a:exit_code)
+    endif
 
     if has_key(l:job_info, 'file_to_read')
         let l:job_info.output = readfile(l:job_info.file_to_read)
@@ -108,7 +115,7 @@ function! s:HandleExit(job_id, exit_code) abort
     \   : l:job_info.input
 
     call s:RunFixer({
-    \   'buffer': l:job_info.buffer,
+    \   'buffer': l:buffer,
     \   'input': l:input,
     \   'callback_list': l:job_info.callback_list,
     \   'callback_index': l:job_info.callback_index + 1,
@@ -209,6 +216,12 @@ function! s:RunJob(options) abort
         let l:job_id = ale#job#Start(l:command, l:job_options)
     endif
 
+    let l:status = l:job_id ? 'started' : 'failed'
+
+    if g:ale_history_enabled
+        call ale#history#Add(l:buffer, l:status, l:job_id, l:command)
+    endif
+
     if l:job_id == 0
         return 0
     endif

autoload/ale/fix/registry.vim

@@ -27,6 +27,11 @@ let s:default_registry = {
 \       'suggested_filetypes': ['javascript', 'typescript'],
 \       'description': 'Apply eslint --fix to a file.',
 \   },
+\   'format': {
+\       'function': 'ale#fixers#format#Fix',
+\       'suggested_filetypes': ['elm'],
+\       'description': 'Apply elm-format to a file.',
+\   },
 \   'isort': {
 \       'function': 'ale#fixers#isort#Fix',
 \       'suggested_filetypes': ['python'],
@@ -34,7 +39,7 @@ let s:default_registry = {
 \   },
 \   'prettier': {
 \       'function': 'ale#fixers#prettier#Fix',
-\       'suggested_filetypes': ['javascript'],
+\       'suggested_filetypes': ['javascript', 'typescript', 'json', 'css', 'scss', 'less'],
 \       'description': 'Apply prettier to a file.',
 \   },
 \   'prettier_eslint': {
@@ -52,6 +57,11 @@ let s:default_registry = {
 \       'suggested_filetypes': [],
 \       'description': 'Remove all blank lines at the end of a file.',
 \   },
+\   'trim_whitespace': {
+\       'function': 'ale#fixers#generic#TrimWhitespace',
+\       'suggested_filetypes': [],
+\       'description': 'Remove all trailing whitespace characters at the end of every line.',
+\   },
 \   'yapf': {
 \       'function': 'ale#fixers#yapf#Fix',
 \       'suggested_filetypes': ['python'],
@@ -87,6 +97,16 @@ let s:default_registry = {
 \       'suggested_filetypes': ['c', 'cpp'],
 \       'description': 'Fix C/C++ files with clang-format.',
 \   },
+\   'gofmt': {
+\       'function': 'ale#fixers#gofmt#Fix',
+\       'suggested_filetypes': ['go'],
+\       'description': 'Fix Go files with go fmt.',
+\   },
+\   'tslint': {
+\       'function': 'ale#fixers#tslint#Fix',
+\       'suggested_filetypes': ['typescript'],
+\       'description': 'Fix typescript files with tslint --fix.',
+\   },
 \}
 
 " Reset the function registry to the default entries.

autoload/ale/fixers/clangformat.vim

@@ -1,3 +1,4 @@
+scriptencoding utf-8
 " Author: Peter Renström <renstrom.peter@gmail.com>
 " Description: Fixing C/C++ files with clang-format.
 

autoload/ale/fixers/eslint.vim

@@ -1,44 +1,17 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Fixing files with eslint.
 
-function! s:FindConfig(buffer) abort
-    for l:filename in [
-    \   '.eslintrc.js',
-    \   '.eslintrc.yaml',
-    \   '.eslintrc.yml',
-    \   '.eslintrc.json',
-    \   '.eslintrc',
-    \   'package.json',
-    \]
-        let l:config = ale#path#FindNearestFile(a:buffer, l:filename)
-
-        if !empty(l:config)
-            return l:config
-        endif
-    endfor
-
-    return ''
-endfunction
-
 function! ale#fixers#eslint#Fix(buffer) abort
     let l:executable = ale#handlers#eslint#GetExecutable(a:buffer)
-    let l:config = s:FindConfig(a:buffer)
+    let l:config = ale#handlers#eslint#FindConfig(a:buffer)
 
     if empty(l:config)
         return 0
     endif
 
-    if ale#Has('win32') && l:executable =~? 'eslint\.js$'
-        " For Windows, if we detect an eslint.js script, we need to execute
-        " it with node, or the file can be opened with a text editor.
-        let l:head = 'node ' . ale#Escape(l:executable)
-    else
-        let l:head = ale#Escape(l:executable)
-    endif
-
     return {
-    \   'command': l:head
-    \       . ' --config ' . ale#Escape(l:config)
+    \   'command': ale#node#Executable(a:buffer, l:executable)
+    \       . ' -c ' . ale#Escape(l:config)
     \       . ' --fix %t',
     \   'read_temporary_file': 1,
     \}

autoload/ale/fixers/format.vim

@@ -0,0 +1,23 @@
+" Author: soywod <clement.douin@gmail.com>
+" Description: Integration of elm-format with ALE.
+
+call ale#Set('elm_format_executable', 'elm-format')
+call ale#Set('elm_format_use_global', 0)
+call ale#Set('elm_format_options', '--yes')
+
+function! ale#fixers#format#GetExecutable(buffer) abort
+    return ale#node#FindExecutable(a:buffer, 'elm_format', [
+    \   'node_modules/.bin/elm-format',
+    \])
+endfunction
+
+function! ale#fixers#format#Fix(buffer) abort
+    let l:options = ale#Var(a:buffer, 'elm_format_options')
+
+    return {
+    \   'command': ale#Escape(ale#fixers#format#GetExecutable(a:buffer))
+    \       . ' %t'
+    \       . (empty(l:options) ? '' : ' ' . l:options),
+    \   'read_temporary_file': 1,
+    \}
+endfunction

autoload/ale/fixers/generic.vim

@@ -10,3 +10,16 @@ function! ale#fixers#generic#RemoveTrailingBlankLines(buffer, lines) abort
 
     return a:lines[:l:end_index]
 endfunction
+
+" Remove all whitespaces at the end of lines
+function! ale#fixers#generic#TrimWhitespace(buffer, lines) abort
+    let l:index = 0
+    let l:lines_new = range(len(a:lines))
+
+    for l:line in a:lines
+        let l:lines_new[l:index] = substitute(l:line, '\s\+$', '', 'g')
+        let l:index = l:index + 1
+    endfor
+
+    return l:lines_new
+endfunction

autoload/ale/fixers/gofmt.vim

@@ -0,0 +1,18 @@
+" Author: aliou <code@aliou.me>
+" Description: Integration of gofmt with ALE.
+
+call ale#Set('go_gofmt_executable', 'gofmt')
+call ale#Set('go_gofmt_options', '')
+
+function! ale#fixers#gofmt#Fix(buffer) abort
+    let l:executable = ale#Var(a:buffer, 'go_gofmt_executable')
+    let l:options = ale#Var(a:buffer, 'go_gofmt_options')
+
+    return {
+    \   'command': ale#Escape(l:executable)
+    \       . ' -l -w'
+    \       . (empty(l:options) ? '' : ' ' . l:options)
+    \       . ' %t',
+    \   'read_temporary_file': 1,
+    \}
+endfunction

autoload/ale/fixers/prettier.vim

@@ -1,13 +1,37 @@
 " Author: tunnckoCore (Charlike Mike Reagent) <mameto2011@gmail.com>,
-"         w0rp <devw0rp@gmail.com>
+"         w0rp <devw0rp@gmail.com>, morhetz (Pavel Pertsev) <morhetz@gmail.com>
 " Description: Integration of Prettier with ALE.
 
 call ale#Set('javascript_prettier_executable', 'prettier')
 call ale#Set('javascript_prettier_use_global', 0)
+call ale#Set('javascript_prettier_use_local_config', 0)
 call ale#Set('javascript_prettier_options', '')
 
+function! s:FindConfig(buffer) abort
+    for l:filename in [
+    \   '.prettierrc',
+    \   '.prettierrc.json',
+    \   '.prettierrc.yaml',
+    \   '.prettierrc.yml',
+    \   '.prettierrc.js',
+    \   'prettier.config.js',
+    \   'package.json',
+    \ ]
+
+        let l:config = ale#path#FindNearestFile(a:buffer, l:filename)
+
+        if !empty(l:config)
+            return l:config
+        endif
+    endfor
+
+    return ''
+endfunction
+
+
 function! ale#fixers#prettier#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_prettier', [
+    \   'node_modules/.bin/prettier_d',
     \   'node_modules/prettier-cli/index.js',
     \   'node_modules/.bin/prettier',
     \])
@@ -15,11 +39,31 @@ endfunction
 
 function! ale#fixers#prettier#Fix(buffer) abort
     let l:options = ale#Var(a:buffer, 'javascript_prettier_options')
+    let l:config = s:FindConfig(a:buffer)
+    let l:use_config = ale#Var(a:buffer, 'javascript_prettier_use_local_config')
+                \ && !empty(l:config)
+    let l:filetype = getbufvar(a:buffer, '&filetype')
+
+    " Append the --parser flag depending on the current filetype (unless it's
+    " already set in g:javascript_prettier_options).
+    if match(l:options, '--parser') == -1
+        if l:filetype is# 'typescript'
+            let l:parser = 'typescript'
+        elseif l:filetype =~# 'css\|scss\|less'
+            let l:parser = 'postcss'
+        elseif l:filetype is# 'json'
+            let l:parser = 'json'
+        else
+            let l:parser = 'babylon'
+        endif
+        let l:options = (!empty(l:options) ? l:options . ' ' : '') . '--parser ' . l:parser
+    endif
 
     return {
     \   'command': ale#Escape(ale#fixers#prettier#GetExecutable(a:buffer))
     \       . ' %t'
-    \       . ' ' . l:options
+    \       . (!empty(l:options) ? ' ' . l:options : '')
+    \       . (l:use_config ? ' --config ' . ale#Escape(l:config) : '')
     \       . ' --write',
     \   'read_temporary_file': 1,
     \}

autoload/ale/fixers/prettier_eslint.vim

@@ -1,25 +1,39 @@
 " Author: tunnckoCore (Charlike Mike Reagent) <mameto2011@gmail.com>,
-"         w0rp <devw0rp@gmail.com>
+"         w0rp <devw0rp@gmail.com>, morhetz (Pavel Pertsev) <morhetz@gmail.com>
 " Description: Integration between Prettier and ESLint.
 
-call ale#Set('javascript_prettier_eslint_executable', 'prettier-eslint')
-call ale#Set('javascript_prettier_eslint_use_global', 0)
-call ale#Set('javascript_prettier_eslint_options', '')
+function! ale#fixers#prettier_eslint#SetOptionDefaults() abort
+    call ale#Set('javascript_prettier_eslint_executable', 'prettier-eslint')
+    call ale#Set('javascript_prettier_eslint_use_global', 0)
+    call ale#Set('javascript_prettier_eslint_options', '')
+    call ale#Set('javascript_prettier_eslint_legacy', 0)
+endfunction
+
+call ale#fixers#prettier_eslint#SetOptionDefaults()
 
 function! ale#fixers#prettier_eslint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_prettier_eslint', [
-    \   'node_modules/prettier-eslint-cli/index.js',
+    \   'node_modules/prettier-eslint-cli/dist/index.js',
     \   'node_modules/.bin/prettier-eslint',
     \])
 endfunction
 
-function! ale#fixers#prettier_eslint#Fix(buffer, lines) abort
+function! ale#fixers#prettier_eslint#Fix(buffer) abort
     let l:options = ale#Var(a:buffer, 'javascript_prettier_eslint_options')
+    let l:executable = ale#fixers#prettier_eslint#GetExecutable(a:buffer)
+
+    let l:config = !ale#Var(a:buffer, 'javascript_prettier_eslint_legacy')
+    \   ? ale#handlers#eslint#FindConfig(a:buffer)
+    \   : ''
+    let l:eslint_config_option = !empty(l:config)
+    \   ? ' --eslint-config-path ' . ale#Escape(l:config)
+    \   : ''
 
     return {
-    \   'command': ale#Escape(ale#fixers#prettier_eslint#GetExecutable(a:buffer))
+    \   'command': ale#Escape(l:executable)
     \       . ' %t'
-    \       . ' ' . l:options
+    \       . l:eslint_config_option
+    \       . (!empty(l:options) ? ' ' . l:options : '')
     \       . ' --write',
     \   'read_temporary_file': 1,
     \}

autoload/ale/fixers/standard.vim

@@ -1,6 +1,10 @@
 " Author: Sumner Evans <sumner.evans98@gmail.com>
 " Description: Fixing files with Standard.
 
+call ale#Set('javascript_standard_executable', 'standard')
+call ale#Set('javascript_standard_use_global', 0)
+call ale#Set('javascript_standard_options', '')
+
 function! ale#fixers#standard#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_standard', [
     \   'node_modules/standard/bin/cmd.js',
@@ -11,16 +15,8 @@ endfunction
 function! ale#fixers#standard#Fix(buffer) abort
     let l:executable = ale#fixers#standard#GetExecutable(a:buffer)
 
-    if ale#Has('win32') && l:executable =~? 'cmd\.js$'
-        " For Windows, if we detect an standard.js script, we need to execute
-        " it with node, or the file can be opened with a text editor.
-        let l:head = 'node ' . ale#Escape(l:executable)
-    else
-        let l:head = ale#Escape(l:executable)
-    endif
-
     return {
-    \   'command': l:head
+    \   'command': ale#node#Executable(a:buffer, l:executable)
     \       . ' --fix %t',
     \   'read_temporary_file': 1,
     \}

autoload/ale/fixers/stylelint.vim

@@ -15,16 +15,8 @@ endfunction
 function! ale#fixers#stylelint#Fix(buffer) abort
     let l:executable = ale#fixers#stylelint#GetExecutable(a:buffer)
 
-    if ale#Has('win32') && l:executable =~? 'stylelint\.js$'
-        " For Windows, if we detect an stylelint.js script, we need to execute
-        " it with node, or the file can be opened with a text editor.
-        let l:head = 'node ' . ale#Escape(l:executable)
-    else
-        let l:head = ale#Escape(l:executable)
-    endif
-
     return {
-    \   'command': l:head
+    \   'command': ale#node#Executable(a:buffer, l:executable)
     \       . ' --fix %t',
     \   'read_temporary_file': 1,
     \}

autoload/ale/fixers/tslint.vim

@@ -0,0 +1,22 @@
+" Author: carakan <carakan@gmail.com>
+" Description: Fixing files with tslint.
+
+function! ale#fixers#tslint#Fix(buffer) abort
+    let l:executable = ale_linters#typescript#tslint#GetExecutable(a:buffer)
+
+    let l:tslint_config_path = ale#path#ResolveLocalPath(
+    \   a:buffer,
+    \   'tslint.json',
+    \   ale#Var(a:buffer, 'typescript_tslint_config_path')
+    \)
+    let l:tslint_config_option = !empty(l:tslint_config_path)
+    \   ? ' -c ' . ale#Escape(l:tslint_config_path)
+    \   : ''
+
+    return {
+    \   'command': ale#node#Executable(a:buffer, l:executable)
+    \       . l:tslint_config_option
+    \       . ' --fix %t',
+    \   'read_temporary_file': 1,
+    \}
+endfunction

autoload/ale/gradle.vim

@@ -2,20 +2,30 @@
 " Description: Functions for working with Gradle projects.
 
 let s:script_path = fnamemodify(resolve(expand('<sfile>:p')), ':h')
+let s:init_path = has('win32')
+\   ? s:script_path . '\gradle\init.gradle'
+\   : s:script_path . '/gradle/init.gradle'
+
+function! ale#gradle#GetInitPath() abort
+    return s:init_path
+endfunction
 
 " Given a buffer number, find a Gradle project root.
 function! ale#gradle#FindProjectRoot(buffer) abort
     let l:gradlew_path = ale#path#FindNearestFile(a:buffer, 'gradlew')
+
     if !empty(l:gradlew_path)
         return fnamemodify(l:gradlew_path, ':h')
     endif
 
     let l:settings_path = ale#path#FindNearestFile(a:buffer, 'settings.gradle')
+
     if !empty(l:settings_path)
         return fnamemodify(l:settings_path, ':h')
     endif
 
     let l:build_path = ale#path#FindNearestFile(a:buffer, 'build.gradle')
+
     if !empty(l:build_path)
         return fnamemodify(l:build_path, ':h')
     endif
@@ -28,6 +38,7 @@ endfunction
 " command. Returns an empty string if cannot find the executable.
 function! ale#gradle#FindExecutable(buffer) abort
     let l:gradlew_path = ale#path#FindNearestFile(a:buffer, 'gradlew')
+
     if !empty(l:gradlew_path)
         return l:gradlew_path
     endif
@@ -47,7 +58,9 @@ function! ale#gradle#BuildClasspathCommand(buffer) abort
 
     if !empty(l:executable) && !empty(l:project_root)
         return ale#path#CdString(l:project_root)
-        \   . l:executable . ' -I ' . s:script_path . '/gradle/init.gradle -q printClasspath'
+        \   . ale#Escape(l:executable)
+        \   . ' -I ' . ale#Escape(s:init_path)
+        \   . ' -q printClasspath'
     endif
 
     return ''

autoload/ale/handlers/eslint.vim

@@ -1,11 +1,33 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Functions for working with eslint, for checking or fixing files.
 
+let s:sep = has('win32') ? '\' : '/'
+
 call ale#Set('javascript_eslint_options', '')
 call ale#Set('javascript_eslint_executable', 'eslint')
 call ale#Set('javascript_eslint_use_global', 0)
 call ale#Set('javascript_eslint_suppress_eslintignore', 0)
 
+function! ale#handlers#eslint#FindConfig(buffer) abort
+    for l:path in ale#path#Upwards(expand('#' . a:buffer . ':p:h'))
+        for l:basename in [
+        \   '.eslintrc.js',
+        \   '.eslintrc.yaml',
+        \   '.eslintrc.yml',
+        \   '.eslintrc.json',
+        \   '.eslintrc',
+        \]
+            let l:config = ale#path#Simplify(join([l:path, l:basename], s:sep))
+
+            if filereadable(l:config)
+                return l:config
+            endif
+        endfor
+    endfor
+
+    return ale#path#FindNearestFile(a:buffer, 'package.json')
+endfunction
+
 function! ale#handlers#eslint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_eslint', [
     \   'node_modules/.bin/eslint_d',
@@ -17,17 +39,9 @@ endfunction
 function! ale#handlers#eslint#GetCommand(buffer) abort
     let l:executable = ale#handlers#eslint#GetExecutable(a:buffer)
 
-    if ale#Has('win32') && l:executable =~? 'eslint\.js$'
-        " For Windows, if we detect an eslint.js script, we need to execute
-        " it with node, or the file can be opened with a text editor.
-        let l:head = 'node ' . ale#Escape(l:executable)
-    else
-        let l:head = ale#Escape(l:executable)
-    endif
-
     let l:options = ale#Var(a:buffer, 'javascript_eslint_options')
 
-    return l:head
+    return ale#node#Executable(a:buffer, l:executable)
     \   . (!empty(l:options) ? ' ' . l:options : '')
     \   . ' -f unix --stdin --stdin-filename %s'
 endfunction

autoload/ale/handlers/haskell.vim

@@ -1,12 +1,25 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Error handling for the format GHC outputs.
 
+" Remember the directory used for temporary files for Vim.
+let s:temp_dir = fnamemodify(tempname(), ':h')
+" Build part of a regular expression for matching ALE temporary filenames.
+let s:temp_regex_prefix =
+\   '\M'
+\   . substitute(s:temp_dir, '\\', '\\\\', 'g')
+\   . '\.\{-}'
+
 function! ale#handlers#haskell#HandleGHCFormat(buffer, lines) abort
     " Look for lines like the following.
     "
     "Appoint/Lib.hs:8:1: warning:
     "Appoint/Lib.hs:8:1:
-    let l:pattern = '\v^([a-zA-Z]?:?[^:]+):(\d+):(\d+):(.*)?$'
+    let l:basename = expand('#' . a:buffer . ':t')
+    " Build a complete regular expression for replacing temporary filenames
+    " in Haskell error messages with the basename for this file.
+    let l:temp_filename_regex = s:temp_regex_prefix . l:basename
+
+    let l:pattern = '\v^\s*([a-zA-Z]?:?[^:]+):(\d+):(\d+):(.*)?$'
     let l:output = []
 
     let l:corrected_lines = []
@@ -51,6 +64,9 @@ function! ale#handlers#haskell#HandleGHCFormat(buffer, lines) abort
             let l:type = 'E'
         endif
 
+        " Replace temporary filenames in problem messages with the basename
+        let l:text = substitute(l:text, l:temp_filename_regex, l:basename, 'g')
+
         call add(l:output, {
         \   'lnum': l:match[2] + 0,
         \   'col': l:match[3] + 0,

autoload/ale/handlers/rust.vim

@@ -7,25 +7,25 @@ if !exists('g:ale_rust_ignore_error_codes')
     let g:ale_rust_ignore_error_codes = []
 endif
 
-" returns: a list [lnum, col] with the location of the error or []
-function! s:FindErrorInExpansion(span, buffer) abort
-    if ale#path#IsBufferPath(a:buffer, a:span.file_name)
-        return [a:span.line_start, a:span.line_end, a:span.byte_start, a:span.byte_end]
+function! s:FindSpan(buffer, span) abort
+    if ale#path#IsBufferPath(a:buffer, a:span.file_name) || a:span.file_name is# '<anon>'
+        return a:span
     endif
 
-    if !empty(a:span.expansion)
-        return s:FindErrorInExpansion(a:span.expansion.span, a:buffer)
+    " Search inside the expansion of an error, as the problem for this buffer
+    " could lie inside a nested object.
+    if !empty(get(a:span, 'expansion', v:null))
+        return s:FindSpan(a:buffer, a:span.expansion.span)
     endif
 
-    return []
+    return {}
 endfunction
 
-" A handler function which accepts a file name, to make unit testing easier.
-function! ale#handlers#rust#HandleRustErrorsForFile(buffer, full_filename, lines) abort
+function! ale#handlers#rust#HandleRustErrors(buffer, lines) abort
     let l:output = []
 
     for l:errorline in a:lines
-        " ignore everything that is not Json
+        " ignore everything that is not JSON
         if l:errorline !~# '^{'
             continue
         endif
@@ -44,11 +44,10 @@ function! ale#handlers#rust#HandleRustErrorsForFile(buffer, full_filename, lines
             continue
         endif
 
-        for l:span in l:error.spans
-            if (
-            \   l:span.is_primary
-            \   && (ale#path#IsBufferPath(a:buffer, l:span.file_name) || l:span.file_name is# '<anon>')
-            \)
+        for l:root_span in l:error.spans
+            let l:span = s:FindSpan(a:buffer, l:root_span)
+
+            if !empty(l:span)
                 call add(l:output, {
                 \   'lnum': l:span.line_start,
                 \   'end_lnum': l:span.line_end,
@@ -57,29 +56,9 @@ function! ale#handlers#rust#HandleRustErrorsForFile(buffer, full_filename, lines
                 \   'text': empty(l:span.label) ? l:error.message : printf('%s: %s', l:error.message, l:span.label),
                 \   'type': toupper(l:error.level[0]),
                 \})
-            else
-                " when the error is caused in the expansion of a macro, we have
-                " to bury deeper
-                let l:root_cause = s:FindErrorInExpansion(l:span, a:buffer)
-
-                if !empty(l:root_cause)
-                    call add(l:output, {
-                    \   'lnum': l:root_cause[0],
-                    \   'end_lnum': l:root_cause[1],
-                    \   'col': l:root_cause[2],
-                    \   'end_col': l:root_cause[3],
-                    \   'text': l:error.message,
-                    \   'type': toupper(l:error.level[0]),
-                    \})
-                endif
             endif
         endfor
     endfor
 
     return l:output
 endfunction
-
-" A handler for output for Rust linters.
-function! ale#handlers#rust#HandleRustErrors(buffer, lines) abort
-    return ale#handlers#rust#HandleRustErrorsForFile(a:buffer, bufname(a:buffer), a:lines)
-endfunction

autoload/ale/handlers/sh.vim

@@ -0,0 +1,20 @@
+" Author: w0rp <devw0rp@gmail.com>
+
+" Get the shell type for a buffer, based on the hashbang line.
+function! ale#handlers#sh#GetShellType(buffer) abort
+    let l:bang_line = get(getbufline(a:buffer, 1), 0, '')
+
+    " Take the shell executable from the hashbang, if we can.
+    if l:bang_line[:1] is# '#!'
+        " Remove options like -e, etc.
+        let l:command = substitute(l:bang_line, ' --\?[a-zA-Z0-9]\+', '', 'g')
+
+        for l:possible_shell in ['bash', 'dash', 'ash', 'tcsh', 'csh', 'zsh', 'sh']
+            if l:command =~# l:possible_shell . '\s*$'
+                return l:possible_shell
+            endif
+        endfor
+    endif
+
+    return ''
+endfunction

autoload/ale/handlers/sml.vim

@@ -0,0 +1,92 @@
+" Author: Jake Zimmerman <jake@zimmerman.io>
+" Description: Shared functions for SML linters
+
+" The glob to use for finding the .cm file.
+"
+" See :help ale-sml-smlnj for more information.
+call ale#Set('sml_smlnj_cm_file', '*.cm')
+
+function! ale#handlers#sml#GetCmFile(buffer) abort
+    let l:pattern = ale#Var(a:buffer, 'sml_smlnj_cm_file')
+    let l:as_list = 1
+
+    let l:cmfile = ''
+    for l:path in ale#path#Upwards(expand('#' . a:buffer . ':p:h'))
+        let l:results = glob(l:path . '/' . l:pattern, 0, l:as_list)
+        if len(l:results) > 0
+            " If there is more than one CM file, we take the first one
+            " See :help ale-sml-smlnj for how to configure this.
+            let l:cmfile = l:results[0]
+        endif
+    endfor
+
+    return l:cmfile
+endfunction
+
+" Only one of smlnj or smlnj-cm can be enabled at a time.
+" executable_callback is called before *every* lint attempt
+function! s:GetExecutable(buffer, source) abort
+    if ale#handlers#sml#GetCmFile(a:buffer) is# ''
+        " No CM file found; only allow single-file mode to be enabled
+        if a:source is# 'smlnj-file'
+            return 'sml'
+        elseif a:source is# 'smlnj-cm'
+            return ''
+        endif
+    else
+        " Found a CM file; only allow cm-file mode to be enabled
+        if a:source is# 'smlnj-file'
+            return ''
+        elseif a:source is# 'smlnj-cm'
+            return 'sml'
+        endif
+    endif
+endfunction
+
+function! ale#handlers#sml#GetExecutableSmlnjCm(buffer) abort
+    return s:GetExecutable(a:buffer, 'smlnj-cm')
+endfunction
+function! ale#handlers#sml#GetExecutableSmlnjFile(buffer) abort
+    return s:GetExecutable(a:buffer, 'smlnj-file')
+endfunction
+
+function! ale#handlers#sml#Handle(buffer, lines) abort
+    " Try to match basic sml errors
+    " TODO(jez) We can get better errorfmt strings from Syntastic
+
+    let l:out = []
+    let l:pattern = '^.*\:\([0-9\.]\+\)\ \(\w\+\)\:\ \(.*\)'
+    let l:pattern2 = '^.*\:\([0-9]\+\)\.\?\([0-9]\+\).* \(\(Warning\|Error\): .*\)'
+
+    for l:line in a:lines
+        let l:match2 = matchlist(l:line, l:pattern2)
+
+        if len(l:match2) != 0
+          call add(l:out, {
+          \   'bufnr': a:buffer,
+          \   'lnum': l:match2[1] + 0,
+          \   'col' : l:match2[2] - 1,
+          \   'text': l:match2[3],
+          \   'type': l:match2[3] =~# '^Warning' ? 'W' : 'E',
+          \})
+          continue
+        endif
+
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) != 0
+          call add(l:out, {
+          \   'bufnr': a:buffer,
+          \   'lnum': l:match[1] + 0,
+          \   'text': l:match[2] . ': ' . l:match[3],
+          \   'type': l:match[2] is# 'error' ? 'E' : 'W',
+          \})
+          continue
+        endif
+
+    endfor
+
+    return l:out
+endfunction
+
+" vim:ts=4:sts=4:sw=4

autoload/ale/job.vim

@@ -1,5 +1,5 @@
 " Author: w0rp <devw0rp@gmail.com>
-" Deciption: APIs for working with Asynchronous jobs, with an API normalised
+" Description: APIs for working with Asynchronous jobs, with an API normalised
 " between Vim 8 and NeoVim.
 "
 " Important functions are described below. They are:
@@ -25,6 +25,11 @@ endfunction
 
 " Note that jobs and IDs are the same thing on NeoVim.
 function! ale#job#JoinNeovimOutput(job, last_line, data, mode, callback) abort
+    if a:mode is# 'raw'
+        call a:callback(a:job, join(a:data, "\n"))
+        return ''
+    endif
+
     let l:lines = a:data[:-2]
 
     if len(a:data) > 1
@@ -34,15 +39,9 @@ function! ale#job#JoinNeovimOutput(job, last_line, data, mode, callback) abort
         let l:new_last_line = a:last_line . a:data[0]
     endif
 
-    if a:mode is# 'raw'
-        if !empty(l:lines)
-            call a:callback(a:job, join(l:lines, "\n") . "\n")
-        endif
-    else
-        for l:line in l:lines
-            call a:callback(a:job, l:line)
-        endfor
-    endif
+    for l:line in l:lines
+        call a:callback(a:job, l:line)
+    endfor
 
     return l:new_last_line
 endfunction
@@ -290,7 +289,7 @@ function! ale#job#Stop(job_id) abort
         " FIXME: NeoVim kills jobs on a timer, but will not kill any processes
         " which are child processes on Unix. Some work needs to be done to
         " kill child processes to stop long-running processes like pylint.
-        call jobstop(a:job_id)
+        silent! call jobstop(a:job_id)
     else
         let l:job = s:job_map[a:job_id].job
 

autoload/ale/linter.vim

@@ -25,6 +25,7 @@ let s:default_ale_linters = {
 \   'csh': ['shell'],
 \   'go': ['gofmt', 'golint', 'go vet'],
 \   'help': [],
+\   'python': ['flake8', 'mypy', 'pylint'],
 \   'rust': ['cargo'],
 \   'spec': [],
 \   'text': [],
@@ -304,7 +305,7 @@ endfunction
 function! ale#linter#Get(original_filetypes) abort
     let l:possibly_duplicated_linters = []
 
-    " Handle dot-seperated filetypes.
+    " Handle dot-separated filetypes.
     for l:original_filetype in split(a:original_filetypes, '\.')
         let l:filetype = ale#linter#ResolveFiletype(l:original_filetype)
         let l:linter_names = s:GetLinterNames(l:original_filetype)

autoload/ale/list.vim

@@ -56,6 +56,10 @@ function! s:FixList(list) abort
     return l:new_list
 endfunction
 
+function! s:BufWinId(buffer) abort
+    return exists('*bufwinid') ? bufwinid(str2nr(a:buffer)) : 0
+endfunction
+
 function! s:SetListsImpl(timer_id, buffer, loclist) abort
     let l:title = expand('#' . a:buffer . ':p')
 
@@ -72,7 +76,7 @@ function! s:SetListsImpl(timer_id, buffer, loclist) abort
         " If windows support is off, bufwinid() may not exist.
         " We'll set result in the current window, which might not be correct,
         " but is better than nothing.
-        let l:win_id = exists('*bufwinid') ? bufwinid(str2nr(a:buffer)) : 0
+        let l:win_id = s:BufWinId(a:buffer)
 
         if has('nvim')
             call setloclist(l:win_id, s:FixList(a:loclist), ' ', l:title)
@@ -82,13 +86,11 @@ function! s:SetListsImpl(timer_id, buffer, loclist) abort
         endif
     endif
 
-    let l:keep_open = ale#Var(a:buffer, 'keep_list_window_open')
-
     " Open a window to show the problems if we need to.
     "
     " We'll check if the current buffer's List is not empty here, so the
     " window will only be opened if the current buffer has problems.
-    if s:ShouldOpen(a:buffer) && (l:keep_open || !empty(a:loclist))
+    if s:ShouldOpen(a:buffer) && !empty(a:loclist)
         let l:winnr = winnr()
         let l:mode = mode()
         let l:reset_visual_selection = l:mode is? 'v' || l:mode is# "\<c-v>"
@@ -96,10 +98,10 @@ function! s:SetListsImpl(timer_id, buffer, loclist) abort
 
         if g:ale_set_quickfix
             if !ale#list#IsQuickfixOpen()
-                execute 'copen ' . str2nr(ale#Var(a:buffer, 'list_window_size'))
+                silent! execute 'copen ' . str2nr(ale#Var(a:buffer, 'list_window_size'))
             endif
         elseif g:ale_set_loclist
-            execute 'lopen ' . str2nr(ale#Var(a:buffer, 'list_window_size'))
+            silent! execute 'lopen ' . str2nr(ale#Var(a:buffer, 'list_window_size'))
         endif
 
         " If focus changed, restore it (jump to the last window).
@@ -117,10 +119,23 @@ function! s:SetListsImpl(timer_id, buffer, loclist) abort
             endif
         endif
     endif
+
+    " If ALE isn't currently checking for more problems, close the window if
+    " needed now. This check happens inside of this timer function, so
+    " the window can be closed reliably.
+    if !ale#engine#IsCheckingBuffer(a:buffer)
+        call s:CloseWindowIfNeeded(a:buffer)
+    endif
 endfunction
 
 function! ale#list#SetLists(buffer, loclist) abort
     if get(g:, 'ale_set_lists_synchronously') == 1
+    \|| getbufvar(a:buffer, 'ale_save_event_fired', 0)
+        " Update lists immediately if running a test synchronously, or if the
+        " buffer was saved.
+        "
+        " The lists need to be updated immediately when saving a buffer so
+        " that we can reliably close window automatically, if so configured.
         call s:SetListsImpl(-1, a:buffer, a:loclist)
     else
         call ale#util#StartPartialTimer(
@@ -131,7 +146,7 @@ function! ale#list#SetLists(buffer, loclist) abort
     endif
 endfunction
 
-function! s:CloseWindowIfNeededImpl(timer_id, buffer) abort
+function! s:CloseWindowIfNeeded(buffer) abort
     if ale#Var(a:buffer, 'keep_list_window_open') || !s:ShouldOpen(a:buffer)
         return
     endif
@@ -143,22 +158,14 @@ function! s:CloseWindowIfNeededImpl(timer_id, buffer) abort
             if empty(getqflist())
                 cclose
             endif
-        elseif g:ale_set_loclist && empty(getloclist(0))
-            lclose
+        else
+            let l:win_id = s:BufWinId(a:buffer)
+
+            if g:ale_set_loclist && empty(getloclist(l:win_id))
+                lclose
+            endif
         endif
     " Ignore 'Cannot close last window' errors.
     catch /E444/
     endtry
 endfunction
-
-function! ale#list#CloseWindowIfNeeded(buffer) abort
-    if get(g:, 'ale_set_lists_synchronously') == 1
-        call s:CloseWindowIfNeededImpl(-1, a:buffer)
-    else
-        call ale#util#StartPartialTimer(
-        \   0,
-        \   function('s:CloseWindowIfNeededImpl'),
-        \   [a:buffer],
-        \)
-    endif
-endfunction

autoload/ale/lsp.vim

@@ -242,10 +242,14 @@ function! s:HandleCommandMessage(job_id, message) abort
     call ale#lsp#HandleMessage(l:conn, a:message)
 endfunction
 
-function! s:RegisterProject(conn, project_root) abort
-    if !has_key(a:conn.projects, a:project_root)
+function! ale#lsp#RegisterProject(conn, project_root) abort
+    " Empty strings can't be used for Dictionary keys in NeoVim, due to E713.
+    " This appears to be a nonsensical bug in NeoVim.
+    let l:key = empty(a:project_root) ? '<<EMPTY>>' : a:project_root
+
+    if !has_key(a:conn.projects, l:key)
         " Tools without project roots are ready right away, like tsserver.
-        let a:conn.projects[a:project_root] = {
+        let a:conn.projects[l:key] = {
         \   'initialized': empty(a:project_root),
         \   'init_request_id': 0,
         \   'message_queue': [],
@@ -253,6 +257,12 @@ function! s:RegisterProject(conn, project_root) abort
     endif
 endfunction
 
+function! ale#lsp#GetProject(conn, project_root) abort
+    let l:key = empty(a:project_root) ? '<<EMPTY>>' : a:project_root
+
+    return get(a:conn.projects, l:key, {})
+endfunction
+
 " Start a program for LSP servers which run with executables.
 "
 " The job ID will be returned for for the program if it ran, otherwise
@@ -285,7 +295,7 @@ function! ale#lsp#StartProgram(executable, command, project_root, callback) abor
     let l:conn.id = l:job_id
     " Add the callback to the List if it's not there already.
     call uniq(sort(add(l:conn.callback_list, a:callback)))
-    call s:RegisterProject(l:conn, a:project_root)
+    call ale#lsp#RegisterProject(l:conn, a:project_root)
 
     return l:job_id
 endfunction
@@ -311,7 +321,7 @@ function! ale#lsp#ConnectToAddress(address, project_root, callback) abort
     let l:conn.id = a:address
     " Add the callback to the List if it's not there already.
     call uniq(sort(add(l:conn.callback_list, a:callback)))
-    call s:RegisterProject(l:conn, a:project_root)
+    call ale#lsp#RegisterProject(l:conn, a:project_root)
 
     return 1
 endfunction
@@ -344,7 +354,7 @@ function! ale#lsp#Send(conn_id, message, ...) abort
         return 0
     endif
 
-    let l:project = get(l:conn.projects, l:project_root, {})
+    let l:project = ale#lsp#GetProject(l:conn, l:project_root)
 
     if empty(l:project)
         return 0

autoload/ale/lsp/message.vim

@@ -53,7 +53,7 @@ function! ale#lsp#message#DidOpen(buffer, language_id) abort
     \       'uri': ale#path#ToURI(expand('#' . a:buffer . ':p')),
     \       'languageId': a:language_id,
     \       'version': ale#lsp#message#GetNextVersionID(),
-    \       'text': join(l:lines, "\n"),
+    \       'text': join(l:lines, "\n") . "\n",
     \   },
     \}]
 endfunction
@@ -67,7 +67,7 @@ function! ale#lsp#message#DidChange(buffer) abort
     \       'uri': ale#path#ToURI(expand('#' . a:buffer . ':p')),
     \       'version': ale#lsp#message#GetNextVersionID(),
     \   },
-    \   'contentChanges': [{'text': join(l:lines, "\n")}]
+    \   'contentChanges': [{'text': join(l:lines, "\n") . "\n"}]
     \}]
 endfunction
 

autoload/ale/lsp/tsserver_message.vim

@@ -28,7 +28,7 @@ function! ale#lsp#tsserver_message#Change(buffer) abort
     \   'offset': 1,
     \   'endLine': 1073741824,
     \   'endOffset': 1,
-    \   'insertString': join(l:lines, "\n"),
+    \   'insertString': join(l:lines, "\n") . "\n",
     \}]
 endfunction
 

autoload/ale/node.vim

@@ -1,6 +1,8 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Functions for working with Node executables.
 
+call ale#Set('windows_node_executable_path', 'node.exe')
+
 " Given a buffer number, a base variable name, and a list of paths to search
 " for in ancestor directories, detect the executable path for a Node program.
 "
@@ -20,3 +22,21 @@ function! ale#node#FindExecutable(buffer, base_var_name, path_list) abort
 
     return ale#Var(a:buffer, a:base_var_name . '_executable')
 endfunction
+
+" Create a executable string which executes a Node.js script command with a
+" Node.js executable if needed.
+"
+" The executable string should not be escaped before passing it to this
+" function, the executable string will be escaped when returned by this
+" function.
+"
+" The executable is only prefixed for Windows machines
+function! ale#node#Executable(buffer, executable) abort
+    if ale#Has('win32') && a:executable =~? '\.js$'
+        let l:node = ale#Var(a:buffer, 'windows_node_executable_path')
+
+        return ale#Escape(l:node) . ' ' . ale#Escape(a:executable)
+    endif
+
+    return ale#Escape(a:executable)
+endfunction

autoload/ale/path.vim

@@ -7,6 +7,26 @@ function! ale#path#Simplify(path) abort
     return substitute(simplify(a:path), '^//\+', '/', 'g') " no-custom-checks
 endfunction
 
+" This function is mainly used for testing.
+" Simplify() a path, and change forward slashes to back slashes on Windows.
+"
+" If an additional 'add_drive' argument is given, the current drive letter
+" will be prefixed to any absolute paths on Windows.
+function! ale#path#Winify(path, ...) abort
+    let l:new_path = ale#path#Simplify(a:path)
+
+    if has('win32')
+        let l:new_path = substitute(l:new_path, '/', '\\', 'g')
+
+        " Add a drive letter to \foo\bar paths, if needed.
+        if a:0 && a:1 is# 'add_drive' && l:new_path[:0] is# '\'
+            let l:new_path = fnamemodify('.', ':p')[:1] . l:new_path
+        endif
+    endif
+
+    return l:new_path
+endfunction
+
 " Given a buffer and a filename, find the nearest file by searching upwards
 " through the paths relative to the given buffer.
 function! ale#path#FindNearestFile(buffer, filename) abort
@@ -68,22 +88,12 @@ function! ale#path#IsAbsolute(filename) abort
     return a:filename[:0] is# '/' || a:filename[1:2] is# ':\'
 endfunction
 
+let s:temp_dir = fnamemodify(tempname(), ':h')
+
 " Given a filename, return 1 if the file represents some temporary file
 " created by Vim.
 function! ale#path#IsTempName(filename) abort
-    let l:prefix_list = [
-    \   $TMPDIR,
-    \   resolve($TMPDIR),
-    \   '/run/user',
-    \]
-
-    for l:prefix in l:prefix_list
-        if a:filename[:len(l:prefix) - 1] is# l:prefix
-            return 1
-        endif
-    endfor
-
-    return 0
+    return a:filename[:len(s:temp_dir) - 1] is# s:temp_dir
 endfunction
 
 " Given a base directory, which must not have a trailing slash, and a
@@ -175,5 +185,12 @@ function! ale#path#FromURI(uri) abort
     let l:i = len('file://')
     let l:encoded_path = a:uri[: l:i - 1] is# 'file://' ? a:uri[l:i :] : a:uri
 
-    return ale#uri#Decode(l:encoded_path)
+    let l:path = ale#uri#Decode(l:encoded_path)
+
+    " If the path is like /C:/foo/bar, it should be C:\foo\bar instead.
+    if l:path =~# '^/[a-zA-Z]:'
+        let l:path = substitute(l:path[1:], '/', '\\', 'g')
+    endif
+
+    return l:path
 endfunction

autoload/ale/python.vim

@@ -1,6 +1,7 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: Functions for integrating with Python linters.
 
+let s:sep = has('win32') ? '\' : '/'
 " bin is used for Unix virtualenv directories, and Scripts is for Windows.
 let s:bin_dir = has('unix') ? 'bin' : 'Scripts'
 let g:ale_virtualenv_dir_names = get(g:, 'ale_virtualenv_dir_names', [
@@ -11,7 +12,6 @@ let g:ale_virtualenv_dir_names = get(g:, 'ale_virtualenv_dir_names', [
 \   'virtualenv',
 \])
 
-
 function! ale#python#FindProjectRootIni(buffer) abort
     for l:path in ale#path#Upwards(expand('#' . a:buffer . ':p:h'))
         if filereadable(l:path . '/MANIFEST.in')
@@ -58,15 +58,20 @@ function! ale#python#FindVirtualenv(buffer) abort
         endif
 
         for l:dirname in ale#Var(a:buffer, 'virtualenv_dir_names')
-            let l:venv_dir = ale#path#Simplify(l:path . '/' . l:dirname)
+            let l:venv_dir = ale#path#Simplify(
+            \   join([l:path, l:dirname], s:sep)
+            \)
+            let l:script_filename = ale#path#Simplify(
+            \   join([l:venv_dir, s:bin_dir, 'activate'], s:sep)
+            \)
 
-            if filereadable(ale#path#Simplify(l:venv_dir . '/' . s:bin_dir . '/activate'))
+            if filereadable(l:script_filename)
                 return l:venv_dir
             endif
         endfor
     endfor
 
-    return ''
+    return $VIRTUAL_ENV
 endfunction
 
 " Given a buffer number and a command name, find the path to the executable.
@@ -81,7 +86,9 @@ function! ale#python#FindExecutable(buffer, base_var_name, path_list) abort
 
     if !empty(l:virtualenv)
         for l:path in a:path_list
-            let l:ve_executable = ale#path#Simplify(l:virtualenv . '/' . s:bin_dir . '/' . l:path)
+            let l:ve_executable = ale#path#Simplify(
+            \   join([l:virtualenv, s:bin_dir, l:path], s:sep)
+            \)
 
             if executable(l:ve_executable)
                 return l:ve_executable

autoload/ale/sign.vim

@@ -184,16 +184,6 @@ function! s:GroupLoclistItems(buffer, loclist) abort
     return l:grouped_items
 endfunction
 
-function! ale#sign#SetSignColumnHighlight(has_problems) abort
-    highlight clear SignColumn
-
-    if a:has_problems
-        highlight link SignColumn ALESignColumnWithErrors
-    else
-        highlight link SignColumn ALESignColumnWithoutErrors
-    endif
-endfunction
-
 function! s:UpdateLineNumbers(buffer, current_sign_list, loclist) abort
     let l:line_map = {}
     let l:line_numbers_changed = 0
@@ -219,29 +209,47 @@ function! s:UpdateLineNumbers(buffer, current_sign_list, loclist) abort
     endif
 endfunction
 
-function! s:BuildSignMap(current_sign_list, grouped_items) abort
+function! s:BuildSignMap(buffer, current_sign_list, grouped_items) abort
+    let l:max_signs = ale#Var(a:buffer, 'max_signs')
+
+    if l:max_signs is 0
+        let l:selected_grouped_items = []
+    elseif type(l:max_signs) is type(0) && l:max_signs > 0
+        let l:selected_grouped_items = a:grouped_items[:l:max_signs - 1]
+    else
+        let l:selected_grouped_items = a:grouped_items
+    endif
+
     let l:sign_map = {}
     let l:sign_offset = g:ale_sign_offset
 
     for [l:line, l:sign_id, l:name] in a:current_sign_list
-        let l:sign_map[l:line] = {
-        \   'current_id': l:sign_id,
-        \   'current_name': l:name,
+        let l:sign_info = get(l:sign_map, l:line, {
+        \   'current_id_list': [],
+        \   'current_name_list': [],
         \   'new_id': 0,
         \   'new_name': '',
         \   'items': [],
-        \}
+        \})
 
+        " Increment the sign offset for new signs, by the maximum sign ID.
         if l:sign_id > l:sign_offset
             let l:sign_offset = l:sign_id
         endif
+
+        " Remember the sign names and IDs in separate Lists, so they are easy
+        " to work with.
+        call add(l:sign_info.current_id_list, l:sign_id)
+        call add(l:sign_info.current_name_list, l:name)
+
+        let l:sign_map[l:line] = l:sign_info
     endfor
 
-    for l:group in a:grouped_items
+    for l:group in l:selected_grouped_items
         let l:line = l:group[0].lnum
         let l:sign_info = get(l:sign_map, l:line, {
-        \   'current_id': 0,
-        \   'current_name': '',
+        \   'current_id_list': [],
+        \   'current_name_list': [],
         \   'new_id': 0,
         \   'new_name': '',
         \   'items': [],
@@ -250,11 +258,18 @@ function! s:BuildSignMap(current_sign_list, grouped_items) abort
         let l:sign_info.new_name = ale#sign#GetSignName(l:group)
         let l:sign_info.items = l:group
 
-        if l:sign_info.current_name isnot# l:sign_info.new_name
+        let l:index = index(
+        \   l:sign_info.current_name_list,
+        \   l:sign_info.new_name
+        \)
+
+        if l:index >= 0
+            " We have a sign with this name already, so use the same ID.
+            let l:sign_info.new_id = l:sign_info.current_id_list[l:index]
+        else
+            " This sign name replaces the previous name, so use a new ID.
             let l:sign_info.new_id = l:sign_offset + 1
             let l:sign_offset += 1
-        else
-            let l:sign_info.new_id = l:sign_info.current_id
         endif
 
         let l:sign_map[l:line] = l:sign_info
@@ -288,7 +303,7 @@ function! ale#sign#GetSignCommands(buffer, was_sign_set, sign_map) abort
                 let l:item.sign_id = l:info.new_id
             endfor
 
-            if l:info.new_id isnot l:info.current_id
+            if index(l:info.current_id_list, l:info.new_id) < 0
                 call add(l:command_list, 'sign place '
                 \   . (l:info.new_id)
                 \   . ' line=' . l:line_str
@@ -301,12 +316,14 @@ function! ale#sign#GetSignCommands(buffer, was_sign_set, sign_map) abort
 
     " Remove signs without new IDs.
     for l:info in values(a:sign_map)
-        if l:info.current_id && l:info.current_id isnot l:info.new_id
-            call add(l:command_list, 'sign unplace '
-            \   . (l:info.current_id)
-            \   . ' buffer=' . a:buffer
-            \)
-        endif
+        for l:current_id in l:info.current_id_list
+            if l:current_id isnot l:info.new_id
+                call add(l:command_list, 'sign unplace '
+                \   . l:current_id
+                \   . ' buffer=' . a:buffer
+                \)
+            endif
+        endfor
     endfor
 
     " Remove the dummy sign to close the sign column if we need to.
@@ -339,7 +356,11 @@ function! ale#sign#SetSigns(buffer, loclist) abort
     let l:grouped_items = s:GroupLoclistItems(a:buffer, a:loclist)
 
     " Build a map of current and new signs, with the lines as the keys.
-    let l:sign_map = s:BuildSignMap(l:current_sign_list, l:grouped_items)
+    let l:sign_map = s:BuildSignMap(
+    \   a:buffer,
+    \   l:current_sign_list,
+    \   l:grouped_items,
+    \)
 
     let l:command_list = ale#sign#GetSignCommands(
     \   a:buffer,
@@ -347,7 +368,19 @@ function! ale#sign#SetSigns(buffer, loclist) abort
     \   l:sign_map,
     \)
 
+    " Change the sign column color if the option is on.
+    if g:ale_change_sign_column_color && !empty(a:loclist)
+        highlight clear SignColumn
+        highlight link SignColumn ALESignColumnWithErrors
+    endif
+
     for l:command in l:command_list
         silent! execute l:command
     endfor
+
+    " Reset the sign column color when there are no more errors.
+    if g:ale_change_sign_column_color && empty(a:loclist)
+        highlight clear SignColumn
+        highlight link SignColumn ALESignColumnWithoutErrors
+    endif
 endfunction

autoload/ale/test.vim

@@ -19,7 +19,7 @@ function! ale#test#SetDirectory(docker_path) abort
     " Try to switch directory, which will fail when running tests directly,
     " and not through the Docker image.
     silent! execute 'cd ' . fnameescape(a:docker_path)
-    let g:dir = getcwd()
+    let g:dir = getcwd() " no-custom-checks
 endfunction
 
 " When g:dir is defined, switch back to the directory we saved, and then
@@ -43,12 +43,12 @@ function! ale#test#SetFilename(path) abort
     let l:dir = get(g:, 'dir', '')
 
     if empty(l:dir)
-        let l:dir = getcwd()
+        let l:dir = getcwd() " no-custom-checks
     endif
 
     let l:full_path = ale#path#IsAbsolute(a:path)
     \   ? a:path
     \   : l:dir . '/' . a:path
 
-    silent noautocmd execute 'file ' . fnameescape(ale#path#Simplify(l:full_path))
+    silent! noautocmd execute 'file ' . fnameescape(ale#path#Winify(l:full_path))
 endfunction

doc/ale-asm.txt

@@ -1,5 +1,5 @@
 ===============================================================================
-ALE Assembly Integration                                      *ale-asm-options*
+ALE ASM Integration                                           *ale-asm-options*
 
 
 ===============================================================================

doc/ale-awk.txt

@@ -1,20 +1,20 @@
 ===============================================================================
-ALE Awk Integration                                          *ale-awk-options*
+ALE Awk Integration                                           *ale-awk-options*
 
 
 ===============================================================================
-gawk                                                  *ale-awk-gawk*
+gawk                                                             *ale-awk-gawk*
 
-g:ale_awk_gawk_executable                      *g:ale_awk_gawk_executable*
-                                               *b:ale_awk_gawk_executable*
+g:ale_awk_gawk_executable                           *g:ale_awk_gawk_executable*
+                                                    *b:ale_awk_gawk_executable*
   Type: |String|
   Default: `'gawk'`
 
   This variable sets executable used for gawk.
 
 
-g:ale_awk_gawk_options                            *g:ale_awk_gawk_options*
-                                                  *b:ale_awk_gawk_options*
+g:ale_awk_gawk_options                                 *g:ale_awk_gawk_options*
+                                                       *b:ale_awk_gawk_options*
   Type: |String|
   Default: `''`
 

doc/ale-c.txt

@@ -2,6 +2,37 @@
 ALE C Integration                                               *ale-c-options*
 
 
+===============================================================================
+Global Options
+
+g:ale_c_build_dir_names                               *g:ale_c_build_dir_names*
+                                                      *b:ale_c_build_dir_names*
+
+  Type: |List|
+  Default: `['build', 'bin']`
+
+  A list of directory names to be used when searching upwards from cpp
+  files to discover compilation databases with. For directory named `'foo'`,
+  ALE will search for `'foo/compile_commands.json'` in all directories on and above
+  the directory containing the cpp file to find path to compilation database.
+  This feature is useful for the clang tools wrapped around LibTooling (namely
+  here, clang-tidy)
+
+
+g:ale_c_build_dir                                           *g:ale_c_build_dir*
+                                                            *b:ale_c_build_dir*
+
+  Type: |String|
+  Default: `''`
+
+  A path to the directory containing the `compile_commands.json` file to use
+  with c-family linters. Usually setting this option to a non-empty string
+  will override the |g:ale_c_build_dir_names| option to impose a compilation
+  database (it can be useful if multiple builds are in multiple build
+  subdirectories in the project tree).
+  This feature is also most useful for the clang tools linters, wrapped
+  aroung LibTooling (namely clang-tidy here)
+
 ===============================================================================
 clang                                                             *ale-c-clang*
 
@@ -21,6 +52,78 @@ g:ale_c_clang_options                                   *g:ale_c_clang_options*
   This variable can be changed to modify flags given to clang.
 
 
+===============================================================================
+clang-format                                                *ale-c-clangformat*
+
+g:ale_c_clangformat_executable                 *g:ale_c_clangformat_executable*
+                                               *b:ale_c_clangformat_executable*
+  Type: |String|
+  Default: `'clang-format'`
+
+  This variable can be changed to use a different executable for clang-format.
+
+
+g:ale_c_clangformat_options                       *g:ale_c_clangformat_options*
+                                                  *b:ale_c_clangformat_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be change to modify flags given to clang-format.
+
+
+===============================================================================
+clangtidy                                                     *ale-c-clangtidy*
+
+`clang-tidy` will be run only when files are saved to disk, so that
+`compile_commands.json` files can be used. It is recommended to use this
+linter in combination with `compile_commands.json` files.
+Therefore, `clang-tidy` linter reads the options |g:ale_c_build_dir| and
+|g:ale_c_build_dir_names|. Also, setting |g:ale_c_build_dir| actually
+overrides |g:ale_c_build_dir_names|.
+
+
+g:ale_c_clangtidy_checks                             *g:ale_c_clangtidy_checks*
+                                                     *b:ale_c_clangtidy_checks*
+  Type: |List|
+  Default: `['*']`
+
+  The checks to enable for clang-tidy with the `-checks` argument.
+
+  All options will be joined with commas, and escaped appropriately for
+  the shell. The `-checks` flag can be removed entirely by setting this
+  option to an empty List.
+
+  Not all of clangtidy checks are applicable for C. You should consult the
+  clang documentation for an up-to-date list of compatible checks:
+  http://clang.llvm.org/extra/clang-tidy/checks/list.html
+
+
+g:ale_c_clangtidy_executable                     *g:ale_c_clangtidy_executable*
+                                                 *b:ale_c_clangtidy_executable*
+  Type: |String|
+  Default: `'clang-tidy'`
+
+  This variable can be changed to use a different executable for clangtidy.
+
+
+g:ale_c_clangtidy_options                           *g:ale_c_clangtidy_options*
+                                                    *b:ale_c_clangtidy_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be changed to modify flags given to clang-tidy.
+
+  - Setting this variable to a non-empty string,
+  - and working in a buffer where no compilation database is found using
+    |g:ale_c_build_dir_names| or |g:ale_c_build_dir|,
+  will cause the `--` argument to be passed to `clang-tidy`, which will mean
+  that detection of `compile_commands.json` files for compile command
+  databases will be disabled.
+  Only set this option if you want to control compiler flags
+  entirely manually, and no `compile_commands.json` file is in one
+  of the |g:ale_c_build_dir_names| directories of the project tree.
+
+
 ===============================================================================
 cppcheck                                                       *ale-c-cppcheck*
 
@@ -59,24 +162,5 @@ g:ale_c_gcc_options                                       *g:ale_c_gcc_options*
   This variable can be change to modify flags given to gcc.
 
 
-===============================================================================
-clang-format                                                *ale-c-clangformat*
-
-g:ale_c_clangformat_executable                 *g:ale_c_clangformat_executable*
-                                               *b:ale_c_clangformat_executable*
-  Type: |String|
-  Default: `'clang-format'`
-
-  This variable can be changed to use a different executable for clang-format.
-
-
-g:ale_c_clangformat_options                       *g:ale_c_clangformat_options*
-                                                  *b:ale_c_clangformat_options*
-  Type: |String|
-  Default: `''`
-
-  This variable can be change to modify flags given to clang-format.
-
-
 ===============================================================================
   vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-chef.txt

@@ -3,7 +3,7 @@ ALE Chef Integration                                         *ale-chef-options*
 
 
 ===============================================================================
-foodcritc                                                 *ale-chef-foodcritic*
+foodcritic                                                *ale-chef-foodcritic*
 
 g:ale_chef_foodcritic_options                   *g:ale_chef_foodcritic_options*
                                                 *b:ale_chef_foodcritic_options*

doc/ale-cmake.txt

@@ -5,7 +5,7 @@ ALE CMake Integration                                       *ale-cmake-options*
 ===============================================================================
 cmakelint                                                 *ale-cmake-cmakelint*
 
-g:ale_cmake_cmakelint_exectuable             *g:ale_cmake_cmakelint_executable*
+g:ale_cmake_cmakelint_executable             *g:ale_cmake_cmakelint_executable*
                                              *b:ale_cmake_cmakelint_executable*
   Type: |String|
   Default: `'cmakelint'`

doc/ale-cpp.txt

@@ -5,33 +5,9 @@ ALE C++ Integration                                           *ale-cpp-options*
 ===============================================================================
 Global Options
 
-g:ale_c_build_dir_names                               *g:ale_c_build_dir_names*
-                                                      *b:ale_c_build_dir_names*
+The |g:ale_c_build_dir_names| and |g:ale_c_build_dir| also apply to some C++
+linters too.
 
-  Type: |List|
-  Default: `['build', 'bin']`
-
-  A list of directory names to be used when searching upwards from cpp
-  files to discover compilation databases with. For directory named `'foo'`,
-  ALE will search for `'foo/compile_commands.json'` in all directories on and above
-  the directory containing the cpp file to find path to compilation database.
-  This feature is useful for the clang tools wrapped around LibTooling (namely
-  here, clang-tidy)
-
-
-g:ale_c_build_dir                                           *g:ale_c_build_dir*
-                                                            *b:ale_c_build_dir*
-
-  Type: |String|
-  Default: `''`
-
-  A path to the directory containing the `compile_commands.json` file to use
-  with c-family linters. Usually setting this option to a non-empty string
-  will override the |g:ale_c_build_dir_names| option to impose a compilation
-  database (it can be useful if multiple builds are in multiple build
-  subdirectories in the project tree).
-  This feature is also most useful for the clang tools linters, wrapped
-  aroung LibTooling (namely clang-tidy here)
 
 ===============================================================================
 clang                                                           *ale-cpp-clang*
@@ -83,6 +59,13 @@ g:ale_cpp_clangcheck_options                     *g:ale_cpp_clangcheck_options*
   option.
 
 
+===============================================================================
+clang-format                                              *ale-cpp-clangformat*
+
+See |ale-c-clangformat| for information about the available options.
+Note that the C options are also used for C++.
+
+
 ===============================================================================
 clangtidy                                                   *ale-cpp-clangtidy*
 
@@ -189,12 +172,5 @@ g:ale_cpp_gcc_options                                   *g:ale_cpp_gcc_options*
   This variable can be changed to modify flags given to gcc.
 
 
-===============================================================================
-clang-format                                              *ale-cpp-clangformat*
-
-See |ale-c-clangformat| for information about the available options.
-Note that the C options are also used for C++.
-
-
 ===============================================================================
   vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-cs.txt

@@ -0,0 +1,102 @@
+===============================================================================
+ALE C# Integration                                             *ale-cs-options*
+
+
+===============================================================================
+mcs                                                                *ale-cs-mcs*
+
+  The mcs linter checks the syntax of the '*.cs' file loaded in the current
+  buffer only. It uses the --parse option of the mcs compiler and implicitly 
+  sets the -unsafe flag.
+
+g:ale_cs_mcs_options                                     *g:ale_cs_mcs_options*
+                                                         *b:ale_cs_mcs_options*
+
+  Type: String
+  Default: `''`
+
+  This variable can be changed to pass additional flags given to mcs.
+
+  NOTE: The -unsafe flag is selected implicitly and thus does not need to be 
+  explicitly included in the |g:ale_cs_mcs_options| or |b:ale_cs_mcs_options|
+  parameter.
+
+
+===============================================================================
+mcsc                                                              *ale-cs-mcsc*
+
+  The mcsc linter uses the mono mcs compiler to generate a temporary module
+  target file (-t:module). The module includes including all '*.cs' files
+  contained in the directory tree rooted at the path defined by the 
+  |g:ale_cs_mcsc_source| or |b:ale_cs_mcsc_source| variable.
+  variable and all sub directories. 
+
+  The paths to search for additional assembly ('*.dll') files can be
+  specified using the |g:ale_cs_mcsc_assembly_path| or 
+  |b:ale_cs_mcsc_assembly_path| variable. The additional assembly files ('*.dll')
+  can be included through the |g:ale_cs_mcsc_assemblies| or 
+  |b:ale_cs_mcsc_assemblies| parameter. 
+
+  NOTE: mcs compiles sources in multiple phases. It stops compilation after
+  finding errors during the current phase.
+  For example assume a file named 'FileWithTypeError.cs' is edited and saved
+  which contains a Type error. In the same directory tree a file named
+  'FileWithSyntaxError.cs' exists which contains a syntax error 
+  (eg.: a missing '{'). 
+  In that case mcs and thus mcsc linter will stop after the syntax check phase is
+  finished and report the syntax error in the file 'FileWithSyntaxError.cs'. The
+  Type error in the file 'FileWithTypeError.cs is not seen jet.
+  The only possibility to find the error in in 'FileWithTypeError.cs' is to fix
+  the syntax error in 'FileWithSyntaxError.cs' first. After saving mcs will
+  successfully pass the syntax check phase and advance to the next compilation
+  phase at which the Type error hidden in 'FileWithTypeError.cs' is found  and 
+  now can be indicated  by ale.
+
+g:ale_cs_mcsc_options                                   *g:ale_cs_mcsc_options*
+                                                        *b:ale_cs_mcsc_options*
+  Type: |String|
+  Default: `''`
+
+  This parameter can be used to define additional flags and parameters independent
+  of the source tree to be linted. The specified string is directly passed to
+  mcs compiler without any further change.
+
+  For example, to add the dotnet package which is not added per default
+
+      let g:ale_cs_mcs_options = '-pkg:dotnet'
+
+  NOTE: The mcs -unsafe option is included implicitly per default. Therefore it
+  is not necessary to specify it explicitly through the |g:ale_cs_mcsc_options|
+  or |b:ale_cs_mcsc_options| parameter.
+
+g:ale_cs_mcsc_source                                     *g:ale_cs_mcsc_source*
+                                                         *b:ale_cs_mcsc_source*
+  Type: |String|
+  Default: `''`
+
+  This variable defines the root path of the directory tree searched for the
+  '*.cs' files to be linted. If empty the current working directory is used.
+
+  NOTE: Currently it is not possible to specify sub directories and
+  directory sub trees which shall not be searched for *.cs files.
+
+g:ale_cs_mcsc_assembly_path                       *g:ale_cs_mcsc_assembly_path*
+                                                  *b:ale_cs_mcsc_assembly_path*
+  Type: |List|
+  Default: `[]`
+
+  This variable defines a list of path strings to be searched for external
+  assembly ('*.dll') files. The list is passed to the mcs compiler using the
+  '-lib:' flag. 
+
+g:ale_cs_mcsc_assemblies                             *g:ale_cs_mcsc_assemblies*
+                                                     *b:ale_cs_mcsc_assemblies*
+  Type: |List|
+  Default: `[]`
+
+  This variable defines a list of external assembly (*.dll) files required 
+  by the mono mcs compiler to generate a valid module target. The list is 
+  passed the mcs compiler using the '-r:' flag.
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-css.txt

@@ -2,6 +2,12 @@
 ALE CSS Integration                                           *ale-css-options*
 
 
+===============================================================================
+prettier                                                     *ale-css-prettier*
+
+See |ale-javascript-prettier| for information about the available options.
+
+
 ===============================================================================
 stylelint                                                   *ale-css-stylelint*
 
@@ -13,8 +19,8 @@ g:ale_css_stylelint_executable                 *g:ale_css_stylelint_executable*
   See |ale-integrations-local-executables|
 
 
-g:ale_css_stylelint_options                    *g:ale_css_stylelint_options*
-                                               *b:ale_css_stylelint_options*
+g:ale_css_stylelint_options                       *g:ale_css_stylelint_options*
+                                                  *b:ale_css_stylelint_options*
   Type: |String|
   Default: `''`
 

doc/ale-cuda.txt

@@ -0,0 +1,25 @@
+===============================================================================
+ALE CUDA Integration                                         *ale-cuda-options*
+
+
+===============================================================================
+nvcc                                                            *ale-cuda-nvcc*
+
+g:ale_cuda_nvcc_executable                         *g:ale_cuda_nvcc_executable*
+                                                   *b:ale_cuda_nvcc_executable*
+  Type: |String|
+  Default: `'nvcc'`
+
+  This variable can be changed to use a different executable for nvcc.
+  Currently only nvcc 8.0 is supported.
+
+
+g:ale_cuda_nvcc_options                               *g:ale_cuda_nvcc_options*
+                                                      *b:ale_cuda_nvcc_options*
+  Type: |String|
+  Default: `'-std=c++11'`
+
+  This variable can be changed to modify flags given to nvcc.
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-elm.txt

@@ -0,0 +1,50 @@
+===============================================================================
+ALE Elm Integration                                           *ale-elm-options*
+
+
+===============================================================================
+elm-format                                                 *ale-elm-elm-format*
+
+g:ale_elm_format_executable                       *g:ale_elm_format_executable*
+                                                  *b:ale_elm_format_executable*
+  Type: |String|
+  Default: `'elm-format'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_elm_format_use_global                       *g:ale_elm_format_use_global*
+                                                  *b:ale_elm_format_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_elm_format_options                             *g:ale_elm_format_options*
+                                                     *b:ale_elm_format_options*
+  Type: |String|
+  Default: `'--yes'`
+
+  This variable can be set to pass additional options to elm-format.
+
+===============================================================================
+elm-make                                                     *ale-elm-elm-make*
+
+g:ale_elm_make_executable                           *g:ale_elm_make_executable*
+                                                    *b:ale_elm_make_executable*
+  Type: |String|
+  Default: `'elm-make'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_elm_make_use_global                           *g:ale_elm_make_use_global*
+                                                    *b:ale_elm_make_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-fuse.txt

@@ -3,7 +3,7 @@ ALE FusionScript Integration                                 *ale-fuse-options*
 
 
 ===============================================================================
-4.12. fusionlint                                          *ale-fuse-fusionlint*
+fusion-lint                                               *ale-fuse-fusionlint*
 
 g:ale_fusion_fusionlint_executable           *g:ale_fuse_fusionlint_executable*
                                              *b:ale_fuse_fusionlint_executable*

doc/ale-glsl.txt

@@ -0,0 +1,36 @@
+===============================================================================
+ALE GLSL Integration                                         *ale-glsl-options*
+                                                         *ale-integration-glsl*
+
+===============================================================================
+Integration Information
+
+  Since Vim does not detect the glsl file types out-of-the-box, you need the
+  runtime files for glsl from here: https://github.com/tikhomirov/vim-glsl
+
+  Note that the current glslang-based linter expects glslangValidator in
+  standard paths. If it's not installed system-wide you can set
+  |g:ale_glsl_glslang_executable| to a specific path.
+
+
+===============================================================================
+glslang                                                      *ale-glsl-glslang*
+
+g:ale_glsl_glslang_executable                   *g:ale_glsl_glslang_executable*
+                                                *b:ale_glsl_glslang_executable*
+  Type: |String|
+  Default: `'glslangValidator'`
+
+  This variable can be changed to change the path to glslangValidator.
+
+
+g:ale_glsl_glslang_options                         *g:ale_glsl_glslang_options*
+                                                   *b:ale_glsl_glslang_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to pass additional options to glslangValidator.
+
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-go.txt

@@ -20,6 +20,16 @@ the benefit of running a number of linters, more than ALE would by default,
 while ensuring it doesn't run any linters known to be slow or resource
 intensive.
 
+===============================================================================
+gofmt                                                            *ale-go-gofmt*
+
+g:ale_go_gofmt_options                                 *g:ale_go_gofmt_options*
+                                                       *b:ale_go_gofmt_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to pass additional options to the gofmt fixer.
+
 ===============================================================================
 gometalinter                                              *ale-go-gometalinter*
 

doc/ale-haskell.txt

@@ -1,16 +1,6 @@
 ===============================================================================
 ALE Haskell Integration                                   *ale-haskell-options*
 
-===============================================================================
-stack-build                                           *ale-haskell-stack-build*
-
-g:ale_haskell_stack_build_options           *g:ale_haskell_stack_build_options*
-                                            *b:ale_haskell_stack_build_options*
-  Type: |String|
-  Default: `'--fast'`
-
-  We default to using `'--fast'`. Since Stack generates binaries, your
-  programs will be slower unless you separately rebuild them outside of ALE.
 
 ===============================================================================
 hdevtools                                               *ale-haskell-hdevtools*
@@ -30,5 +20,17 @@ g:ale_haskell_hdevtools_options               *g:ale_haskell_hdevtools_options*
 
   This variable can be changed to modify flags given to hdevtools.
 
+===============================================================================
+stack-build                                           *ale-haskell-stack-build*
+
+g:ale_haskell_stack_build_options           *g:ale_haskell_stack_build_options*
+                                            *b:ale_haskell_stack_build_options*
+  Type: |String|
+  Default: `'--fast'`
+
+  We default to using `'--fast'`. Since Stack generates binaries, your
+  programs will be slower unless you separately rebuild them outside of ALE.
+
+
 ===============================================================================
   vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-javascript.txt

@@ -60,105 +60,6 @@ g:ale_javascript_eslint_suppress_eslintignore
   the current file due to being covered by `.eslintignore`.
 
 
-===============================================================================
-prettier                                              *ale-javascript-prettier*
-
-g:ale_javascript_prettier_executable     *g:ale_javascript_prettier_executable*
-                                         *b:ale_javascript_prettier_executable*
-  Type: |String|
-  Default: `'prettier'`
-
-  See |ale-integrations-local-executables|
-
-
-g:ale_javascript_prettier_options           *g:ale_javascript_prettier_options*
-                                            *b:ale_javascript_prettier_options*
-  Type: |String|
-  Default: `''`
-
-  This variable can be set to pass additional options to prettier.
-
-
-g:ale_javascript_prettier_use_global     *g:ale_javascript_prettier_use_global*
-                                         *b:ale_javascript_prettier_use_global*
-  Type: |Number|
-  Default: `0`
-
-  See |ale-integrations-local-executables|
-
-
-===============================================================================
-prettier-eslint                                *ale-javascript-prettier-eslint*
-
-ALE supports `prettier-eslint` for easy integration with projects, but it is
-not recommended for new projects. ALE instead recommends configuring
-|g:ale_fixers| to run `'prettier'` and `'eslint'` in a sequence like so: >
-
-  let g:ale_fixers = {'javascript': ['prettier', 'eslint']}
-<
-
-This is because `prettier-eslint` cannot be configured to use the ESLint
-configuration file for input given via stdin, which is how ALE integrates with
-the tool.
-
-g:ale_javascript_prettier_eslint_executable
-                                  *g:ale_javascript_prettier_eslint_executable*
-                                  *b:ale_javascript_prettier_eslint_executable*
-  Type: |String|
-  Default: `'prettier-eslint'`
-
-  See |ale-integrations-local-executables|
-
-
-g:ale_javascript_prettier_eslint_options
-                                     *g:ale_javascript_prettier_eslint_options*
-                                     *b:ale_javascript_prettier_eslint_options*
-  Type: |String|
-  Default: `''`
-
-  This variable can be set to pass additional options to prettier-eslint.
-
-
-g:ale_javascript_prettier_eslint_use_global
-                                  *g:ale_javascript_prettier_eslint_use_global*
-                                  *b:ale_javascript_prettier_eslint_use_global*
-  Type: |Number|
-  Default: `0`
-
-  See |ale-integrations-local-executables|
-
-
-===============================================================================
-prettier-standard                            *ale-javascript-prettier-standard*
-
-
-g:ale_javascript_prettier_standard_executable
-                                *g:ale_javascript_prettier_standard_executable*
-                                *b:ale_javascript_prettier_standard_executable*
-  Type: |String|
-  Default: `'prettier-standard'`
-
-  See |ale-integrations-local-executables|
-
-
-g:ale_javascript_prettier_standard_options
-                                     *g:ale_javascript_prettier_standard_options*
-                                     *b:ale_javascript_prettier_standard_options*
-  Type: |String|
-  Default: `''`
-
-  This variable can be set to pass additional options to prettier-standard.
-
-
-g:ale_javascript_prettier_standard_use_global
-                                  *g:ale_javascript_prettier_standard_use_global*
-                                  *b:ale_javascript_prettier_standard_use_global*
-  Type: |Number|
-  Default: `0`
-
-  See |ale-integrations-local-executables|
-
-
 ===============================================================================
 flow                                                      *ale-javascript-flow*
 
@@ -216,6 +117,117 @@ g:ale_javascript_jshint_use_global         *g:ale_javascript_jshint_use_global*
   See |ale-integrations-local-executables|
 
 
+===============================================================================
+prettier                                              *ale-javascript-prettier*
+
+g:ale_javascript_prettier_executable     *g:ale_javascript_prettier_executable*
+                                         *b:ale_javascript_prettier_executable*
+  Type: |String|
+  Default: `'prettier'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_javascript_prettier_options           *g:ale_javascript_prettier_options*
+                                            *b:ale_javascript_prettier_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to pass additional options to prettier.
+
+
+g:ale_javascript_prettier_use_global     *g:ale_javascript_prettier_use_global*
+                                         *b:ale_javascript_prettier_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+g:ale_javascript_prettier_use_local_config
+                                   *g:ale_javascript_prettier_use_local_config*
+                                   *b:ale_javascript_prettier_use_local_config*
+  Type: |Number|
+  Default: `0`
+
+  This variable can be set to use the local prettier configuration file.
+
+
+===============================================================================
+prettier-eslint                                *ale-javascript-prettier-eslint*
+
+ALE supports `prettier-eslint` >= 4.2.0. Using lower version is not recommended
+because it cannot be configured to use the ESLint configuration file for input
+given via stdin. However ALE could be set up on your own risk with older
+versions with |g:ale_javascript_prettier_eslint_legacy|
+
+g:ale_javascript_prettier_eslint_executable
+                                  *g:ale_javascript_prettier_eslint_executable*
+                                  *b:ale_javascript_prettier_eslint_executable*
+  Type: |String|
+  Default: `'prettier-eslint'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_javascript_prettier_eslint_options
+                                     *g:ale_javascript_prettier_eslint_options*
+                                     *b:ale_javascript_prettier_eslint_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to pass additional options to prettier-eslint.
+
+
+g:ale_javascript_prettier_eslint_use_global
+                                  *g:ale_javascript_prettier_eslint_use_global*
+                                  *b:ale_javascript_prettier_eslint_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+g:ale_javascript_prettier_eslint_legacy
+                                      *g:ale_javascript_prettier_eslint_legacy*
+                                      *b:ale_javascript_prettier_eslint_legacy*
+  Type: |Number|
+  Default: `0`
+
+  Fallback option for `prettier-eslint` < 4.2.0
+
+
+===============================================================================
+prettier-standard                            *ale-javascript-prettier-standard*
+
+
+g:ale_javascript_prettier_standard_executable
+                                *g:ale_javascript_prettier_standard_executable*
+                                *b:ale_javascript_prettier_standard_executable*
+  Type: |String|
+  Default: `'prettier-standard'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_javascript_prettier_standard_options
+                                   *g:ale_javascript_prettier_standard_options*
+                                   *b:ale_javascript_prettier_standard_options*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to pass additional options to prettier-standard.
+
+
+g:ale_javascript_prettier_standard_use_global
+                                *g:ale_javascript_prettier_standard_use_global*
+                                *b:ale_javascript_prettier_standard_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+
+
+
 ===============================================================================
 standard                                              *ale-javascript-standard*
 

doc/ale-json.txt

@@ -0,0 +1,18 @@
+===============================================================================
+ALE JSON Integration                                         *ale-json-options*
+
+
+===============================================================================
+jsonlint                                                    *ale-json-jsonlint*
+
+There are no options available.
+
+
+===============================================================================
+prettier                                                    *ale-json-prettier*
+
+See |ale-javascript-prettier| for information about the available options.
+
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-less.txt

@@ -0,0 +1,12 @@
+===============================================================================
+ALE Less Integration                                         *ale-less-options*
+
+
+===============================================================================
+prettier                                                    *ale-less-prettier*
+
+See |ale-javascript-prettier| for information about the available options.
+
+
+===============================================================================
+

doc/ale-llvm.txt

@@ -0,0 +1,19 @@
+===============================================================================
+ALE LLVM Integration                                         *ale-llvm-options*
+
+
+===============================================================================
+llc                                                              *ale-llvm-llc*
+
+g:ale_llvm_llc_executable                           *g:ale_llvm_llc_executable*
+                                                    *b:ale_llvm_llc_executable*
+
+  Type: |String|
+  Default: "llc"
+
+  The command to use for checking. This variable is useful when llc command
+  has suffix like "llc-5.0".
+
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-lua.txt

@@ -3,7 +3,7 @@ ALE Lua Integration                                           *ale-lua-options*
 
 
 ===============================================================================
-4.12. luacheck                                               *ale-lua-luacheck*
+luacheck                                                     *ale-lua-luacheck*
 
 g:ale_lua_luacheck_executable                   *g:ale_lua_luacheck_executable*
                                                 *b:ale_lua_luacheck_executable*

doc/ale-php.txt

@@ -35,67 +35,6 @@ g:ale_php_langserver_use_global               *g:ale_php_langserver_use_global*
 
 
 ===============================================================================
-phpcs                                                           *ale-php-phpcs*
-
-g:ale_php_phpcs_executable                         *g:ale_php_phpcs_executable*
-                                                   *b:ale_php_phpcs_executable*
-  Type: |String|
-  Default: `'phpcs'`
-
-  See |ale-integrations-local-executables|
-
-
-g:ale_php_phpcs_standard                             *g:ale_php_phpcs_standard*
-                                                     *b:ale_php_phpcs_standard*
-  Type: |String|
-  Default: `''`
-
-  This variable can be set to specify the coding standard used by phpcs. If no
-  coding standard is specified, phpcs will default to checking against the
-  PEAR coding standard, or the standard you have set as the default.
-
-
-g:ale_php_phpcs_use_global                         *g:ale_php_phpcs_use_global*
-                                                   *b:ale_php_phpcs_use_global*
-  Type: |Number|
-  Default: `0`
-
-  See |ale-integrations-local-executables|
-
-
--------------------------------------------------------------------------------
-phpmd                                                           *ale-php-phpmd*
-
-g:ale_php_phpmd_ruleset                               *g:ale_php_phpmd_ruleset*
-                                                      *b:ale_php_phpmd_ruleset*
-  Type: |String|
-  Default: `'cleancode,codesize,controversial,design,naming,unusedcode'`
-
-  This variable controls the ruleset used by phpmd. Default is to use all of
-  the available phpmd rulesets
-
-
--------------------------------------------------------------------------------
-phpstan                                                       *ale-php-phpstan*
-
-g:ale_php_phpstan_executable                     *g:ale_php_phpstan_executable*
-                                                 *b:ale_php_phpstan_executable*
-  Type: |String|
-  Default: `'phpstan'`
-
-  This variable sets executable used for phpstan.
-
-
-g:ale_php_phpstan_level                               *g:ale_php_phpstan_level*
-                                                      *b:ale_php_phpstan_level*
-  Type: |Number|
-  Default: `4`
-
-  This variable controls the rule levels. 0 is the loosest and 4 is the
-  strictest.
-
-
--------------------------------------------------------------------------------
 phpcbf                                                         *ale-php-phpcbf*
 
 g:ale_php_phpcbf_executable                       *g:ale_php_phpcbf_executable*
@@ -124,5 +63,74 @@ g:ale_php_phpcbf_use_global                       *g:ale_php_phpcbf_use_global*
   See |ale-integrations-local-executables|
 
 
+===============================================================================
+phpcs                                                           *ale-php-phpcs*
+
+g:ale_php_phpcs_executable                         *g:ale_php_phpcs_executable*
+                                                   *b:ale_php_phpcs_executable*
+  Type: |String|
+  Default: `'phpcs'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_php_phpcs_standard                             *g:ale_php_phpcs_standard*
+                                                     *b:ale_php_phpcs_standard*
+  Type: |String|
+  Default: `''`
+
+  This variable can be set to specify the coding standard used by phpcs. If no
+  coding standard is specified, phpcs will default to checking against the
+  PEAR coding standard, or the standard you have set as the default.
+
+
+g:ale_php_phpcs_use_global                         *g:ale_php_phpcs_use_global*
+                                                   *b:ale_php_phpcs_use_global*
+  Type: |Number|
+  Default: `0`
+
+  See |ale-integrations-local-executables|
+
+
+===============================================================================
+phpmd                                                           *ale-php-phpmd*
+
+g:ale_php_phpmd_ruleset                               *g:ale_php_phpmd_ruleset*
+                                                      *b:ale_php_phpmd_ruleset*
+  Type: |String|
+  Default: `'cleancode,codesize,controversial,design,naming,unusedcode'`
+
+  This variable controls the ruleset used by phpmd. Default is to use all of
+  the available phpmd rulesets
+
+
+===============================================================================
+phpstan                                                       *ale-php-phpstan*
+
+g:ale_php_phpstan_executable                     *g:ale_php_phpstan_executable*
+                                                 *b:ale_php_phpstan_executable*
+  Type: |String|
+  Default: `'phpstan'`
+
+  This variable sets executable used for phpstan.
+
+
+g:ale_php_phpstan_level                               *g:ale_php_phpstan_level*
+                                                      *b:ale_php_phpstan_level*
+  Type: |Number|
+  Default: `4`
+
+  This variable controls the rule levels. 0 is the loosest and 4 is the
+  strictest.
+
+
+g:ale_php_phpstan_configuration               *g:ale_php_phpstan_configuration*
+                                              *b:ale_php_phpstan_configuration*
+  Type: |String|
+  Default: `''`
+
+  This variable sets path to phpstan configuration file.
+
+
 ===============================================================================
   vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-r.txt

@@ -0,0 +1,20 @@
+===============================================================================
+ALE R Integration                                               *ale-r-options*
+
+
+===============================================================================
+lintr                                                             *ale-r-lintr*
+
+g:ale_r_lintr_options                                   *g:ale_r_lintr_options*
+                                                        *b:ale_r_lintr_options*
+  Type: |String|
+  Default: `'lintr::with_defaults()'`
+
+  This option can be configured to change the options for lintr.
+
+  The value of this option will be run with `eval` for the `lintr::lint`
+  options. Consult the lintr documentation for more information.
+
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-rust.txt

@@ -20,7 +20,7 @@ Integration Information
      while you type.
   3. rls -- If you have `rls` installed, you might prefer using this linter
      over cargo. rls implements the Language Server Protocol for incremental
-     compliation of Rust code, and can check Rust files while you type. `rls`
+     compilation of Rust code, and can check Rust files while you type. `rls`
      requires Rust files to contained in Cargo projects.
 
   Only cargo is enabled by default. To switch to using rustc instead of cargo,

doc/ale-scala.txt

@@ -5,14 +5,28 @@ ALE Scala Integration                                       *ale-scala-options*
 ===============================================================================
 scalastyle                                               *ale-scala-scalastyle*
 
+`scalastyle` requires a configuration file for a project to run. When no
+configuration file can be found, ALE will report a problem saying that a
+configuration file is required at line 1.
+
+To disable `scalastyle` globally, use |g:ale_linters| like so: >
+  let g:ale_linters = {'scala': ['scalac']} " Enable only scalac instead
+<
+
+See |g:ale_linters| for more information on disabling linters.
+
+
 g:ale_scalastyle_config_loc                       *g:ale_scalastyle_config_loc*
 
   Type: |String|
   Default: `''`
 
-  A string containing the location of a global fallback config file.
-  By default, ALE will look for a config file named `scalastyle_config.xml` or
-  `scalastyle-config.xml` in the current file's directory or parent directories.
+  A string containing the location of a global fallback configuration file.
+
+  By default, ALE will look for a configuration file named
+  `scalastyle_config.xml` or `scalastyle-config.xml` in the current file's
+  directory or parent directories.
+
 
 g:ale_scala_scalastyle_options                 *g:ale_scala_scalastyle_options*
 
@@ -21,5 +35,6 @@ g:ale_scala_scalastyle_options                 *g:ale_scala_scalastyle_options*
 
   A string containing additional options to pass to scalastyle.
 
+
 ===============================================================================
   vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-scss.txt

@@ -2,6 +2,12 @@
 ALE SCSS Integration                                         *ale-scss-options*
 
 
+===============================================================================
+prettier                                                    *ale-scss-prettier*
+
+See |ale-javascript-prettier| for information about the available options.
+
+
 ===============================================================================
 stylelint                                                  *ale-scss-stylelint*
 

doc/ale-sml.txt

@@ -0,0 +1,36 @@
+===============================================================================
+ALE SML Integration                                           *ale-sml-options*
+
+===============================================================================
+smlnj                                                           *ale-sml-smlnj*
+                                                             *ale-sml-smlnj-cm*
+
+There are two SML/NJ powered checkers:
+
+- one using Compilation Manager that works on whole projects, but requires you
+  to save before errors show up
+- one using the SML/NJ REPL that works as you change the text, but might fail
+  if your project can only be built with CM.
+
+We dynamically select which one to use based whether we find a `*.cm` file at
+or above the directory of the file being checked. Only one checker (`smlnj`,
+`smlnj-cm`) will be enabled at a time.
+
+-------------------------------------------------------------------------------
+
+g:ale_sml_smlnj_cm_file                               *g:ale_sml_smlnj_cm_file*
+                                                      *b:ale_sml_smlnj_cm_file*
+  Type: |String|
+  Default: `'*.cm'`
+
+  By default, ALE will look for a `*.cm` file in your current directory,
+  searching upwards. It stops when it finds at least one `*.cm` file (taking
+  the first file if there are more than one).
+
+  Change this option (in the buffer or global scope) to control how ALE finds
+  CM files. For example, to always search for a CM file named `sandbox.cm`:
+>
+      let g:ale_sml_smlnj_cm_file = 'sandbox.cm'
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-solidity.txt

@@ -0,0 +1,16 @@
+===============================================================================
+ALE Solidity Integration                                 *ale-solidity-options*
+
+
+===============================================================================
+solium                                                    *ale-solidity-solium*
+
+  Use of Solium linter for Solidity source code requires a .soliumrc.json
+  file in project root. This file can be generated by running `solium --init`.
+  See the corresponding solium usage for detailed instructions
+  (https://github.com/duaraghav8/Solium#usage).
+
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:
+

doc/ale-spec.txt

@@ -1,5 +1,5 @@
 ===============================================================================
-ALE RPM Spec Integration                                     *ale-spec-options*
+ALE Spec Integration                                         *ale-spec-options*
                                                          *ale-integration-spec*
 
 ===============================================================================

doc/ale-stylus.txt

@@ -1,5 +1,5 @@
 ===============================================================================
-ALE CSS Integration                                        *ale-stylus-options*
+ALE Stylus Integration                                     *ale-stylus-options*
 
 
 ===============================================================================

doc/ale-thrift.txt

@@ -0,0 +1,46 @@
+===============================================================================
+ALE Thrift Integration                                     *ale-thrift-options*
+
+
+===============================================================================
+thrift                                                      *ale-thrift-thrift*
+
+The `thrift` linter works by compiling the buffer's contents and reporting any
+errors reported by the parser and the configured code generator(s).
+
+g:ale_thrift_thrift_executable                 *g:ale_thrift_thrift_executable*
+                                               *b:ale_thrift_thrift_executable*
+  Type: |String|
+  Default: `'thrift'`
+
+  See |ale-integrations-local-executables|
+
+
+g:ale_thrift_thrift_generators                 *g:ale_thrift_thrift_generators*
+                                               *b:ale_thrift_thrift_generators*
+  Type: |List| of |String|s
+  Default: `['cpp']`
+
+  This list must contain one or more named code generators. Generator options
+  can be included as part of each string, e.g. `['py:dynamic']`.
+
+
+g:ale_thrift_thrift_includes                     *g:ale_thrift_thrift_includes*
+                                                 *b:ale_thrift_thrift_includes*
+  Type: |List| of |String|s
+  Default: `[]`
+
+  This list contains paths that will be searched for thrift `include`
+  directives.
+
+
+g:ale_thrift_thrift_options                       *g:ale_thrift_thrift_options*
+                                                  *b:ale_thrift_thrift_options*
+  Type: |String|
+  Default: `'-strict'`
+
+  This variable can be changed to customize the additional command-line
+  arguments that are passed to the thrift compiler.
+
+===============================================================================
+  vim:tw=78:ts=2:sts=2:sw=2:ft=help:norl:

doc/ale-typescript.txt

@@ -10,6 +10,12 @@ the two languages are, the `eslint` linter for TypeScript uses the JavaScript
 options for `eslint` too. See: |ale-javascript-eslint|.
 
 
+===============================================================================
+prettier                                              *ale-typescript-prettier*
+
+See |ale-javascript-prettier| for information about the available options.
+
+
 ===============================================================================
 tslint                                                  *ale-typescript-tslint*
 
@@ -30,6 +36,26 @@ g:ale_typescript_tslint_config_path       *g:ale_typescript_tslint_config_path*
   such path exists, this variable will be used instead.
 
 
+g:ale_typescript_tslint_ignore_empty_files
+                                   *g:ale_typescript_tslint_ignore_empty_files*
+                                   *b:ale_typescript_tslint_ignore_empty_files*
+  Type: |Number|
+  Default: `0`
+
+  When set to `1`, ALE will not report any problems for empty files with
+  TSLint. ALE will still execute TSLint for the files, but ignore any problems
+  reported. This stops ALE from complaining about newly created files,
+  and files where lines have been added and then removed.
+
+
+g:ale_typescript_tslint_rules_dir           *g:ale_typescript_tslint_rules_dir*
+                                            *b:ale_typescript_tslint_rules_dir*
+  Type: |String|
+  Default: `''`
+
+  If this variable is set, ALE will use it as the rules directory for tslint.
+
+
 g:ale_typescript_tslint_use_global         *g:ale_typescript_tslint_use_global*
                                            *b:ale_typescript_tslint_use_global*
   Type: |Number|