Fix #1298 - Escape commands for PowerShell

fixed rust errors parsing

.gitattributes

@@ -2,7 +2,6 @@
 /CODE_OF_CONDUCT.md export-ignore
 /CONTRIBUTING.md export-ignore
 /Dockerfile export-ignore
-/ISSUE_TEMPLATE export-ignore
 /ISSUE_TEMPLATE.md export-ignore
 /Makefile export-ignore
 /PULL_REQUEST_TEMPLATE.md export-ignore

.github/ISSUE_TEMPLATE/report-a-bug.md

@@ -1,40 +0,0 @@
----
-name: Report a bug
-about: Report a bug with ALE.
-
----
-
-<!--
-  This is the template for reporting ALE bugs. Make sure you try updating ALE
-  to a more recent version before reporting a bug. Look through existing bug
-  reports for similar issues before reporting a new one. Don't leave comments
-  about new bugs in the comment section for old issues.
-
-  Make sure to try disabling other plugins and trying to repeat your bug before
-  reporting it in ALE. Some times problems can arise when two plugins are used
-  together, but often your issues might be problems with other plugins.
--->
-
-## Information
-
-**VIM version**
-
-<!-- Paste just the first two lines of :version here. -->
-
-Operating System: <!-- Describe your operating system version. -->
-
-### :ALEInfo
-
-<!-- Paste the output of :ALEInfo here. Try :ALEInfoToClipboard -->
-<!-- Make sure to run :ALEInfo from the buffer where the bug occurred. -->
-
-## What went wrong
-
-<!-- Describe what went wrong here. -->
-
-## Reproducing the bug
-
-<!-- Write a list of steps below. -->
-
-1. I did this.
-2. Then this happened.

.github/ISSUE_TEMPLATE/suggest-a-new-linter-or-fixer.md

@@ -1,20 +0,0 @@
----
-name: Suggest a new linter or fixer
-about: Suggest a new tool ALE can officially integrate with.
-
----
-
-<!--
-  Write "Add support for foobar" as the issue title, or similar.
-
-  Fill out the details below.
--->
-
-**Name:** foobar
-**URL:** https://foo.bar.com
-
-<!--
-  Write a description of the tool, and add any other information you think might
-  be helpful. Consider creating a pull request to add support for the tool
-  yourself.
--->

.github/ISSUE_TEMPLATE/suggest-an-improvement.md

@@ -1,7 +0,0 @@
----
-name: Suggest an improvement
-about: Suggest some way to improve ALE, or add a new feature.
-
----
-
-<!-- There's no fixed format for feature requests. Just add your thoughts. -->

.gitignore

@@ -1,7 +1,6 @@
+/init.vim
+/doc/tags
+.*
 !.editorconfig
 *.obj
-.*
-/doc/tags
-/init.vim
-/test/ale-info-test-file
 tags

.travis.yml

@@ -2,6 +2,6 @@
 sudo: required
 services:
     - docker
-language: generic
+language: python
 script: |
-    ./run-tests -v
+    ./run-tests

CONTRIBUTING.md

@@ -1,11 +1,37 @@
-## Guidelines
+# Contributing to ALE
+
+1. [Guidelines](#guidelines)
+2. [Creating Issues](#issues)
+3. [Creating Pull Requests](#pull-requests)
+    1. [Adding a New Linter](#adding-a-new-linter)
+    2. [Adding New Options](#adding-new-options)
+4. [Writing Documentation](#writing-documentation)
+    1. [Documenting New Linters](#documenting-new-linters)
+    2. [Editing the Online Documentation](#editing-online-documentation)
+    3. [Documenting Linter Options](#documenting-linter-options)
+5. [In Case of Busses](#in-case-of-busses)
+
+<a name="guidelines"></a>
+
+## 1. Guidelines
 
 Have fun, and work on whatever floats your boat. Take It Easy :tm:.
 
-For help with contributing to ALE, see `:help ale-development` in Vim, or view
+Don't forget to **write documentation** for whatever it is you are doing.
-the help file online [here](/w0rp/ale/blob/master/doc/ale-development.txt).
+See the ["Writing Documentation"](#writing-documentation) section.
 
-## Creating Issues
+Remember to write Vader tests for most of the code you write. You can look at
+existing Vader tests in the `test` directory for examples.
+
+When writing code, follow the [Google Vimscript Style
+Guide](https://google.github.io/styleguide/vimscriptguide.xml), and run `vint
+-s` on your files to check for most of what the guide mentions and more. If you
+install this plugin (ALE) and install [Vint](https://github.com/Kuniwak/vint), it
+will check your code while you type.
+
+<a name="issues"></a>
+
+## 2. Creating Issues
 
 Before creating any issues, please look through the current list of issues and
 pull requests, and ensure that the issue hasn't already been reported. If an
@@ -23,3 +49,125 @@ operating system, or any other information you think might be helpful.
 Please describe your issue in clear, grammatically correct, and easy to
 understand English. You are more likely to see an issue resolved if others
 can understand you.
+
+<a name="pull-requests"></a>
+
+## 3. Creating Pull Requests
+
+For code you write, make sure to credit yourself at the top of files you add,
+and probably those you modify. You can write some comments at the top of your
+VIM files.
+
+```vim
+" Author: John Smith <john.smith@gmail.com>
+" Description: This file adds support for awesomelinter for the best language ever.
+```
+
+If you want to credit multiple authors, you can comma separate them.
+
+```vim
+" Author: John Smith <john.smith@gmail.com>, Jane Doe <https://jane-doe.info>
+```
+
+<a name="adding-a-new-linter"></a>
+
+### 3.i. Adding a New Linter
+
+If you add a new linter, look for existing handlers first in the
+[handlers](autoload/ale/handlers) directory. One of the handlers there may
+already be able to handle your lines of output. If you find that your new
+linter replicates an existing error handler, consider pulling it up into the
+[handlers](autoload/ale/handlers) directory, and use the generic handler in
+both places.
+
+When you add a linter, make sure the language for the linter and the linter
+itself are present in the table in the [README.md](README.md) file and in the
+Vim [help file](doc/ale.txt). The programs and linters should be sorted
+alphabetically in the table and list.
+
+<a name="adding-new-options"></a>
+
+### 3.ii. Adding New Options
+
+If you add new options to the plugin, make sure to document those new options
+in the [README.md](README.md) file, and also in the [help file](doc/ale.txt).
+Follow the format of other options in each. Global options should appear in the
+README file, and in the relevant section in the help file. Options specific
+to a particular linter should appear in the section for that linter.
+
+Linter options for customizing general argument lists should be named
+`g:ale_<filetype>_<linter>_options`, so that all linters can have similar
+global variable names.
+
+Any options for linters should be set to some default value so it is always
+easy to see what the default is with `:echo g:ale...`.
+
+<a name="writing-documentation"></a>
+
+## 4. Writing Documentation
+
+If you are adding new linters, changing the API, adding new options, etc., you
+_must_ write some documentation describing it in the `doc/ale.txt` file.  New
+linters _must_ be added to the `README.md` file too, so other users can get a
+quick overview of the supported tools.
+
+<a name="documenting-new-linters"></a>
+
+### 4.i Documenting New Linters
+
+If you add a new linter to the project, edit the table in the `README.md` file,
+and edit the list of linters at the top of the `doc/ale.txt` file. The linters
+should be sorted vertically in lexicographic (alphabetical) order by the
+programming language name or filetype, and the tools for each language should
+be sorted in lexicographic order horizontally. Sorting in this manner is a fair
+manner of presenting all of the information in an easy to scan way, without
+giving some unfair preference to any particular tool or language.
+
+<a name="editing-online-documentation"></a>
+
+### 4.ii Editing the Online Documentation
+
+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 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.
+3. Sections should have a _single_ blank line before or after.
+4. Between descriptions of variables/functions/commands, use _two_ blank lines.
+5. Up-indent the description of a variable/function/command by two spaces.
+6. Place tags at the ends of lines, with the final characters on column 79.
+   All of the tags should line up perfectly on the same column as you scan
+   down through the document.
+7. Keep the table of contents balanced so the longest tag link ends on column
+   79, and so all links line up perfectly on their first character, on the
+   left.
+
+<a name="documenting-linter-options"></a>
+
+### 4.iii Documenting Linter Options
+
+For documenting new linter options, please add a new sub-section under the
+"Linter Specific Options" section describing all of the global options added
+for each linter, and what the default values of the options are. All global
+options for linters should be set to some default value. This will allow users
+to look up the default value easily by typing `:echo g:ale_...`.
+
+<a name="in-case-of-busses"></a>
+
+## 5. In Case of Busses
+
+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 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
+original, and life will go on, except the life of whoever vanished, because
+then they will probably be dead.
+
+Should w0rp suddenly disappear, then he was probably killed in a traffic
+accident, or the government finally decided to kill him and make it look like
+suicide. In the latter event, please subvert said government and restore
+order to the universe, and ensure peace for mankind.

Dockerfile

@@ -1,8 +1,7 @@
 FROM tweekmonster/vim-testbed:latest
 
 RUN install_vim -tag v8.0.0027 -build \
-                -tag neovim:v0.2.0 -build \
+                -tag neovim:v0.1.7 -build
-                -tag neovim:v0.3.0 -build
 
 ENV PACKAGES="\
     bash \
@@ -13,7 +12,7 @@ ENV PACKAGES="\
 RUN apk --update add $PACKAGES && \
     rm -rf /var/cache/apk/* /tmp/* /var/tmp/*
 
-RUN pip install vim-vint==0.3.15
+RUN pip install vim-vint==0.3.9
 
 RUN git clone https://github.com/junegunn/vader.vim vader && \
     cd vader && git checkout c6243dd81c98350df4dec608fa972df98fa2a3af

ISSUE_TEMPLATE.md

@@ -0,0 +1,28 @@
+<!--
+    This is a template for bug reports. If you want to request a new feature,
+    you can clear this entire form field and write a short description of what
+    you want.
+-->
+
+## Information
+
+**VIM version**
+
+PASTE JUST THE FIRST TWO LINES OF `:version` HERE.
+
+Operating System: WHAT OS WERE YOU USING?
+
+### :ALEInfo
+
+PASTE OUTPUT OF `:ALEInfo` HERE. YOU CAN TRY `:ALEInfoToClipboard`.
+
+## What went wrong
+
+WRITE WHAT WENT WRONG HERE.
+
+## Reproducing the bug
+
+Steps for repeating the bug:
+
+1. Write a list of steps.
+2. Otherwise nobody will fix the bug.

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016-2018, w0rp <devw0rp@gmail.com>
+Copyright (c) 2016-2017, w0rp <devw0rp@gmail.com>
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

PULL_REQUEST_TEMPLATE.md

@@ -1,8 +1,21 @@
 <!--
-Before creating a pull request, do the following.
+READ THIS: Before creating a pull request, please consider the following first.
 
+* The most important thing you can do is write tests. Code without tests
+  probably doesn't work, and will almost certainly stop working later on. Pull
+  requests without tests probably won't be accepted, although there are some
+  exceptions.
 * Read the Contributing guide linked above first.
-* Read the documentation that comes with ALE with `:help ale-development`.
+* If you are adding a new linter, remember to update the README.md file and
-
+  doc/ale.txt first.
-Have fun!
+* If you add or modify a function for converting error lines into loclist items
+  that ALE can work with, please add Vader tests for them. Look at existing
+  tests in the test/handler directory, etc.
+* If you add or modify a function for computing a command line string for
+  running a command, please add Vader tests for that.
+* Generally try and cover anything with Vader tests, although some things just
+  can't be tested with Vader, or at least they can be hard to test. Consider
+  breaking up your code so that some parts can be tested, and generally open up
+  a discussion about it.
+* Have fun!
 -->

README.md

@@ -1,10 +1,10 @@
-# Asynchronous Lint Engine [![Travis CI Build Status](https://travis-ci.org/w0rp/ale.svg?branch=master)](https://travis-ci.org/w0rp/ale) [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/r0ef1xu8xjmik58d/branch/master?svg=true)](https://ci.appveyor.com/project/w0rp/ale)
+# 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)
 
 ALE (Asynchronous Lint Engine) is a plugin for providing linting in NeoVim
-0.2.0+ and Vim 8 while you edit your text files.
+and Vim 8 while you edit your text files.
 
 ![linting example](img/example.gif?raw=true)
 
@@ -16,22 +16,8 @@ back to a filesystem.
 
 In other words, this plugin allows you to lint while you type.
 
-ALE offers support for fixing code with command line tools in a non-blocking
+In addition to linting support, ALE offers some support for fixing code with
-manner with the `:ALEFix` feature, supporting tools in many languages, like
+formatting tools, and some Language Server Protocol and `tsserver` features.
-`prettier`, `eslint`, `autopep8`, and more.
-
-ALE acts as a "language client" to support a variety of Language Server Protocol
-features, including:
-
-* Diagnostics (via Language Server Protocol linters)
-* Go To Definition (`:ALEGoToDefinition`)
-* Completion (`let g:ale_completion_enabled = 1`)
-* Finding references (`:ALEFindReferences`)
-* Hover information (`:ALEHover`)
-
-If you don't care about Language Server Protocol, ALE won't load any of the code
-for working with it unless needed. One of ALE's general missions is that you
-won't pay for the features that you don't use.
 
 ## Table of Contents
 
@@ -41,8 +27,6 @@ won't pay for the features that you don't use.
     2. [Fixing](#usage-fixing)
     3. [Completion](#usage-completion)
     4. [Go To Definition](#usage-go-to-definition)
-    5. [Find References](#usage-find-references)
-    6. [Hovering](#usage-hover)
 3. [Installation](#installation)
     1. [Installation with Vim package management](#standard-installation)
     2. [Installation with Pathogen](#installation-with-pathogen)
@@ -64,7 +48,6 @@ won't pay for the features that you don't use.
     13. [Will this plugin eat all of my laptop battery power?](#faq-my-battery-is-sad)
     14. [How can I configure my C or C++ project?](#faq-c-configuration)
     15. [How can I configure ALE differently for different buffers?](#faq-buffer-configuration)
-    16. [How can I configure the height of the list in which ALE displays errors?](#faq-list-window-height)
 
 <a name="supported-languages"></a>
 
@@ -94,82 +77,72 @@ formatting.
 | API Blueprint | [drafter](https://github.com/apiaryio/drafter) |
 | AsciiDoc | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [write-good](https://github.com/btford/write-good) |
 | Awk | [gawk](https://www.gnu.org/software/gawk/)|
-| Bash | [language-server](https://github.com/mads-hartmann/bash-language-server), shell [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/), [shfmt](https://github.com/mvdan/sh) |
+| Bash | shell [-n flag](https://www.gnu.org/software/bash/manual/bash.html#index-set), [shellcheck](https://www.shellcheck.net/), [shfmt](https://github.com/mvdan/sh) |
 | Bourne Shell | shell [-n flag](http://linux.die.net/man/1/sh), [shellcheck](https://www.shellcheck.net/), [shfmt](https://github.com/mvdan/sh) |
-| C | [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint), [clang](http://clang.llvm.org/), [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html), [flawfinder](https://www.dwheeler.com/flawfinder/), [gcc](https://gcc.gnu.org/) |
+| 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/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html), [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint) !!, [cquery](https://github.com/cquery-project/cquery), [flawfinder](https://www.dwheeler.com/flawfinder/), [gcc](https://gcc.gnu.org/) |
+| C++ (filetype cpp) | [clang](http://clang.llvm.org/), [clangcheck](http://clang.llvm.org/docs/ClangCheck.html) !!, [clangtidy](http://clang.llvm.org/extra/clang-tidy/) !!, [clang-format](https://clang.llvm.org/docs/ClangFormat.html), [cppcheck](http://cppcheck.sourceforge.net), [cpplint](https://github.com/google/styleguide/tree/gh-pages/cpplint) !!, [gcc](https://gcc.gnu.org/) |
 | 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/) |
 | Clojure | [joker](https://github.com/candid82/joker) |
-| CloudFormation | [cfn-python-lint](https://github.com/awslabs/cfn-python-lint) |
 | CMake | [cmakelint](https://github.com/richq/cmake-lint) |
 | CoffeeScript | [coffee](http://coffeescript.org/), [coffeelint](https://www.npmjs.com/package/coffeelint) |
 | Crystal | [crystal](https://crystal-lang.org/) !! |
 | CSS | [csslint](http://csslint.net/), [prettier](https://github.com/prettier/prettier), [stylelint](https://github.com/stylelint/stylelint) |
-| Cucumber | [cucumber](https://cucumber.io/) |
 | Cython (pyrex filetype) | [cython](http://cython.org/) |
 | D | [dmd](https://dlang.org/dmd-linux.html) |
 | Dafny | [dafny](https://rise4fun.com/Dafny) !! |
-| Dart | [dartanalyzer](https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_cli) !!, [language_server](https://github.com/natebosch/dart_language_server), [dartfmt](https://github.com/dart-lang/sdk/tree/master/utils/dartfmt) |
+| Dart | [dartanalyzer](https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_cli) !!, [language_server](https://github.com/natebosch/dart_language_server) |
-| Dockerfile | [hadolint](https://github.com/hadolint/hadolint) |
+| Dockerfile | [hadolint](https://github.com/lukasmartinelli/hadolint) |
-| Elixir | [credo](https://github.com/rrrene/credo), [dialyxir](https://github.com/jeremyjh/dialyxir), [dogma](https://github.com/lpil/dogma), [mix](https://hexdocs.pm/mix/Mix.html) !!|
+| 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://apidock.com/ruby/ERB), [erubi](https://github.com/jeremyevans/erubi), [erubis](https://github.com/kwatch/erubis) |
+| 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) |
-| Fish | fish [-n flag](https://linux.die.net/man/1/fish)
 | Fortran | [gcc](https://gcc.gnu.org/) |
-| Fountain | [proselint](http://proselint.com/) |
 | FusionScript | [fusion-lint](https://github.com/RyanSquared/fusionscript) |
-| Git Commit Messages | [gitlint](https://github.com/jorisroovers/gitlint) |
 | GLSL | [glslang](https://github.com/KhronosGroup/glslang), [glslls](https://github.com/svenstaro/glsl-language-server) |
-| Go | [gofmt](https://golang.org/cmd/gofmt/), [goimports](https://godoc.org/golang.org/x/tools/cmd/goimports), [go vet](https://golang.org/cmd/vet/) !!, [golint](https://godoc.org/github.com/golang/lint), [gotype](https://godoc.org/golang.org/x/tools/cmd/gotype) !!, [gometalinter](https://github.com/alecthomas/gometalinter) !!, [go build](https://golang.org/cmd/go/) !!, [gosimple](https://github.com/dominikh/go-tools/tree/master/cmd/gosimple) !!, [staticcheck](https://github.com/dominikh/go-tools/tree/master/cmd/staticcheck) !! |
+| Go | [gofmt](https://golang.org/cmd/gofmt/), [goimports](https://godoc.org/golang.org/x/tools/cmd/goimports), [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 | [eslint](http://eslint.org/), [gqlint](https://github.com/happylinks/gqlint), [prettier](https://github.com/prettier/prettier) |
+| GraphQL | [eslint](http://eslint.org/), [gqlint](https://github.com/happylinks/gqlint) |
 | Haml | [haml-lint](https://github.com/brigade/haml-lint) |
 | Handlebars | [ember-template-lint](https://github.com/rwjblue/ember-template-lint) |
 | Haskell | [brittany](https://github.com/lspitzner/brittany), [ghc](https://www.haskell.org/ghc/), [stack-ghc](https://haskellstack.org/), [stack-build](https://haskellstack.org/) !!, [ghc-mod](https://github.com/DanielG/ghc-mod), [stack-ghc-mod](https://github.com/DanielG/ghc-mod), [hlint](https://hackage.haskell.org/package/hlint), [hdevtools](https://hackage.haskell.org/package/hdevtools), [hfmt](https://github.com/danstiner/hfmt) |
 | HTML | [alex](https://github.com/wooorm/alex) !!, [HTMLHint](http://htmlhint.com/), [proselint](http://proselint.com/), [tidy](http://www.html-tidy.org/), [write-good](https://github.com/btford/write-good) |
 | Idris | [idris](http://www.idris-lang.org/) |
-| Java | [checkstyle](http://checkstyle.sourceforge.net), [javac](http://www.oracle.com/technetwork/java/javase/downloads/index.html), [google-java-format](https://github.com/google/google-java-format), [PMD](https://pmd.github.io/) |
+| Java | [checkstyle](http://checkstyle.sourceforge.net), [javac](http://www.oracle.com/technetwork/java/javase/downloads/index.html), [google-java-format](https://github.com/google/google-java-format) |
-| JavaScript | [eslint](http://eslint.org/), [flow](https://flowtype.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [prettier](https://github.com/prettier/prettier), [prettier-eslint](https://github.com/prettier/prettier-eslint-cli), [prettier-standard](https://github.com/sheerun/prettier-standard), [standard](http://standardjs.com/), [xo](https://github.com/sindresorhus/xo)
+| JavaScript | [eslint](http://eslint.org/), [flow](https://flowtype.org/), [jscs](http://jscs.info/), [jshint](http://jshint.com/), [prettier](https://github.com/prettier/prettier), [prettier-eslint](https://github.com/prettier/prettier-eslint), [prettier-standard](https://github.com/sheerun/prettier-standard), [standard](http://standardjs.com/), [xo](https://github.com/sindresorhus/xo)
-| JSON | [fixjson](https://github.com/rhysd/fixjson), [jsonlint](http://zaa.ch/jsonlint/), [jq](https://stedolan.github.io/jq/), [prettier](https://github.com/prettier/prettier) |
+| 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 | [alex](https://github.com/wooorm/alex) !!, [chktex](http://www.nongnu.org/chktex/), [lacheck](https://www.ctan.org/pkg/lacheck), [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | Less | [lessc](https://www.npmjs.com/package/less), [prettier](https://github.com/prettier/prettier), [stylelint](https://github.com/stylelint/stylelint) |
 | LLVM | [llc](https://llvm.org/docs/CommandGuide/llc.html) |
-| Lua | [luac](https://www.lua.org/manual/5.1/luac.html), [luacheck](https://github.com/mpeterv/luacheck) |
+| Lua | [luacheck](https://github.com/mpeterv/luacheck) |
 | Mail | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale) |
 | Make | [checkmake](https://github.com/mrtazz/checkmake) |
-| Markdown | [alex](https://github.com/wooorm/alex) !!, [markdownlint](https://github.com/DavidAnson/markdownlint) !!, [mdl](https://github.com/mivok/markdownlint), [prettier](https://github.com/prettier/prettier), [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [remark-lint](https://github.com/wooorm/remark-lint) !!, [textlint](https://textlint.github.io/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
+| Markdown | [alex](https://github.com/wooorm/alex) !!, [mdl](https://github.com/mivok/markdownlint), [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [remark-lint](https://github.com/wooorm/remark-lint) !!, [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | MATLAB | [mlint](https://www.mathworks.com/help/matlab/ref/mlint.html) |
-| Mercury | [mmc](http://mercurylang.org) !! |
-| NASM | [nasm](https://www.nasm.us/) !! |
 | Nim | [nim check](https://nim-lang.org/docs/nimc.html) !! |
 | nix | [nix-instantiate](http://nixos.org/nix/manual/#sec-nix-instantiate) |
 | nroff | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good)|
 | Objective-C | [clang](http://clang.llvm.org/) |
 | Objective-C++ | [clang](http://clang.llvm.org/) |
 | OCaml | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-ocaml-merlin` for configuration instructions, [ols](https://github.com/freebroccolo/ocaml-language-server) |
-| Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic), [perltidy](https://metacpan.org/pod/distribution/Perl-Tidy/bin/perltidy) |
+| Perl | [perl -c](https://perl.org/), [perl-critic](https://metacpan.org/pod/Perl::Critic) |
-| PHP | [hack](http://hacklang.org/), [hackfmt](https://github.com/facebook/flow/tree/master/hack/hackfmt), [langserver](https://github.com/felixfbecker/php-language-server), [phan](https://github.com/phan/phan) see `:help ale-php-phan` to instructions, [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer), [phpmd](https://phpmd.org), [phpstan](https://github.com/phpstan/phpstan), [phpcbf](https://github.com/squizlabs/PHP_CodeSniffer), [php-cs-fixer](http://cs.sensiolabs.org/) |
+| PHP | [hack](http://hacklang.org/), [hackfmt](https://github.com/facebook/flow/tree/master/hack/hackfmt), [langserver](https://github.com/felixfbecker/php-language-server), [phan](https://github.com/phan/phan) see `:help ale-php-phan` to instructions, [php -l](https://secure.php.net/), [phpcs](https://github.com/squizlabs/PHP_CodeSniffer), [phpmd](https://phpmd.org), [phpstan](https://github.com/phpstan/phpstan), [phpcbf](https://github.com/squizlabs/PHP_CodeSniffer) |
-| PO | [alex](https://github.com/wooorm/alex) !!, [msgfmt](https://www.gnu.org/software/gettext/manual/html_node/msgfmt-Invocation.html), [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | Pod | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
-| Pony | [ponyc](https://github.com/ponylang/ponyc) |
 | proto | [protoc-gen-lint](https://github.com/ckaznocha/protoc-gen-lint) |
 | Pug | [pug-lint](https://github.com/pugjs/pug-lint) |
 | Puppet | [puppet](https://puppet.com), [puppet-lint](https://puppet-lint.com) |
-| Python | [autopep8](https://github.com/hhatto/autopep8), [black](https://github.com/ambv/black), [flake8](http://flake8.pycqa.org/en/latest/), [isort](https://github.com/timothycrosley/isort), [mypy](http://mypy-lang.org/), [prospector](http://github.com/landscapeio/prospector), [pycodestyle](https://github.com/PyCQA/pycodestyle), [pyls](https://github.com/palantir/python-language-server), [pyre](https://github.com/facebook/pyre-check), [pylint](https://www.pylint.org/) !!, [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/), [prospector](http://github.com/landscapeio/prospector), [pycodestyle](https://github.com/PyCQA/pycodestyle), [pyls](https://github.com/palantir/python-language-server), [pylint](https://www.pylint.org/) !!, [yapf](https://github.com/google/yapf) |
-| QML | [qmlfmt](https://github.com/jesperhh/qmlfmt), [qmllint](https://github.com/qt/qtdeclarative/tree/5.11/tools/qmllint) |
 | R | [lintr](https://github.com/jimhester/lintr) |
-| ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-reasonml-ols` for configuration instructions, [ols](https://github.com/freebroccolo/ocaml-language-server), [refmt](https://github.com/reasonml/reason-cli) |
+| ReasonML | [merlin](https://github.com/the-lambda-church/merlin) see `:help ale-integration-reason-merlin` for configuration instructions, [ols](https://github.com/freebroccolo/ocaml-language-server), [refmt](https://github.com/reasonml/reason-cli) |
 | reStructuredText | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [rstcheck](https://github.com/myint/rstcheck), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
 | Re:VIEW | [redpen](http://redpen.cc/) |
 | RPM spec | [rpmlint](https://github.com/rpm-software-management/rpmlint) (disabled by default; see `:help ale-integration-spec`) |
-| Ruby | [brakeman](http://brakemanscanner.org/) !!, [rails_best_practices](https://github.com/flyerhzm/rails_best_practices) !!, [reek](https://github.com/troessner/reek), [rubocop](https://github.com/bbatsov/rubocop), [ruby](https://www.ruby-lang.org), [rufo](https://github.com/ruby-formatter/rufo) |
+| 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/), [rustfmt](https://github.com/rust-lang-nursery/rustfmt) |
 | SASS | [sass-lint](https://www.npmjs.com/package/sass-lint), [stylelint](https://github.com/stylelint/stylelint) |
 | SCSS | [prettier](https://github.com/prettier/prettier), [sass-lint](https://www.npmjs.com/package/sass-lint), [scss-lint](https://github.com/brigade/scss-lint), [stylelint](https://github.com/stylelint/stylelint) |
-| Scala | [fsc](https://www.scala-lang.org/old/sites/default/files/linuxsoft_archives/docu/files/tools/fsc.html), [scalac](http://scala-lang.org), [scalafmt](https://scalameta.org/scalafmt/), [scalastyle](http://www.scalastyle.org) |
+| Scala | [scalac](http://scala-lang.org), [scalastyle](http://www.scalastyle.org) |
 | Slim | [slim-lint](https://github.com/sds/slim-lint) |
 | SML | [smlnj](http://www.smlnj.org/) |
 | Solidity | [solhint](https://github.com/protofire/solhint), [solium](https://github.com/duaraghav8/Solium) |
@@ -179,13 +152,12 @@ formatting.
 | Tcl | [nagelfar](http://nagelfar.sourceforge.net) !! |
 | Terraform | [tflint](https://github.com/wata727/tflint) |
 | Texinfo | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good)|
-| Text^ | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [redpen](http://redpen.cc/), [textlint](https://textlint.github.io/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good) |
+| Text^ | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [vale](https://github.com/ValeLint/vale), [write-good](https://github.com/btford/write-good), [redpen](http://redpen.cc/) |
 | Thrift | [thrift](http://thrift.apache.org/) |
 | TypeScript | [eslint](http://eslint.org/), [prettier](https://github.com/prettier/prettier), [tslint](https://github.com/palantir/tslint), tsserver, typecheck |
 | Verilog | [iverilog](https://github.com/steveicarus/iverilog), [verilator](http://www.veripool.org/projects/verilator/wiki/Intro) |
 | Vim | [vint](https://github.com/Kuniwak/vint) |
 | Vim help^ | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
-| Vue | [prettier](https://github.com/prettier/prettier) |
 | XHTML | [alex](https://github.com/wooorm/alex) !!, [proselint](http://proselint.com/), [write-good](https://github.com/btford/write-good) |
 | XML | [xmllint](http://xmlsoft.org/xmllint.html) |
 | YAML | [swaglint](https://github.com/byCedric/swaglint), [yamllint](https://yamllint.readthedocs.io/) |
@@ -215,42 +187,24 @@ ale-linter-options` for options specified to particular linters.
 ### 2.ii Fixing
 
 ALE can fix files with the `ALEFix` command. Functions need to be configured
-either in each buffer with a `b:ale_fixers`, or globally with `g:ale_fixers`.
+for different filetypes with the `g:ale_fixers` variable. For example, the
-
+following code can be used to fix JavaScript code with ESLint:
-The recommended way to configure fixers is to define a List in an ftplugin file.
 
 ```vim
-" In ~/.vim/ftplugin/javascript.vim, or somewhere similar.
+" Put this in vimrc or a plugin file of your own.
-
+" After this is configured, :ALEFix will try and fix your JS code with ESLint.
-" Fix files with prettier, and then ESLint.
-let b:ale_fixers = ['prettier', 'eslint']
-" Equivalent to the above.
-let b:ale_fixers = {'javascript': ['prettier', 'eslint']}
-```
-
-You can also configure your fixers from vimrc using `g:ale_fixers`, before
-or after ALE has been loaded.
-
-```vim
-" In ~/.vim/vimrc, or somewhere similar.
 let g:ale_fixers = {
 \   'javascript': ['eslint'],
 \}
-```
 
-If you want to automatically fix files when you save them, you need to turn
+" Set this setting in vimrc if you want to fix files automatically on save.
-a setting on in vimrc.
+" This is off by default.
-
-```vim
-" Set this variable to 1 to fix files when you save them.
 let g:ale_fix_on_save = 1
 ```
 
-The `:ALEFixSuggest` command will suggest some supported tools for fixing code.
+The `:ALEFixSuggest` command will suggest some supported tools for fixing code,
-Both `g:ale_fixers` and `b:ale_fixers` can also accept functions, including
+but fixers can be also implemented with functions, including lambda functions
-lambda functions, as fixers, for fixing files with custom tools.
+too. See `:help ale-fix` for detailed information.
-
-See `:help ale-fix` for complete information on how to fix files with ALE.
 
 <a name="usage-completion"></a>
 
@@ -258,7 +212,9 @@ See `:help ale-fix` for complete information on how to fix files with ALE.
 
 ALE offers some support for completion via hijacking of omnicompletion while you
 type. All of ALE's completion information must come from Language Server
-Protocol linters, or from `tsserver` for TypeScript.
+Protocol linters, or similar protocols. At the moment, completion is only
+supported for TypeScript code with `tsserver`, when `tsserver` is enabled. You
+can enable completion like so:
 
 ```vim
 " Enable completion where available.
@@ -272,34 +228,10 @@ See `:help ale-completion` for more information.
 ### 2.iv Go To Definition
 
 ALE supports jumping to the definition of words under your cursor with the
-`:ALEGoToDefinition` command using any enabled Language Server Protocol linters
+`:ALEGoToDefinition` command using any enabled LSP linters and `tsserver`.
-and `tsserver`.
 
 See `:help ale-go-to-definition` for more information.
 
-<a name="usage-find-references"></a>
-
-### 2.v Find References
-
-ALE supports finding references for words under your cursor with the
-`:ALEFindReferences` command using any enabled Language Server Protocol linters
-and `tsserver`.
-
-See `:help ale-find-references` for more information.
-
-<a name="usage-hover"></a>
-
-### 2.vi Hovering
-
-ALE supports "hover" information for printing brief information about symbols at
-the cursor taken from Language Server Protocol linters and `tsserver` with the
-`ALEHover` command.
-
-On vim/gvim with `balloon` support you can see the information in a tooltip
-that appears under the mouse when you mouseover a symbol.
-
-See `:help ale-hover` for more information.
-
 <a name="installation"></a>
 
 ## 3. Installation
@@ -408,28 +340,12 @@ on Freenode. Web chat is available [here](https://webchat.freenode.net/?channels
 
 ### 5.i. How do I disable particular linters?
 
-By default, all available tools for all supported languages will be run. If you
+By default, all available tools for all supported languages will be run.
-want to only select a subset of the tools, you can define `b:ale_linters` for a
+If you want to only select a subset of the tools, simply create a
-single buffer, or `g:ale_linters` globally.
+`g:ale_linters` dictionary in your vimrc file mapping filetypes
-
+to lists of linters to run.
-The recommended way to configure linters is to define a List in an ftplugin
-file.
 
 ```vim
-" In ~/.vim/ftplugin/javascript.vim, or somewhere similar.
-
-" Enable ESLint only for JavaScript.
-let b:ale_linters = ['eslint']
-
-" Equivalent to the above.
-let b:ale_linters = {'javascript': ['eslint']}
-```
-
-You can also declare which linters you want to run in your vimrc file, before or
-after ALE has been loaded.
-
-```vim
-" In ~/.vim/vimrc, or somewhere similar.
 let g:ale_linters = {
 \   'javascript': ['eslint'],
 \}
@@ -440,14 +356,6 @@ be run for those languages, just as when the dictionary is not defined.
 Running many linters should not typically obstruct editing in Vim,
 as they will all be executed in separate processes simultaneously.
 
-If you don't want ALE to run anything other than what you've explicitly asked
-for, you can set `g:ale_linters_explicit` to `1`.
-
-```vim
-" Only run linters named in ale_linters settings.
-let g:ale_linters_explicit = 1
-```
-
 This plugin will look for linters in the [`ale_linters`](ale_linters) directory.
 Each directory within corresponds to a particular filetype in Vim, and each file
 in each directory corresponds to the name of a particular linter.
@@ -566,8 +474,6 @@ There are 3 global options that allow customizing the echoed message.
 
 - `g:ale_echo_msg_format` where:
     * `%s` is the error message itself
-    * `%...code...%` is an optional error code, and most characters can be
-      written between the `%` characters.
     * `%linter%` is the linter name
     * `%severity` is the severity type
 - `g:ale_echo_msg_error_str` is the string used for error severity.
@@ -585,28 +491,20 @@ Will give you:
 
 ![Echoed message](img/echo.png)
 
-See `:help g:ale_echo_msg_format` for more information.
-
 <a name="faq-autocmd"></a>
 
 ### 5.viii. How can I execute some code when ALE starts or stops linting?
 
 ALE runs its own [autocmd](http://vimdoc.sourceforge.net/htmldoc/autocmd.html)
-events when a lint or fix cycle are started and stopped. There is also an event
+events whenever has a linter is started and has been successfully executed and
-that runs when a linter job has been successfully started. These events can be
+processed. These events can be used to call arbitrary functions before and after
-used to call arbitrary functions during these respective parts of the ALE's
+ALE stops linting.
-operation.
 
 ```vim
 augroup YourGroup
     autocmd!
     autocmd User ALELintPre  call YourFunction()
     autocmd User ALELintPost call YourFunction()
-
-    autocmd User ALEJobStarted call YourFunction()
-
-    autocmd User ALEFixPre     call YourFunction()
-    autocmd User ALEFixPost    call YourFunction()
 augroup END
 ```
 
@@ -673,9 +571,6 @@ let g:ale_open_list = 1
 let g:ale_keep_list_window_open = 1
 ```
 
-You can also set `let g:ale_list_vertical = 1` to open the windows vertically
-instead of the default horizontally.
-
 <a name="faq-jsx-stylelint-eslint"></a>
 
 ### 5.xii. How can I check JSX files with both stylelint and eslint?
@@ -697,18 +592,9 @@ augroup END
 ```
 
 Supposing the filetype has been set correctly, you can set the following
-options in a jsx.vim ftplugin file.
+options in your vimrc file:
 
 ```vim
-" In ~/.vim/ftplugin/jsx.vim, or somewhere similar.
-let b:ale_linters = ['stylelint', 'eslint']
-let b:ale_linter_aliases = ['css']
-```
-
-Or if you want, you can configure the linters from your vimrc file.
-
-```vim
-" In ~/.vim/vimrc, or somewhere similar.
 let g:ale_linters = {'jsx': ['stylelint', 'eslint']}
 let g:ale_linter_aliases = {'jsx': 'css'}
 ```
@@ -754,9 +640,8 @@ ALE cannot easily detect which compiler flags to use.
 
 Some tools and build configurations can generate
 [compile_commands.json](https://clang.llvm.org/docs/JSONCompilationDatabase.html)
-files. The `cppcheck`, `clangcheck`, `clangtidy` and `cquery` linters can read
+files. The `cppcheck`, `clangcheck` and `clangtidy` linters can read these
-these files for automatically determining the appropriate compiler flags to
+files for automatically determining the appropriate compiler flags to use.
-use.
 
 For linting with compilers like `gcc` and `clang`, and with other tools, you
 will need to tell ALE which compiler flags to use yourself. You can use
@@ -804,14 +689,3 @@ let g:ale_pattern_options_enabled = 1
 ```
 
 Buffer-local variables for settings always override the global settings.
-
-<a name="faq-list-window-height"></a>
-
-### 5.xvi. How can I configure the height of the list in which ALE displays errors?
-
-To set a default height for the error list, use the `g:ale_list_window_size` variable.
-
-```vim
-" Show 5 lines of errors (default: 10)
-let g:ale_list_window_size = 5
-```

after/plugin/ale.vim

@@ -0,0 +1,37 @@
+" Author: w0rp <devw0rp@gmail.com>
+" Description: Follow-up checks for the plugin: warn about conflicting plugins.
+
+" A flag for ensuring that this is not run more than one time.
+if exists('g:loaded_ale_after')
+    finish
+endif
+
+" Set the flag so this file is not run more than one time.
+let g:loaded_ale_after = 1
+
+" Check if the flag is available and set to 0 to disable checking for and
+" emitting conflicting plugin warnings.
+if exists('g:ale_emit_conflict_warnings') && !g:ale_emit_conflict_warnings
+    finish
+endif
+
+" Conflicting Plugins Checks
+
+function! s:GetConflictingPluginWarning(plugin_name) abort
+    return 'ALE conflicts with ' . a:plugin_name
+    \   . '. Uninstall it, or disable this warning with '
+    \   . '`let g:ale_emit_conflict_warnings = 0` in your vimrc file, '
+    \   . '*before* plugins are loaded.'
+endfunction
+
+if exists('g:loaded_syntastic_plugin')
+    throw s:GetConflictingPluginWarning('Syntastic')
+endif
+
+if exists('g:loaded_neomake')
+    throw s:GetConflictingPluginWarning('Neomake')
+endif
+
+if exists('g:loaded_validator_plugin')
+    throw s:GetConflictingPluginWarning('Validator')
+endif

ale_linters/awk/gawk.vim

@@ -12,11 +12,7 @@ function! ale_linters#awk#gawk#GetExecutable(buffer) abort
 endfunction
 
 function! ale_linters#awk#gawk#GetCommand(buffer) abort
-    " note the --source 'BEGIN ...' is to prevent
-    " gawk from attempting to execute the body of the script
-    " it is linting.
     return ale_linters#awk#gawk#GetExecutable(a:buffer)
-    \   . " --source 'BEGIN { exit } END { exit 1 }'"
     \   . ' ' . ale#Var(a:buffer, 'awk_gawk_options')
     \   . ' ' . '-f %t --lint /dev/null'
 endfunction
@@ -25,6 +21,6 @@ call ale#linter#Define('awk', {
 \   'name': 'gawk',
 \   'executable_callback': 'ale_linters#awk#gawk#GetExecutable',
 \   'command_callback': 'ale_linters#awk#gawk#GetCommand',
-\   'callback': 'ale#handlers#gawk#HandleGawkFormat',
+\   'callback': 'ale#handlers#cpplint#HandleCppLintFormat',
 \   'output_stream': 'both'
 \})

ale_linters/c/clang.vim

@@ -8,15 +8,15 @@ function! ale_linters#c#clang#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'c_clang_executable')
 endfunction
 
-function! ale_linters#c#clang#GetCommand(buffer, output) abort
+function! ale_linters#c#clang#GetCommand(buffer) abort
-    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
     " -iquote with the directory the file is in makes #include work for
     "  headers in the same directory.
     return ale#Escape(ale_linters#c#clang#GetExecutable(a:buffer))
     \   . ' -S -x c -fsyntax-only '
     \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
-    \   . l:cflags
+    \   . ale#c#IncludeOptions(l:paths)
     \   . ale#Var(a:buffer, 'c_clang_options') . ' -'
 endfunction
 
@@ -24,9 +24,6 @@ call ale#linter#Define('c', {
 \   'name': 'clang',
 \   'output_stream': 'stderr',
 \   'executable_callback': 'ale_linters#c#clang#GetExecutable',
-\   'command_chain': [
+\   'command_callback': 'ale_linters#c#clang#GetCommand',
-\       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
-\       {'callback': 'ale_linters#c#clang#GetCommand'}
-\   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/c/flawfinder.vim

@@ -1,31 +0,0 @@
-" Author: Christian Gibbons <cgibbons@gmu.edu>
-" Description: flawfinder linter for c files
-
-call ale#Set('c_flawfinder_executable', 'flawfinder')
-call ale#Set('c_flawfinder_options', '')
-call ale#Set('c_flawfinder_minlevel', 1)
-call ale#Set('c_flawfinder_error_severity', 6)
-
-function! ale_linters#c#flawfinder#GetExecutable(buffer) abort
-   return ale#Var(a:buffer, 'c_flawfinder_executable')
-endfunction
-
-function! ale_linters#c#flawfinder#GetCommand(buffer) abort
-
-   " Set the minimum vulnerability level for flawfinder to bother with
-   let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'c_flawfinder_minlevel')
-
-   return ale#Escape(ale_linters#c#flawfinder#GetExecutable(a:buffer))
-   \  . ' -CDQS'
-   \  . ale#Var(a:buffer, 'c_flawfinder_options')
-   \  . l:minlevel
-   \  . ' %t'
-endfunction
-
-call ale#linter#Define('c', {
-\  'name': 'flawfinder',
-\  'output_stream': 'stdout',
-\  'executable_callback': 'ale_linters#c#flawfinder#GetExecutable',
-\  'command_callback': 'ale_linters#c#flawfinder#GetCommand',
-\  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
-\})

ale_linters/c/gcc.vim

@@ -8,15 +8,15 @@ function! ale_linters#c#gcc#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'c_gcc_executable')
 endfunction
 
-function! ale_linters#c#gcc#GetCommand(buffer, output) abort
+function! ale_linters#c#gcc#GetCommand(buffer) abort
-    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
     " -iquote with the directory the file is in makes #include work for
     "  headers in the same directory.
     return ale#Escape(ale_linters#c#gcc#GetExecutable(a:buffer))
     \   . ' -S -x c -fsyntax-only '
     \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
-    \   . l:cflags
+    \   . ale#c#IncludeOptions(l:paths)
     \   . ale#Var(a:buffer, 'c_gcc_options') . ' -'
 endfunction
 
@@ -24,9 +24,6 @@ call ale#linter#Define('c', {
 \   'name': 'gcc',
 \   'output_stream': 'stderr',
 \   'executable_callback': 'ale_linters#c#gcc#GetExecutable',
-\   'command_chain': [
+\   'command_callback': 'ale_linters#c#gcc#GetCommand',
-\       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
-\       {'callback': 'ale_linters#c#gcc#GetCommand'}
-\   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/cloudformation/cfn_python_lint.vim

@@ -1,35 +0,0 @@
-" Author: Yasuhiro Kiyota <yasuhiroki.duck@gmail.com>
-" Description: Support cfn-python-lint for AWS Cloudformation template file
-
-function! ale_linters#cloudformation#cfn_python_lint#Handle(buffer, lines) abort
-    " Matches patterns line the following:
-    "
-    " sample.template.yaml:96:7:96:15:E3012:Property Resources/Sample/Properties/FromPort should be of type Integer
-    let l:pattern = '\v^(.*):(\d+):(\d+):(\d+):(\d+):([[:alnum:]]+):(.*)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:code = l:match[6]
-
-        if ale#path#IsBufferPath(a:buffer, l:match[1])
-            call add(l:output, {
-            \   'lnum': l:match[2],
-            \   'col': l:match[3],
-            \   'end_lnum': l:match[4],
-            \   'end_col': l:match[5],
-            \   'code': l:code,
-            \   'type': l:code[:0] is# 'E' ? 'E' : 'W',
-            \   'text': l:match[7]
-            \})
-        endif
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('cloudformation', {
-\   'name': 'cloudformation',
-\   'executable': 'cfn-lint',
-\   'command': 'cfn-lint --template %t --format parseable',
-\   'callback': 'ale_linters#cloudformation#cfn_python_lint#Handle',
-\})

ale_linters/cpp/clang.vim

@@ -8,15 +8,15 @@ function! ale_linters#cpp#clang#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'cpp_clang_executable')
 endfunction
 
-function! ale_linters#cpp#clang#GetCommand(buffer, output) abort
+function! ale_linters#cpp#clang#GetCommand(buffer) abort
-    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
     " -iquote with the directory the file is in makes #include work for
     "  headers in the same directory.
     return ale#Escape(ale_linters#cpp#clang#GetExecutable(a:buffer))
     \   . ' -S -x c++ -fsyntax-only '
     \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
-    \   . l:cflags
+    \   . ale#c#IncludeOptions(l:paths)
     \   . ale#Var(a:buffer, 'cpp_clang_options') . ' -'
 endfunction
 
@@ -24,9 +24,6 @@ call ale#linter#Define('cpp', {
 \   'name': 'clang',
 \   'output_stream': 'stderr',
 \   'executable_callback': 'ale_linters#cpp#clang#GetExecutable',
-\   'command_chain': [
+\   'command_callback': 'ale_linters#cpp#clang#GetCommand',
-\       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
-\       {'callback': 'ale_linters#cpp#clang#GetCommand'},
-\   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/cpp/cquery.vim

@@ -1,34 +0,0 @@
-" Author: Ben Falconer <ben@falconers.me.uk>
-" Description: A language server for C++
-
-call ale#Set('cpp_cquery_executable', 'cquery')
-call ale#Set('cpp_cquery_cache_directory', expand('~/.cache/cquery'))
-
-function! ale_linters#cpp#cquery#GetProjectRoot(buffer) abort
-    let l:project_root = ale#path#FindNearestFile(a:buffer, 'compile_commands.json')
-
-    return !empty(l:project_root) ? fnamemodify(l:project_root, ':h') : ''
-endfunction
-
-function! ale_linters#cpp#cquery#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'cpp_cquery_executable')
-endfunction
-
-function! ale_linters#cpp#cquery#GetCommand(buffer) abort
-    let l:executable = ale_linters#cpp#cquery#GetExecutable(a:buffer)
-    return ale#Escape(l:executable)
-endfunction
-
-function! ale_linters#cpp#cquery#GetInitializationOptions(buffer) abort
-    return {'cacheDirectory': ale#Var(a:buffer, 'cpp_cquery_cache_directory')}
-endfunction
-
-call ale#linter#Define('cpp', {
-\   'name': 'cquery',
-\   'lsp': 'stdio',
-\   'executable_callback': 'ale_linters#cpp#cquery#GetExecutable',
-\   'command_callback': 'ale_linters#cpp#cquery#GetCommand',
-\   'project_root_callback': 'ale_linters#cpp#cquery#GetProjectRoot',
-\   'initialization_options_callback': 'ale_linters#cpp#cquery#GetInitializationOptions',
-\   'language': 'cpp',
-\})

ale_linters/cpp/flawfinder.vim

@@ -1,31 +0,0 @@
-" Author: Christian Gibbons <cgibbons@gmu.edu>
-" Description: flawfinder linter for c++ files
-
-call ale#Set('cpp_flawfinder_executable', 'flawfinder')
-call ale#Set('cpp_flawfinder_options', '')
-call ale#Set('cpp_flawfinder_minlevel', 1)
-call ale#Set('c_flawfinder_error_severity', 6)
-
-function! ale_linters#cpp#flawfinder#GetExecutable(buffer) abort
-   return ale#Var(a:buffer, 'cpp_flawfinder_executable')
-endfunction
-
-function! ale_linters#cpp#flawfinder#GetCommand(buffer) abort
-
-   " Set the minimum vulnerability level for flawfinder to bother with
-   let l:minlevel = ' --minlevel=' . ale#Var(a:buffer, 'cpp_flawfinder_minlevel')
-
-   return ale#Escape(ale_linters#cpp#flawfinder#GetExecutable(a:buffer))
-   \  . ' -CDQS'
-   \  . ale#Var(a:buffer, 'cpp_flawfinder_options')
-   \  . l:minlevel
-   \  . ' %t'
-endfunction
-
-call ale#linter#Define('cpp', {
-\  'name': 'flawfinder',
-\  'output_stream': 'stdout',
-\  'executable_callback': 'ale_linters#cpp#flawfinder#GetExecutable',
-\  'command_callback': 'ale_linters#cpp#flawfinder#GetCommand',
-\  'callback': 'ale#handlers#flawfinder#HandleFlawfinderFormat',
-\})

ale_linters/cpp/gcc.vim

@@ -8,26 +8,22 @@ function! ale_linters#cpp#gcc#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'cpp_gcc_executable')
 endfunction
 
-function! ale_linters#cpp#gcc#GetCommand(buffer, output) abort
+function! ale_linters#cpp#gcc#GetCommand(buffer) abort
-    let l:cflags = ale#c#GetCFlags(a:buffer, a:output)
+    let l:paths = ale#c#FindLocalHeaderPaths(a:buffer)
 
     " -iquote with the directory the file is in makes #include work for
     "  headers in the same directory.
     return ale#Escape(ale_linters#cpp#gcc#GetExecutable(a:buffer))
     \   . ' -S -x c++ -fsyntax-only '
     \   . '-iquote ' . ale#Escape(fnamemodify(bufname(a:buffer), ':p:h')) . ' '
-    \   . l:cflags
+    \   . ale#c#IncludeOptions(l:paths)
     \   . ale#Var(a:buffer, 'cpp_gcc_options') . ' -'
 endfunction
 
 call ale#linter#Define('cpp', {
-\   'name': 'gcc',
+\   'name': 'g++',
-\   'aliases': ['g++'],
 \   'output_stream': 'stderr',
 \   'executable_callback': 'ale_linters#cpp#gcc#GetExecutable',
-\   'command_chain': [
+\   'command_callback': 'ale_linters#cpp#gcc#GetCommand',
-\       {'callback': 'ale#c#GetMakeCommand', 'output_stream': 'stdout'},
-\       {'callback': 'ale_linters#cpp#gcc#GetCommand'},
-\   ],
 \   'callback': 'ale#handlers#gcc#HandleGCCFormat',
 \})

ale_linters/cs/mcsc.vim

@@ -10,7 +10,7 @@ function! s:GetWorkingDirectory(buffer) abort
         return l:working_directory
     endif
 
-    return expand('#' . a:buffer . ':p:h')
+    return fnamemodify(bufname(a:buffer), ':p:h')
 endfunction
 
 function! ale_linters#cs#mcsc#GetCommand(buffer) abort

ale_linters/css/stylelint.vim

@@ -2,7 +2,7 @@
 
 call ale#Set('css_stylelint_executable', 'stylelint')
 call ale#Set('css_stylelint_options', '')
-call ale#Set('css_stylelint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('css_stylelint_use_global', 0)
 
 function! ale_linters#css#stylelint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'css_stylelint', [

ale_linters/cucumber/cucumber.vim

@@ -1,45 +0,0 @@
-" Author: Eddie Lebow https://github.com/elebow
-" Description: Cucumber, a BDD test tool
-
-function! ale_linters#cucumber#cucumber#GetCommand(buffer) abort
-    let l:features_dir = ale#path#FindNearestDirectory(a:buffer, 'features')
-
-    if !empty(l:features_dir)
-        let l:features_arg = '-r ' . ale#Escape(l:features_dir)
-    else
-        let l:features_arg = ''
-    endif
-
-    return 'cucumber --dry-run --quiet --strict --format=json '
-    \   . l:features_arg . ' %t'
-endfunction
-
-function! ale_linters#cucumber#cucumber#Handle(buffer, lines) abort
-    try
-        let l:json = ale#util#FuzzyJSONDecode(a:lines, {})[0]
-    catch
-        return []
-    endtry
-
-    let l:output = []
-    for l:element in get(l:json, 'elements', [])
-        for l:step in l:element['steps']
-            if l:step['result']['status'] is# 'undefined'
-                call add(l:output, {
-                \   'lnum': l:step['line'],
-                \   'code': 'E',
-                \   'text': 'Undefined step'
-                \})
-            endif
-        endfor
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('cucumber', {
-\   'name': 'cucumber',
-\   'executable': 'cucumber',
-\   'command_callback': 'ale_linters#cucumber#cucumber#GetCommand',
-\   'callback': 'ale_linters#cucumber#cucumber#Handle'
-\})

ale_linters/d/dmd.vim

@@ -46,7 +46,7 @@ function! ale_linters#d#dmd#DMDCommand(buffer, dub_output) abort
         endif
     endfor
 
-    return 'dmd '. join(l:import_list) . ' -o- -wi -vcolumns -c %t'
+    return 'dmd '. join(l:import_list) . ' -o- -vcolumns -c %t'
 endfunction
 
 function! ale_linters#d#dmd#Handle(buffer, lines) abort

ale_linters/dart/language_server.vim

@@ -7,6 +7,10 @@ function! ale_linters#dart#language_server#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'dart_language_server_executable')
 endfunction
 
+function! ale_linters#dart#language_server#GetLanguage(buffer) abort
+    return 'dart'
+endfunction
+
 function! ale_linters#dart#language_server#GetProjectRoot(buffer) abort
     " Note: pub only looks for pubspec.yaml, there's no point in adding
     " support for pubspec.yml
@@ -20,6 +24,7 @@ call ale#linter#Define('dart', {
 \   'lsp': 'stdio',
 \   'executable_callback': 'ale_linters#dart#language_server#GetExecutable',
 \   'command_callback': 'ale_linters#dart#language_server#GetExecutable',
-\   'language': 'dart',
+\   'language_callback': 'ale_linters#dart#language_server#GetLanguage',
 \   'project_root_callback': 'ale_linters#dart#language_server#GetProjectRoot',
 \})
+

ale_linters/dockerfile/hadolint.vim

@@ -2,51 +2,31 @@
 
 " always, yes, never
 call ale#Set('dockerfile_hadolint_use_docker', 'never')
-call ale#Set('dockerfile_hadolint_docker_image', 'hadolint/hadolint')
+call ale#Set('dockerfile_hadolint_docker_image', 'lukasmartinelli/hadolint')
 
 function! ale_linters#dockerfile#hadolint#Handle(buffer, lines) abort
     " Matches patterns line the following:
     "
-    " /dev/stdin:19 DL3001 Pipe chain should start with a raw value.
+    " stdin:19: F: Pipe chain should start with a raw value.
-    " /dev/stdin:19:3 unexpected thing
+    let l:pattern = '\v^/dev/stdin:?(\d+)? (\S+) (.+)$'
-    let l:pattern = '\v^/dev/stdin:(\d+):?(\d+)? ((DL|SC)(\d+) )?(.+)$'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:lnum = 0
-        let l:colnum = 0
 
         if l:match[1] isnot# ''
             let l:lnum = l:match[1] + 0
         endif
 
-        if l:match[2] isnot# ''
-            let l:colnum = l:match[2] + 0
-        endif
-
         let l:type = 'W'
-        let l:text = l:match[6]
+        let l:text = l:match[3]
-        let l:detail = l:match[6]
-        let l:domain = 'https://github.com/hadolint/hadolint/wiki/'
-
-        if l:match[4] is# 'SC'
-            let l:domain = 'https://github.com/koalaman/shellcheck/wiki/'
-        endif
-
-        if l:match[5] isnot# ''
-            let l:code = l:match[4] . l:match[5]
-            let l:link = ' ( ' . l:domain . l:code . ' )'
-            let l:detail = l:code . l:link . "\n\n" . l:detail
-        else
-            let l:type = 'E'
-        endif
 
         call add(l:output, {
         \   'lnum': l:lnum,
-        \   'col': l:colnum,
+        \   'col': 0,
         \   'type': l:type,
         \   'text': l:text,
-        \   'detail': l:detail
+        \   'nr': l:match[2],
         \})
     endfor
 

ale_linters/elixir/credo.vim

@@ -32,6 +32,6 @@ endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'credo',
 \   'executable': 'mix',
-\   'command': 'mix help credo && mix credo suggest --format=flycheck --read-from-stdin %s',
+\   'command': 'mix credo suggest --format=flycheck --read-from-stdin %s',
 \   'callback': 'ale_linters#elixir#credo#Handle',
 \})

ale_linters/elixir/dialyxir.vim

@@ -1,34 +0,0 @@
-" Author: Fran C. - https://github.com/franciscoj
-" Description: Add dialyzer support for elixir through dialyxir
-" https://github.com/jeremyjh/dialyxir
-
-function! ale_linters#elixir#dialyxir#Handle(buffer, lines) abort
-    " Matches patterns line the following:
-    "
-    " lib/filename.ex:19: Function fname/1 has no local return
-    let l:pattern = '\v(.+):(\d+): (.+)$'
-    let l:output = []
-    let l:type = 'W'
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        if bufname(a:buffer) == l:match[1]
-            call add(l:output, {
-            \   'bufnr': a:buffer,
-            \   'lnum': l:match[2] + 0,
-            \   'col': 0,
-            \   'type': l:type,
-            \   'text': l:match[3],
-            \})
-        endif
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('elixir', {
-\   'name': 'dialyxir',
-\   'executable': 'mix',
-\   'command': 'mix dialyzer',
-\   'callback': 'ale_linters#elixir#dialyxir#Handle',
-\})
-

ale_linters/elixir/dogma.vim

@@ -32,7 +32,7 @@ endfunction
 call ale#linter#Define('elixir', {
 \   'name': 'dogma',
 \   'executable': 'mix',
-\   'command': 'mix help dogma && mix dogma %s --format=flycheck',
+\   'command': 'mix dogma %s --format=flycheck',
 \   'lint_file': 1,
 \   'callback': 'ale_linters#elixir#dogma#Handle',
 \})

ale_linters/elixir/mix.vim

@@ -1,61 +0,0 @@
-" Author: evnu - https://github.com/evnu
-" Author: colbydehart - https://github.com/colbydehart
-" Description: Mix compile checking for Elixir files
-
-function! ale_linters#elixir#mix#Handle(buffer, lines) abort
-    " Matches patterns like the following:
-    "
-    " Error format
-    " ** (CompileError) apps/sim/lib/sim/server.ex:87: undefined function update_in/4
-    "
-    " TODO: Warning format
-    " warning: variable "foobar" does not exist and is being expanded to "foobar()", please use parentheses to remove the ambiguity or change the variable name
-
-    let l:pattern = '\v\(([^\)]+Error)\) ([^:]+):([^:]+): (.+)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:type = 'E'
-        let l:text = l:match[4]
-
-        call add(l:output, {
-        \   'bufnr': a:buffer,
-        \   'lnum': l:match[3] + 0,
-        \   'col': 0,
-        \   'type': l:type,
-        \   'text': l:text,
-        \})
-    endfor
-
-    return l:output
-endfunction
-
-function! ale_linters#elixir#mix#FindProjectRoot(buffer) abort
-    let l:mix_file = ale#path#FindNearestFile(a:buffer, 'mix.exs')
-    if !empty(l:mix_file)
-      return fnamemodify(l:mix_file, ':p:h')
-    endif
-    return '.'
-endfunction
-
-function! ale_linters#elixir#mix#GetCommand(buffer) abort
-    let l:project_root = ale_linters#elixir#mix#FindProjectRoot(a:buffer)
-
-    let l:temp_dir = ale#engine#CreateDirectory(a:buffer)
-
-    let l:mix_build_path = has('win32')
-    \   ? 'set MIX_BUILD_PATH=' . ale#Escape(l:temp_dir) . ' &&'
-    \   : 'MIX_BUILD_PATH=' . ale#Escape(l:temp_dir)
-
-    return ale#path#CdString(l:project_root)
-          \ . l:mix_build_path
-          \ . ' mix compile %s'
-endfunction
-
-call ale#linter#Define('elixir', {
-\   'name': 'mix',
-\   'executable': 'mix',
-\   'command_callback': 'ale_linters#elixir#mix#GetCommand',
-\   'callback': 'ale_linters#elixir#mix#Handle',
-\   'lint_file': 1,
-\})

ale_linters/elm/make.vim

@@ -1,26 +1,45 @@
-" Author: buffalocoder - https://github.com/buffalocoder, soywod - https://github.com/soywod, hecrj - https://github.com/hecrj
+" 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')
+call ale#Set('elm_make_executable', 'elm-make')
-call ale#Set('elm_make_use_global', get(g:, 'ale_use_global_executables', 0))
+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',
+    \   'node_modules/.bin/elm-make',
     \])
 endfunction
 
 function! ale_linters#elm#make#Handle(buffer, lines) abort
     let l:output = []
+    let l:is_windows = has('win32')
+    let l:temp_dir = l:is_windows ? $TMP : $TMPDIR
     let l:unparsed_lines = []
-
     for l:line in a:lines
-        if l:line[0] is# '{'
+        if l:line[0] is# '['
-            " Elm 0.19
+            let l:errors = json_decode(l:line)
-            call ale_linters#elm#make#HandleElm019Line(l:line, l:output)
+
-        elseif l:line[0] is# '['
+            for l:error in l:errors
-            " Elm 0.18
+                " Check if file is from the temp directory.
-            call ale_linters#elm#make#HandleElm018Line(l:line, l:output)
+                " Filters out any errors not related to the buffer.
+                if l:is_windows
+                    let l:file_is_buffer = l:error.file[0:len(l:temp_dir) - 1] is? l:temp_dir
+                else
+                    let l:file_is_buffer = l:error.file[0:len(l:temp_dir) - 1] is# l:temp_dir
+                endif
+
+                if l:file_is_buffer
+                    call add(l:output, {
+                    \    'lnum': l:error.region.start.line,
+                    \    'col': l:error.region.start.column,
+                    \    'end_lnum': l:error.region.end.line,
+                    \    'end_col': l:error.region.end.column,
+                    \    'type': (l:error.type is? 'error') ? 'E' : 'W',
+                    \    'text': l:error.overview,
+                    \    'detail': l:error.overview . "\n\n" . l:error.details
+                    \})
+                endif
+            endfor
         elseif l:line isnot# 'Successfully generated /dev/null'
             call add(l:unparsed_lines, l:line)
         endif
@@ -38,142 +57,23 @@ function! ale_linters#elm#make#Handle(buffer, lines) abort
     return l:output
 endfunction
 
-function! ale_linters#elm#make#HandleElm019Line(line, output) abort
-    let l:report = json_decode(a:line)
-
-    if l:report.type is? 'error'
-        " General problem
-        let l:details = ale_linters#elm#make#ParseMessage(l:report.message)
-
-        if empty(l:report.path)
-            let l:report.path = 'Elm'
-        endif
-
-        if ale_linters#elm#make#FileIsBuffer(l:report.path)
-            call add(a:output, {
-            \    'lnum': 1,
-            \    'type': 'E',
-            \    'text': l:details,
-            \})
-        else
-            call add(a:output, {
-            \    'lnum': 1,
-            \    'type': 'E',
-            \    'text': l:report.path .' - '. l:details,
-            \    'detail': l:report.path ." ----------\n\n". l:details,
-            \})
-        endif
-    else
-        " Compilation errors
-        for l:error in l:report.errors
-            let l:file_is_buffer = ale_linters#elm#make#FileIsBuffer(l:error.path)
-
-            for l:problem in l:error.problems
-                let l:details = ale_linters#elm#make#ParseMessage(l:problem.message)
-
-                if l:file_is_buffer
-                    " Buffer module has problems
-                    call add(a:output, {
-                    \    'lnum': l:problem.region.start.line,
-                    \    'col': l:problem.region.start.column,
-                    \    'end_lnum': l:problem.region.end.line,
-                    \    'end_col': l:problem.region.end.column,
-                    \    'type': 'E',
-                    \    'text': l:details,
-                    \})
-                else
-                    " Imported module has problems
-                    let l:location = l:error.path .':'. l:problem.region.start.line
-                    call add(a:output, {
-                    \    'lnum': 1,
-                    \    'type': 'E',
-                    \    'text': l:location .' - '. l:details,
-                    \    'detail': l:location ." ----------\n\n". l:details,
-                    \})
-                endif
-            endfor
-        endfor
-    endif
-endfunction
-
-function! ale_linters#elm#make#HandleElm018Line(line, output) abort
-    let l:errors = json_decode(a:line)
-
-    for l:error in l:errors
-        let l:file_is_buffer = ale_linters#elm#make#FileIsBuffer(l:error.file)
-
-        if l:file_is_buffer
-            " Current buffer has problems
-            call add(a:output, {
-            \    'lnum': l:error.region.start.line,
-            \    'col': l:error.region.start.column,
-            \    'end_lnum': l:error.region.end.line,
-            \    'end_col': l:error.region.end.column,
-            \    'type': (l:error.type is? 'error') ? 'E' : 'W',
-            \    'text': l:error.overview,
-            \    'detail': l:error.overview . "\n\n" . l:error.details
-            \})
-        elseif l:error.type is? 'error'
-            " Imported module has errors
-            let l:location = l:error.file .':'. l:error.region.start.line
-
-            call add(a:output, {
-            \    'lnum': 1,
-            \    'type': 'E',
-            \    'text': l:location .' - '. l:error.overview,
-            \    'detail': l:location ." ----------\n\n". l:error.overview . "\n\n" . l:error.details
-            \})
-        endif
-    endfor
-endfunction
-
-function! ale_linters#elm#make#FileIsBuffer(path) abort
-    let l:is_windows = has('win32')
-    let l:temp_dir = l:is_windows ? $TMP : $TMPDIR
-
-    if has('win32')
-        return a:path[0:len(l:temp_dir) - 1] is? l:temp_dir
-    else
-        return a:path[0:len(l:temp_dir) - 1] is# l:temp_dir
-    endif
-endfunction
-
-function! ale_linters#elm#make#ParseMessage(message) abort
-    return join(map(copy(a:message), 'ale_linters#elm#make#ParseMessageItem(v:val)'), '')
-endfunction
-
-function! ale_linters#elm#make#ParseMessageItem(item) abort
-    if type(a:item) == type('')
-        return a:item
-    else
-        return a:item.string
-    endif
-endfunction
-
 " Return the command to execute the linter in the projects directory.
 " If it doesn't, then this will fail when imports are needed.
 function! ale_linters#elm#make#GetCommand(buffer) abort
-    let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm.json')
+    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)
-    if empty(l:elm_json)
-        " Fallback to Elm 0.18
-        let l:elm_json = ale#path#FindNearestFile(a:buffer, 'elm-package.json')
-    endif
-
-    if empty(l:elm_json)
         let l:dir_set_cmd = ''
     else
-        let l:root_dir = fnamemodify(l:elm_json, ':p:h')
+        let l:root_dir = fnamemodify(l:elm_package, ':p:h')
         let l:dir_set_cmd = 'cd ' . ale#Escape(l:root_dir) . ' && '
     endif
 
-    " The elm compiler, at the time of this writing, uses '/dev/null' as
+    " 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-compiler/blob/19d5a769b30ec0b2fc4475985abb4cd94cd1d6c3/builder/src/Generate/Output.hs#L253
+    " Source: https://github.com/elm-lang/elm-make/blob/master/src/Flags.hs
     let l:elm_cmd = ale#Escape(l:elm_exe)
-    \   . ' make'
     \   . ' --report=json'
     \   . ' --output=/dev/null'
 

ale_linters/eruby/erubi.vim

@@ -1,35 +0,0 @@
-" Author: Eddie Lebow https://github.com/elebow
-" Description: eruby checker using `erubi`
-
-function! ale_linters#eruby#erubi#CheckErubi(buffer) abort
-    return 'ruby -r erubi/capture_end -e ' . ale#Escape('""')
-endfunction
-
-function! ale_linters#eruby#erubi#GetCommand(buffer, check_erubi_output) abort
-    let l:rails_root = ale#ruby#FindRailsRoot(a:buffer)
-
-    if (!empty(a:check_erubi_output))
-        " The empty command in CheckErubi returns nothing if erubi runs and
-        " emits an error if erubi is not present
-        return ''
-    endif
-
-    if empty(l:rails_root)
-        return 'ruby -r erubi/capture_end -e ' . ale#Escape('puts Erubi::CaptureEndEngine.new($stdin.read).src') . '< %t | ruby -c'
-    endif
-
-    " Rails-flavored eRuby does not comply with the standard as understood by
-    " Erubi, so we'll have to do some substitution. This does not reduce the
-    " effectiveness of the linter---the translated code is still evaluated.
-    return 'ruby -r erubi/capture_end -e ' . ale#Escape('puts Erubi::CaptureEndEngine.new($stdin.read.gsub(%{<%=},%{<%}), nil, %{-}).src') . '< %t | ruby -c'
-endfunction
-
-call ale#linter#Define('eruby', {
-\   'name': 'erubi',
-\   'executable': 'ruby',
-\   'command_chain': [
-\     {'callback': 'ale_linters#eruby#erubi#CheckErubi'},
-\     {'callback': 'ale_linters#eruby#erubi#GetCommand', 'output_stream': 'stderr'},
-\   ],
-\   'callback': 'ale#handlers#ruby#HandleSyntaxErrors',
-\})

ale_linters/fish/fish.vim

@@ -1,67 +0,0 @@
-" Author: Niraj Thapaliya - https://github.com/nthapaliya
-" Description: Lints fish files using fish -n
-
-function! ale_linters#fish#fish#Handle(buffer, lines) abort
-    " Matches patterns such as:
-    "
-    " home/.config/fish/functions/foo.fish (line 1): Missing end to balance this function definition
-    " function foo
-    " ^
-    "
-    " OR, patterns such as:
-    "
-    " Unsupported use of '||'. In fish, please use 'COMMAND; or COMMAND'.
-    " /tmp/vLz620o/258/test.fish (line 2): if set -q SSH_CLIENT || set -q SSH_TTY
-    "                                                            ^
-    "
-    " fish -n can return errors in either format.
-    let l:pattern = '^\(.* (line \(\d\+\)): \)\(.*\)$'
-    let l:column_pattern = '^ *\^'
-    let l:output = []
-    let l:column_offset = 0
-    let l:last_line_with_message = ''
-
-    for l:line in a:lines
-        " Look for error lines first.
-        let l:match = matchlist(l:line, l:pattern)
-
-        if !empty(l:match)
-            if !empty(l:last_line_with_message)
-                let l:text = l:last_line_with_message
-            else
-                let l:text = l:match[3]
-            endif
-
-            let l:column_offset = len(l:match[1])
-
-            let l:last_line_with_message = ''
-            call add(l:output, {
-            \  'col': 0,
-            \  'lnum': str2nr(l:match[2]),
-            \  'text': l:text,
-            \})
-        else
-            " Look for column markers like '   ^' second.
-            " The column index will be set according to how long the line is.
-            let l:column_match = matchstr(l:line, l:column_pattern)
-
-            if !empty(l:column_match) && !empty(l:output)
-                let l:output[-1].col = len(l:column_match) - l:column_offset
-                let l:last_line_with_message = ''
-            else
-                let l:last_line_with_message = l:line
-                let l:column_offset = 0
-            endif
-        endif
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('fish', {
-\   'name': 'fish',
-\   'output_stream': 'stderr',
-\   'executable': 'fish',
-\   'command': 'fish -n %t',
-\   'callback': 'ale_linters#fish#fish#Handle',
-\})

ale_linters/fountain/proselint.vim

@@ -1,9 +0,0 @@
-" Author: Jansen Mitchell https://github.com/JansenMitchell
-" Description: proselint for Fountain files
-
-call ale#linter#Define('fountain', {
-\    'name': 'proselint',
-\    'executable': 'proselint',
-\    'command': 'proselint %t',
-\    'callback': 'ale#handlers#unix#HandleAsWarning',
-\})

ale_linters/gitcommit/gitlint.vim

@@ -1,56 +0,0 @@
-" Author: Nick Yamane <nick.diego@gmail.com>
-" Description: gitlint for git commit message files
-
-let g:ale_gitcommit_gitlint_executable =
-\   get(g:, 'ale_gitcommit_gitlint_executable', 'gitlint')
-let g:ale_gitcommit_gitlint_options = get(g:, 'ale_gitcommit_gitlint_options', '')
-let g:ale_gitcommit_gitlint_use_global = get(g:, 'ale_gitcommit_gitlint_use_global', get(g:, 'ale_use_global_executables', 0))
-
-
-function! ale_linters#gitcommit#gitlint#GetExecutable(buffer) abort
-    return ale#python#FindExecutable(a:buffer, 'gitcommit_gitlint', ['gitlint'])
-endfunction
-
-function! ale_linters#gitcommit#gitlint#GetCommand(buffer) abort
-    let l:options = ale#Var(a:buffer, 'gitcommit_gitlint_options')
-    let l:executable = ale_linters#gitcommit#gitlint#GetExecutable(a:buffer)
-    return ale#Escape(l:executable)
-    \   . (!empty(l:options) ? ' ' . l:options : '')
-    \   . ' lint'
-endfunction
-
-
-function! ale_linters#gitcommit#gitlint#Handle(buffer, lines) abort
-    " Matches patterns line the following:
-    let l:pattern = '\v^(\d+): (\w+) (.*)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:code = l:match[2]
-
-        if l:code is# 'T2' && !ale#Var(a:buffer, 'warn_about_trailing_whitespace')
-            continue
-        endif
-
-        let l:item = {
-        \   'lnum': l:match[1] + 0,
-        \   'text': l:match[3],
-        \   'code': l:code,
-        \   'type': 'E',
-        \}
-
-        call add(l:output, l:item)
-    endfor
-
-    return l:output
-endfunction
-
-
-call ale#linter#Define('gitcommit', {
-\   'name': 'gitlint',
-\   'output_stream': 'stderr',
-\   'executable_callback': 'ale_linters#gitcommit#gitlint#GetExecutable',
-\   'command_callback': 'ale_linters#gitcommit#gitlint#GetCommand',
-\   'callback': 'ale_linters#gitcommit#gitlint#Handle',
-\})
-

ale_linters/glsl/glslls.vim

@@ -18,6 +18,10 @@ function! ale_linters#glsl#glslls#GetCommand(buffer) abort
     return ale#Escape(l:executable) . l:logfile_args . ' --stdin'
 endfunction
 
+function! ale_linters#glsl#glslls#GetLanguage(buffer) abort
+    return 'glsl'
+endfunction
+
 function! ale_linters#glsl#glslls#GetProjectRoot(buffer) abort
     let l:project_root = ale#c#FindProjectRoot(a:buffer)
 
@@ -29,6 +33,6 @@ call ale#linter#Define('glsl', {
 \   'lsp': 'stdio',
 \   'executable_callback': 'ale_linters#glsl#glslls#GetExecutable',
 \   'command_callback': 'ale_linters#glsl#glslls#GetCommand',
-\   'language': 'glsl',
+\   'language_callback': 'ale_linters#glsl#glslls#GetLanguage',
 \   'project_root_callback': 'ale_linters#glsl#glslls#GetProjectRoot',
 \})

ale_linters/go/gobuild.vim

@@ -1,14 +1,9 @@
 " Author: Joshua Rubin <joshua@rubixconsulting.com>, Ben Reedy <https://github.com/breed808>,
 " Jeff Willette <jrwillette88@gmail.com>
 " Description: go build for Go files
+
 " inspired by work from dzhou121 <dzhou121@gmail.com>
 
-call ale#Set('go_gobuild_options', '')
-
-function! ale_linters#go#gobuild#ResetEnv() abort
-    unlet! s:go_env
-endfunction
-
 function! ale_linters#go#gobuild#GoEnv(buffer) abort
     if exists('s:go_env')
         return ''
@@ -18,8 +13,6 @@ function! ale_linters#go#gobuild#GoEnv(buffer) abort
 endfunction
 
 function! ale_linters#go#gobuild#GetCommand(buffer, goenv_output) abort
-    let l:options = ale#Var(a:buffer, 'go_gobuild_options')
-
     if !exists('s:go_env')
         let s:go_env = {
         \   'GOPATH': a:goenv_output[0],
@@ -27,16 +20,10 @@ function! ale_linters#go#gobuild#GetCommand(buffer, goenv_output) abort
         \}
     endif
 
-    let l:gopath_env_command = has('win32')
-    \   ? 'set GOPATH=' . ale#Escape(s:go_env.GOPATH) . ' && '
-    \   : 'GOPATH=' . ale#Escape(s:go_env.GOPATH) . ' '
-
     " Run go test in local directory with relative path
-    return l:gopath_env_command
+    return 'GOPATH=' . s:go_env.GOPATH
-    \   . ale#path#BufferCdString(a:buffer)
+    \   . ' cd ' . fnamemodify(bufname(a:buffer), ':.:h')
-    \   . 'go test'
+    \   . ' && go test -c -o /dev/null ./'
-    \   . (!empty(l:options) ? ' ' . l:options : '')
-    \   . ' -c -o /dev/null ./'
 endfunction
 
 function! ale_linters#go#gobuild#GetMatches(lines) abort

ale_linters/go/gosimple.vim

@@ -1,15 +1,11 @@
 " Author: Ben Reedy <https://github.com/breed808>
 " Description: gosimple for Go files
 
-function! ale_linters#go#gosimple#GetCommand(buffer) abort
-    return ale#path#BufferCdString(a:buffer) . ' gosimple .'
-endfunction
-
 call ale#linter#Define('go', {
 \   'name': 'gosimple',
 \   'executable': 'gosimple',
-\   'command_callback': 'ale_linters#go#gosimple#GetCommand',
+\   'command': 'gosimple %s',
-\   'callback': 'ale#handlers#go#Handler',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
 \   'output_stream': 'both',
 \   'lint_file': 1,
 \})

ale_linters/go/gotype.vim

@@ -1,20 +0,0 @@
-" Author: Jelte Fennema <github-public@jeltef.nl>
-" Description: gotype for Go files
-
-function! ale_linters#go#gotype#GetCommand(buffer) abort
-    if expand('#' . a:buffer . ':p') =~# '_test\.go$'
-        return
-    endif
-
-
-    return ale#path#BufferCdString(a:buffer) . ' gotype .'
-endfunction
-
-call ale#linter#Define('go', {
-\   'name': 'gotype',
-\   'output_stream': 'stderr',
-\   'executable': 'gotype',
-\   'command_callback': 'ale_linters#go#gotype#GetCommand',
-\   'callback': 'ale#handlers#go#Handler',
-\   'lint_file': 1,
-\})

ale_linters/go/govet.vim

@@ -1,18 +1,10 @@
 " Author: neersighted <bjorn@neersighted.com>
 " Description: go vet for Go files
-"
-" Author: John Eikenberry <jae@zhar.net>
-" Description: updated to work with go1.10
-
-function! ale_linters#go#govet#GetCommand(buffer) abort
-    return ale#path#BufferCdString(a:buffer) . ' go vet .'
-endfunction
 
 call ale#linter#Define('go', {
 \   'name': 'go vet',
 \   'output_stream': 'stderr',
 \   'executable': 'go',
-\   'command_callback': 'ale_linters#go#govet#GetCommand',
+\   'command': 'go vet %t',
-\   'callback': 'ale#handlers#go#Handler',
+\   'callback': 'ale#handlers#unix#HandleAsError',
-\   'lint_file': 1,
 \})

ale_linters/go/staticcheck.vim

@@ -1,33 +1,11 @@
 " Author: Ben Reedy <https://github.com/breed808>
 " Description: staticcheck for Go files
 
-call ale#Set('go_staticcheck_options', '')
-call ale#Set('go_staticcheck_lint_package', 0)
-
-function! ale_linters#go#staticcheck#GetCommand(buffer) abort
-    let l:filename = expand('#' . a:buffer . ':t')
-    let l:options = ale#Var(a:buffer, 'go_staticcheck_options')
-    let l:lint_package = ale#Var(a:buffer, 'go_staticcheck_lint_package')
-
-    " BufferCdString is used so that we can be sure the paths output from
-    " staticcheck can be calculated to absolute paths in the Handler
-    if l:lint_package
-        return ale#path#BufferCdString(a:buffer)
-        \   . 'staticcheck'
-        \   . (!empty(l:options) ? ' ' . l:options : '') . ' .'
-    endif
-
-    return ale#path#BufferCdString(a:buffer)
-    \   . 'staticcheck'
-    \   . (!empty(l:options) ? ' ' . l:options : '')
-    \   . ' ' . ale#Escape(l:filename)
-endfunction
-
 call ale#linter#Define('go', {
 \   'name': 'staticcheck',
 \   'executable': 'staticcheck',
-\   'command_callback': 'ale_linters#go#staticcheck#GetCommand',
+\   'command': 'staticcheck %s',
-\   'callback': 'ale#handlers#go#Handler',
+\   'callback': 'ale#handlers#unix#HandleAsWarning',
 \   'output_stream': 'both',
 \   'lint_file': 1,
 \})

ale_linters/handlebars/embertemplatelint.vim

@@ -2,7 +2,7 @@
 " Description: Ember-template-lint for checking Handlebars files
 
 call ale#Set('handlebars_embertemplatelint_executable', 'ember-template-lint')
-call ale#Set('handlebars_embertemplatelint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('handlebars_embertemplatelint_use_global', 0)
 
 function! ale_linters#handlebars#embertemplatelint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'handlebars_embertemplatelint', [

ale_linters/haskell/ghc.vim

@@ -1,18 +1,10 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: ghc for Haskell files
 
-call ale#Set('haskell_ghc_options', '-fno-code -v0')
-
-function! ale_linters#haskell#ghc#GetCommand(buffer) abort
-    return 'ghc '
-    \   . ale#Var(a:buffer, 'haskell_ghc_options')
-    \   . ' %t'
-endfunction
-
 call ale#linter#Define('haskell', {
 \   'name': 'ghc',
 \   'output_stream': 'stderr',
 \   'executable': 'ghc',
-\   'command_callback': 'ale_linters#haskell#ghc#GetCommand',
+\   'command': 'ghc -fno-code -v0 %t',
 \   'callback': 'ale#handlers#haskell#HandleGHCFormat',
 \})

ale_linters/haskell/hdevtools.vim

@@ -2,7 +2,7 @@
 " Description: hdevtools for Haskell files
 
 call ale#Set('haskell_hdevtools_executable', 'hdevtools')
-call ale#Set('haskell_hdevtools_options', get(g:, 'hdevtools_options', '-g -Wall'))
+call ale#Set('haskell_hdevtools_options', '-g -Wall')
 
 function! ale_linters#haskell#hdevtools#GetExecutable(buffer) abort
     return ale#Var(a:buffer, 'haskell_hdevtools_executable')

ale_linters/html/htmlhint.vim

@@ -1,9 +1,9 @@
 " Author: KabbAmine <amine.kabb@gmail.com>, deathmaz <00maz1987@gmail.com>, diartyz <diartyz@gmail.com>
 " Description: HTMLHint for checking html files
 
-call ale#Set('html_htmlhint_options', '')
+call ale#Set('html_htmlhint_options', '--format=unix')
 call ale#Set('html_htmlhint_executable', 'htmlhint')
-call ale#Set('html_htmlhint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('html_htmlhint_use_global', 0)
 
 function! ale_linters#html#htmlhint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'html_htmlhint', [
@@ -12,22 +12,9 @@ function! ale_linters#html#htmlhint#GetExecutable(buffer) abort
 endfunction
 
 function! ale_linters#html#htmlhint#GetCommand(buffer) abort
-    let l:options = ale#Var(a:buffer, 'html_htmlhint_options')
+    return ale_linters#html#htmlhint#GetExecutable(a:buffer)
-    let l:config = l:options !~# '--config'
+    \   . ' ' . ale#Var(a:buffer, 'html_htmlhint_options')
-    \   ? ale#path#FindNearestFile(a:buffer, '.htmlhintrc')
+    \   . ' %t'
-    \   : ''
-
-    if !empty(l:config)
-        let l:options .= ' --config ' . ale#Escape(l:config)
-    endif
-
-    if !empty(l:options)
-        let l:options = substitute(l:options, '--format=unix', '', '')
-    endif
-
-    return ale#Escape(ale_linters#html#htmlhint#GetExecutable(a:buffer))
-    \   . (!empty(l:options) ? ' ' . l:options : '')
-    \   . ' --format=unix %t'
 endfunction
 
 call ale#linter#Define('html', {

ale_linters/html/tidy.vim

@@ -1,8 +1,11 @@
 " Author: KabbAmine <amine.kabb@gmail.com>
 " Description: This file adds support for checking HTML code with tidy.
 
+" CLI options
 let g:ale_html_tidy_executable = get(g:, 'ale_html_tidy_executable', 'tidy')
-let g:ale_html_tidy_options = get(g:, 'ale_html_tidy_options', '-q -e -language en')
+" Look for the old _args variable first.
+let s:default_options = get(g:, 'ale_html_tidy_args', '-q -e -language en')
+let g:ale_html_tidy_options = get(g:, 'ale_html_tidy_options', s:default_options)
 
 function! ale_linters#html#tidy#GetCommand(buffer) abort
     " Specify file encoding in options
@@ -22,16 +25,8 @@ function! ale_linters#html#tidy#GetCommand(buffer) abort
     \   'utf-8':        '-utf8',
     \ }, &fileencoding, '-utf8')
 
-    " On macOS, old tidy (released on 31 Oct 2006) is installed. It does not
-    " consider HTML5 so we should avoid it.
-    let l:executable = ale#Var(a:buffer, 'html_tidy_executable')
-    if has('mac') && l:executable is# 'tidy' && exists('*exepath')
-    \  && exepath(l:executable) is# '/usr/bin/tidy'
-        return ''
-    endif
-
     return printf('%s %s %s -',
-    \   l:executable,
+    \   ale#Var(a:buffer, 'html_tidy_executable'),
     \   ale#Var(a:buffer, 'html_tidy_options'),
     \   l:file_encoding
     \)

ale_linters/java/javac.vim

@@ -3,9 +3,8 @@
 
 let s:classpath_sep = has('unix') ? ':' : ';'
 
-call ale#Set('java_javac_executable', 'javac')
+let g:ale_java_javac_options = get(g:, 'ale_java_javac_options', '')
-call ale#Set('java_javac_options', '')
+let g:ale_java_javac_classpath = get(g:, 'ale_java_javac_classpath', '')
-call ale#Set('java_javac_classpath', '')
 
 function! ale_linters#java#javac#GetImportPaths(buffer) abort
     let l:pom_path = ale#path#FindNearestFile(a:buffer, 'pom.xml')
@@ -36,10 +35,6 @@ function! s:BuildClassPathOption(buffer, import_paths) abort
     \   : ''
 endfunction
 
-function! ale_linters#java#javac#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'java_javac_executable')
-endfunction
-
 function! ale_linters#java#javac#GetCommand(buffer, import_paths) abort
     let l:cp_option = s:BuildClassPathOption(a:buffer, a:import_paths)
     let l:sp_option = ''
@@ -77,13 +72,11 @@ 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)
-    let l:executable = ale_linters#java#javac#GetExecutable(a:buffer)
 
     " Always run javac from the directory the file is in, so we can resolve
     " relative paths correctly.
     return ale#path#BufferCdString(a:buffer)
-    \ . ale#Escape(l:executable)
+    \ . 'javac -Xlint'
-    \ . ' -Xlint'
     \ . ' ' . l:cp_option
     \ . ' ' . l:sp_option
     \ . ' -d ' . ale#Escape(l:class_file_directory)
@@ -126,7 +119,7 @@ endfunction
 
 call ale#linter#Define('java', {
 \   'name': 'javac',
-\   'executable_callback': 'ale_linters#java#javac#GetExecutable',
+\   'executable': 'javac',
 \   'command_chain': [
 \       {'callback': 'ale_linters#java#javac#GetImportPaths', 'output_stream': 'stdout'},
 \       {'callback': 'ale_linters#java#javac#GetCommand', 'output_stream': 'stderr'},

ale_linters/java/pmd.vim

@@ -1,36 +0,0 @@
-" Author: Johannes Wienke <languitar@semipol.de>
-" Description: PMD for Java files
-
-function! ale_linters#java#pmd#Handle(buffer, lines) abort
-    let l:pattern = '"\(\d\+\)",".\+","\(.\+\)","\(\d\+\)","\(\d\+\)","\(.\+\)","\(.\+\)","\(.\+\)"$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        call add(l:output, {
-        \   'type': 'W',
-        \   'lnum': l:match[4] + 0,
-        \   'text': l:match[5],
-        \   'code': l:match[6] . ' - ' . l:match[7],
-        \})
-    endfor
-
-    return l:output
-endfunction
-
-function! ale_linters#java#pmd#GetCommand(buffer) abort
-    return 'pmd '
-    \ . ale#Var(a:buffer, 'java_pmd_options')
-    \ . ' -f csv'
-    \ . ' -d %t'
-endfunction
-
-if !exists('g:ale_java_pmd_options')
-    let g:ale_java_pmd_options = '-R category/java/bestpractices.xml'
-endif
-
-call ale#linter#Define('java', {
-\   'name': 'pmd',
-\   'executable': 'pmd',
-\   'command_callback': 'ale_linters#java#pmd#GetCommand',
-\   'callback': 'ale_linters#java#pmd#Handle',
-\})

ale_linters/javascript/eslint.vim

@@ -3,7 +3,6 @@
 
 call ale#linter#Define('javascript', {
 \   'name': 'eslint',
-\   'output_stream': 'both',
 \   'executable_callback': 'ale#handlers#eslint#GetExecutable',
 \   'command_callback': 'ale#handlers#eslint#GetCommand',
 \   'callback': 'ale#handlers#eslint#Handle',

ale_linters/javascript/flow.vim

@@ -4,8 +4,7 @@
 
 call ale#Set('javascript_flow_executable', 'flow')
 call ale#Set('javascript_flow_use_home_config', 0)
-call ale#Set('javascript_flow_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('javascript_flow_use_global', 0)
-call ale#Set('javascript_flow_use_respect_pragma', 1)
 
 function! ale_linters#javascript#flow#GetExecutable(buffer) abort
     let l:flow_config = ale#path#FindNearestFile(a:buffer, '.flowconfig')
@@ -48,8 +47,8 @@ function! ale_linters#javascript#flow#GetCommand(buffer, version_lines) abort
 
     " If we can parse the version number, then only use --respect-pragma
     " if the version is >= 0.36.0, which added the argument.
-    let l:use_respect_pragma = ale#Var(a:buffer, 'javascript_flow_use_respect_pragma')
+    let l:use_respect_pragma = empty(l:version)
-    \   && (empty(l:version) || ale#semver#GTE(l:version, [0, 36]))
+    \   || ale#semver#GTE(l:version, [0, 36])
 
     return ale#Escape(l:executable)
     \   . ' check-contents'

ale_linters/javascript/jscs.vim

@@ -2,7 +2,7 @@
 " Description: jscs for JavaScript files
 
 call ale#Set('javascript_jscs_executable', 'jscs')
-call ale#Set('javascript_jscs_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('javascript_jscs_use_global', 0)
 
 function! ale_linters#javascript#jscs#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_jscs', [

ale_linters/javascript/jshint.vim

@@ -2,7 +2,7 @@
 " Description: JSHint for Javascript files
 
 call ale#Set('javascript_jshint_executable', 'jshint')
-call ale#Set('javascript_jshint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('javascript_jshint_use_global', 0)
 
 function! ale_linters#javascript#jshint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'javascript_jshint', [

ale_linters/javascript/standard.vim

@@ -2,7 +2,7 @@
 " Description: standardjs for JavaScript files
 
 call ale#Set('javascript_standard_executable', 'standard')
-call ale#Set('javascript_standard_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('javascript_standard_use_global', 0)
 call ale#Set('javascript_standard_options', '')
 
 function! ale_linters#javascript#standard#GetExecutable(buffer) abort

ale_linters/javascript/tsserver.vim

@@ -1,26 +0,0 @@
-" Author: Chaucerbao, w0rp <devw0rp@gmail.com>
-" Description: tsserver integration for ALE
-
-call ale#Set('javascript_tsserver_executable', 'tsserver')
-call ale#Set('javascript_tsserver_config_path', '')
-call ale#Set('javascript_tsserver_use_global', get(g:, 'ale_use_global_executables', 0))
-
-" These functions need to be defined just to comply with the API for LSP.
-function! ale_linters#javascript#tsserver#GetProjectRoot(buffer) abort
-    return ''
-endfunction
-
-function! ale_linters#javascript#tsserver#GetExecutable(buffer) abort
-    return ale#node#FindExecutable(a:buffer, 'javascript_tsserver', [
-    \   'node_modules/.bin/tsserver',
-    \])
-endfunction
-
-call ale#linter#Define('javascript', {
-\   'name': 'tsserver',
-\   'lsp': 'tsserver',
-\   'executable_callback': 'ale_linters#javascript#tsserver#GetExecutable',
-\   'command_callback': 'ale_linters#javascript#tsserver#GetExecutable',
-\   'project_root_callback': 'ale_linters#javascript#tsserver#GetProjectRoot',
-\   'language': '',
-\})

ale_linters/javascript/xo.vim

@@ -2,7 +2,7 @@
 " Description: xo for JavaScript files
 
 call ale#Set('javascript_xo_executable', 'xo')
-call ale#Set('javascript_xo_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('javascript_xo_use_global', 0)
 call ale#Set('javascript_xo_options', '')
 
 function! ale_linters#javascript#xo#GetExecutable(buffer) abort

ale_linters/less/lessc.vim

@@ -3,7 +3,7 @@
 
 call ale#Set('less_lessc_executable', 'lessc')
 call ale#Set('less_lessc_options', '')
-call ale#Set('less_lessc_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('less_lessc_use_global', 0)
 
 function! ale_linters#less#lessc#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'less_lessc', [

ale_linters/less/stylelint.vim

@@ -2,7 +2,7 @@
 
 call ale#Set('less_stylelint_executable', 'stylelint')
 call ale#Set('less_stylelint_options', '')
-call ale#Set('less_stylelint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('less_stylelint_use_global', 0)
 
 function! ale_linters#less#stylelint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'less_stylelint', [

ale_linters/lua/luac.vim

@@ -1,40 +0,0 @@
-" Author: Jon Xie https://github.com/xiejiangzhi
-" Description: luac linter for lua files
-
-call ale#Set('lua_luac_executable', 'luac')
-
-function! ale_linters#lua#luac#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'lua_luac_executable')
-endfunction
-
-function! ale_linters#lua#luac#GetCommand(buffer) abort
-    let l:executable = ale_linters#lua#luac#GetExecutable(a:buffer)
-    return ale#Escape(l:executable) . ' -p - '
-endfunction
-
-function! ale_linters#lua#luac#Handle(buffer, lines) abort
-    " Matches patterns line the following:
-    "
-    " luac: stdin:5: '=' expected near ')'
-    " luac: stdin:8: ')' expected (to close '(' at line 6) near '123'
-    let l:pattern = '\v^.*:(\d+): (.+)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        call add(l:output, {
-        \   'lnum': l:match[1] + 0,
-        \   'type': 'E',
-        \   'text': l:match[2],
-        \})
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('lua', {
-\   'name': 'luac',
-\   'executable_callback': 'ale_linters#lua#luac#GetExecutable',
-\   'command_callback': 'ale_linters#lua#luac#GetCommand',
-\   'output_stream': 'stderr',
-\   'callback': 'ale_linters#lua#luac#Handle',
-\})

ale_linters/markdown/markdownlint.vim

@@ -1,11 +0,0 @@
-" Author: Ty-Lucas Kelley <tylucaskelley@gmail.com>
-" Description: Adds support for markdownlint
-
-call ale#linter#Define('markdown', {
-    \ 'name': 'markdownlint',
-    \ 'executable': 'markdownlint',
-    \ 'lint_file': 1,
-    \ 'output_stream': 'both',
-    \ 'command': 'markdownlint %s',
-    \ 'callback': 'ale#handlers#markdownlint#Handle'
-\ })

ale_linters/markdown/mdl.vim

@@ -1,24 +1,5 @@
-" Author: Steve Dignam <steve@dignam.xyz>, Josh Leeb-du Toit <joshleeb.com>
+" Author: Steve Dignam <steve@dignam.xyz>
-" Description: Support for mdl, a markdown linter.
+" Description: Support for mdl, a markdown linter
-
-call ale#Set('markdown_mdl_executable', 'mdl')
-call ale#Set('markdown_mdl_options', '')
-
-function! ale_linters#markdown#mdl#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'markdown_mdl_executable')
-endfunction
-
-function! ale_linters#markdown#mdl#GetCommand(buffer) abort
-    let l:executable = ale_linters#markdown#mdl#GetExecutable(a:buffer)
-    let l:exec_args = l:executable =~? 'bundle$'
-    \   ? ' exec mdl'
-    \   : ''
-
-    let l:options = ale#Var(a:buffer, 'markdown_mdl_options')
-
-    return ale#Escape(l:executable) . l:exec_args
-    \   . (!empty(l:options) ? ' ' . l:options : '')
-endfunction
 
 function! ale_linters#markdown#mdl#Handle(buffer, lines) abort
     " matches: '(stdin):173: MD004 Unordered list style'
@@ -38,7 +19,7 @@ endfunction
 
 call ale#linter#Define('markdown', {
 \   'name': 'mdl',
-\   'executable_callback': 'ale_linters#markdown#mdl#GetExecutable',
+\   'executable': 'mdl',
-\   'command_callback': 'ale_linters#markdown#mdl#GetCommand',
+\   'command': 'mdl',
 \   'callback': 'ale_linters#markdown#mdl#Handle'
 \})

ale_linters/markdown/remark_lint.vim

@@ -1,24 +1,18 @@
-" Author rhysd https://rhysd.github.io/, Dirk Roorda (dirkroorda), Adrián González Rus (@adrigzr)
+" 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'
-    " matches: '  18:71-19:1  error  Missing new line after list item  list-item-spacing  remark-lint',
+    let l:pattern = '^ \+\(\d\+\):\(\d\+\)  \(warning\|error\)  \(.\+\)$'
-    let l:pattern = '^ \+\(\d\+\):\(\d\+\)\(-\(\d\+\):\(\d\+\)\)\?  \(warning\|error\)  \(.\+\)$'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:item = {
+        call add(l:output, {
         \   'lnum': l:match[1] + 0,
         \   'col': l:match[2] + 0,
-        \   'type': l:match[6] is# 'error' ? 'E' : 'W',
+        \   'type': l:match[3] is# 'error' ? 'E' : 'W',
-        \   'text': l:match[7],
+        \   'text': l:match[4],
-        \}
+        \})
-        if l:match[3] isnot# ''
-            let l:item.end_lnum = l:match[4] + 0
-            let l:item.end_col = l:match[5] + 0
-        endif
-        call add(l:output, l:item)
     endfor
 
     return l:output

ale_linters/markdown/textlint.vim

@@ -1,9 +0,0 @@
-" Author: tokida https://rouger.info, Yasuhiro Kiyota <yasuhiroki.duck@gmail.com>
-" Description: textlint, a proofreading tool (https://textlint.github.io/)
-
-call ale#linter#Define('markdown', {
-\   'name': 'textlint',
-\   'executable_callback': 'ale#handlers#textlint#GetExecutable',
-\   'command_callback': 'ale#handlers#textlint#GetCommand',
-\   'callback': 'ale#handlers#textlint#HandleTextlintOutput',
-\})

ale_linters/mercury/mmc.vim

@@ -1,45 +0,0 @@
-" Author: stewy33 <slocumstewy@gmail.com>
-" Description: Lints mercury files using mmc
-
-call ale#Set('mercury_mmc_executable', 'mmc')
-call ale#Set('mercury_mmc_options', '--make --output-compile-error-lines 100')
-
-function! ale_linters#mercury#mmc#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'mercury_mmc_executable')
-endfunction
-
-function! ale_linters#mercury#mmc#GetCommand(buffer) abort
-    let l:module_name = expand('#' . a:buffer . ':t:r')
-
-    return ale#path#BufferCdString(a:buffer)
-    \ . ale_linters#mercury#mmc#GetExecutable(a:buffer)
-    \ . ' --errorcheck-only '
-    \ . ale#Var(a:buffer, 'mercury_mmc_options')
-    \ . ' ' . l:module_name
-endfunction
-
-function! ale_linters#mercury#mmc#Handle(buffer, lines) abort
-    " output format
-    " <filename>:<line>:   <issue type>: <message>
-    let l:pattern = '\v^\w+\.m:(\d+):\s+([W|w]arning|.*[E|e]rror.*): (.*)'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        call add(l:output, {
-        \   'lnum': substitute(l:match[1], '\v^0*', '', '') + 0,
-        \   'type': l:match[2][0] =~? 'W' ? 'W' : 'E',
-        \   'text': l:match[2] . ': ' . l:match[3]
-        \})
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('mercury', {
-\   'name': 'mmc',
-\   'output_stream': 'stderr',
-\   'executable_callback': 'ale_linters#mercury#mmc#GetExecutable',
-\   'command_callback': 'ale_linters#mercury#mmc#GetCommand',
-\   'callback': 'ale_linters#mercury#mmc#Handle',
-\   'lint_file': 1,
-\})

ale_linters/nasm/nasm.vim

@@ -1,50 +0,0 @@
-" Author: Oyvind Ingvaldsen <oyvind.ingvaldsen@gmail.com>
-" Description: NASM linter for asmsyntax nasm.
-
-call ale#Set('nasm_nasm_executable', 'nasm')
-call ale#Set('nasm_nasm_options', '')
-
-function! ale_linters#nasm#nasm#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'nasm_nasm_executable')
-endfunction
-
-function! ale_linters#nasm#nasm#GetOptions(buffer) abort
-    return ale#Var(a:buffer, 'nasm_nasm_options')
-endfunction
-
-function! ale_linters#nasm#nasm#GetCommand(buffer) abort
-    " Note that NASM require a trailing slash to the -I option.
-    let l:executable = ale#Escape(ale_linters#nasm#nasm#GetExecutable(a:buffer))
-    let l:separator = has('win32') ? '\' : '/'
-    let l:path = ale#Escape(fnamemodify(bufname(a:buffer), ':p:h') . l:separator)
-    let l:options = ale_linters#nasm#nasm#GetOptions(a:buffer)
-
-    return l:executable
-    \   . ' -X gnu'
-    \   . ' -I ' . l:path
-    \   . ' ' . l:options
-    \   . ' %s'
-endfunction
-
-function! ale_linters#nasm#nasm#Handle(buffer, lines) abort
-    " Note that we treat 'fatal' as errors.
-    let l:pattern = '^.\+:\(\d\+\): \([^:]\+\): \(.\+\)$'
-    let l:output = []
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        call add(l:output, {
-        \ 'lnum': l:match[1] + 0,
-        \ 'type': l:match[2] =~? 'error\|fatal' ? 'E' : 'W',
-        \ 'text': l:match[3],
-        \})
-    endfor
-    return l:output
-endfunction
-
-call ale#linter#Define('nasm', {
-\   'name': 'nasm',
-\   'executable': 'nasm',
-\   'output_stream': 'stderr',
-\   'lint_file': 1,
-\   'command_callback': 'ale_linters#nasm#nasm#GetCommand',
-\   'callback': 'ale_linters#nasm#nasm#Handle',
-\})

ale_linters/ocaml/ols.vim

@@ -2,7 +2,7 @@
 " Description: A language server for OCaml
 
 call ale#Set('ocaml_ols_executable', 'ocaml-language-server')
-call ale#Set('ocaml_ols_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('ocaml_ols_use_global', 0)
 
 call ale#linter#Define('ocaml', {
 \   'name': 'ols',

ale_linters/perl/perl.vim

@@ -27,20 +27,12 @@ function! ale_linters#perl#perl#Handle(buffer, lines) abort
     let l:output = []
     let l:basename = expand('#' . a:buffer . ':t')
 
-    let l:type = 'E'
-    if a:lines[-1] =~# 'syntax OK'
-        let l:type = 'W'
-    endif
-
-    let l:seen = {}
-
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
         let l:line = l:match[3]
-        let l:file = l:match[2]
         let l:text = l:match[1]
+        let l:type = 'E'
 
-        if ale#path#IsBufferPath(a:buffer, l:file)
+        if ale#path#IsBufferPath(a:buffer, l:match[2])
-        \ && !has_key(l:seen,l:line)
         \ && (
         \   l:text isnot# 'BEGIN failed--compilation aborted'
         \   || empty(l:output)
@@ -51,8 +43,6 @@ function! ale_linters#perl#perl#Handle(buffer, lines) abort
             \   'text': l:text,
             \   'type': l:type,
             \})
-
-            let l:seen[l:line] = 1
         endif
     endfor
 

ale_linters/perl/perlcritic.vim

@@ -18,9 +18,9 @@ function! ale_linters#perl#perlcritic#GetExecutable(buffer) abort
 endfunction
 
 function! ale_linters#perl#perlcritic#GetProfile(buffer) abort
+
     " first see if we've been overridden
     let l:profile = ale#Var(a:buffer, 'perl_perlcritic_profile')
-
     if l:profile is? ''
         return ''
     endif
@@ -31,7 +31,6 @@ endfunction
 
 function! ale_linters#perl#perlcritic#GetCommand(buffer) abort
     let l:critic_verbosity = '%l:%c %m\n'
-
     if ale#Var(a:buffer, 'perl_perlcritic_showrules')
         let l:critic_verbosity = '%l:%c %m [%p]\n'
     endif
@@ -39,11 +38,17 @@ function! ale_linters#perl#perlcritic#GetCommand(buffer) abort
     let l:profile = ale_linters#perl#perlcritic#GetProfile(a:buffer)
     let l:options = ale#Var(a:buffer, 'perl_perlcritic_options')
 
-    return ale#Escape(ale_linters#perl#perlcritic#GetExecutable(a:buffer))
+    let l:command = ale#Escape(ale_linters#perl#perlcritic#GetExecutable(a:buffer))
-    \   . ' --verbose ' . ale#Escape(l:critic_verbosity)
+    \   . " --verbose '". l:critic_verbosity . "' --nocolor"
-    \   . ' --nocolor'
+
-    \   . (!empty(l:profile) ? ' --profile ' . ale#Escape(l:profile) : '')
+    if l:profile isnot? ''
-    \   . (!empty(l:options) ? ' ' . l:options : '')
+        let l:command .= ' --profile ' . ale#Escape(l:profile)
+    endif
+    if l:options isnot? ''
+        let l:command .= ' ' . l:options
+    endif
+
+    return l:command
 endfunction
 
 

ale_linters/php/langserver.vim

@@ -2,7 +2,7 @@
 " Description: PHP Language server integration for ALE
 
 call ale#Set('php_langserver_executable', 'php-language-server.php')
-call ale#Set('php_langserver_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('php_langserver_use_global', 0)
 
 function! ale_linters#php#langserver#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'php_langserver', [
@@ -14,6 +14,10 @@ function! ale_linters#php#langserver#GetCommand(buffer) abort
     return 'php ' . ale#Escape(ale_linters#php#langserver#GetExecutable(a:buffer))
 endfunction
 
+function! ale_linters#php#langserver#GetLanguage(buffer) abort
+    return 'php'
+endfunction
+
 function! ale_linters#php#langserver#GetProjectRoot(buffer) abort
     let l:git_path = ale#path#FindNearestDirectory(a:buffer, '.git')
 
@@ -25,6 +29,6 @@ call ale#linter#Define('php', {
 \   'lsp': 'stdio',
 \   'executable_callback': 'ale_linters#php#langserver#GetExecutable',
 \   'command_callback': 'ale_linters#php#langserver#GetCommand',
-\   'language': 'php',
+\   'language_callback': 'ale_linters#php#langserver#GetLanguage',
 \   'project_root_callback': 'ale_linters#php#langserver#GetProjectRoot',
 \})

ale_linters/php/phan.vim

@@ -1,65 +1,28 @@
-" Author: diegoholiveira <https://github.com/diegoholiveira>, haginaga <https://github.com/haginaga>
+" Author: diegoholiveira <https://github.com/diegoholiveira>
 " Description: static analyzer for PHP
 
 " Define the minimum severity
 let g:ale_php_phan_minimum_severity = get(g:, 'ale_php_phan_minimum_severity', 0)
 
-let g:ale_php_phan_executable = get(g:, 'ale_php_phan_executable', 'phan')
-let g:ale_php_phan_use_client = get(g:, 'ale_php_phan_use_client', 0)
-
-function! ale_linters#php#phan#GetExecutable(buffer) abort
-    let l:executable = ale#Var(a:buffer, 'php_phan_executable')
-
-    if ale#Var(a:buffer, 'php_phan_use_client') == 1 && l:executable is# 'phan'
-        let l:executable = 'phan_client'
-    endif
-
-    return l:executable
-endfunction
-
 function! ale_linters#php#phan#GetCommand(buffer) abort
-    if ale#Var(a:buffer, 'php_phan_use_client') == 1
+    return 'phan -y '
-        let l:args = '-l '
-        \   . ' %s'
-    else
-        let l:args = '-y '
     \   . ale#Var(a:buffer, 'php_phan_minimum_severity')
     \   . ' %s'
-    endif
-
-    let l:executable = ale_linters#php#phan#GetExecutable(a:buffer)
-
-    return ale#Escape(l:executable) . ' ' . l:args
 endfunction
 
 function! ale_linters#php#phan#Handle(buffer, lines) abort
     " Matches against lines like the following:
-    if ale#Var(a:buffer, 'php_phan_use_client') == 1
+    "
-        " Phan error: ERRORTYPE: message in /path/to/some-filename.php on line nnn
-        let l:pattern = '^Phan error: \(\w\+\): \(.\+\) in \(.\+\) on line \(\d\+\)$'
-    else
     " /path/to/some-filename.php:18 ERRORTYPE message
     let l:pattern = '^.*:\(\d\+\)\s\(\w\+\)\s\(.\+\)$'
-    endif
-
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        if ale#Var(a:buffer, 'php_phan_use_client') == 1
+        call add(l:output, {
-            let l:dict = {
-            \   'lnum': l:match[4] + 0,
-            \   'text': l:match[2],
-            \   'type': 'W',
-            \}
-        else
-            let l:dict = {
         \   'lnum': l:match[1] + 0,
         \   'text': l:match[3],
         \   'type': 'W',
-            \}
+        \})
-        endif
-
-        call add(l:output, l:dict)
     endfor
 
     return l:output
@@ -67,7 +30,7 @@ endfunction
 
 call ale#linter#Define('php', {
 \   'name': 'phan',
-\   'executable_callback': 'ale_linters#php#phan#GetExecutable',
+\   'executable': 'phan',
 \   'command_callback': 'ale_linters#php#phan#GetCommand',
 \   'callback': 'ale_linters#php#phan#Handle',
 \})

ale_linters/php/phpcs.vim

@@ -4,7 +4,7 @@
 let g:ale_php_phpcs_standard = get(g:, 'ale_php_phpcs_standard', '')
 
 call ale#Set('php_phpcs_executable', 'phpcs')
-call ale#Set('php_phpcs_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('php_phpcs_use_global', 0)
 
 function! ale_linters#php#phpcs#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'php_phpcs', [

ale_linters/po/alex.vim

@@ -1,11 +0,0 @@
-" Author: Cian Butler https://github.com/butlerx
-" Description: alex for PO files
-
-call ale#linter#Define('po', {
-\   'name': 'alex',
-\   'executable': 'alex',
-\   'command': 'alex %s -t',
-\   'output_stream': 'stderr',
-\   'callback': 'ale#handlers#alex#Handle',
-\   'lint_file': 1,
-\})

ale_linters/po/msgfmt.vim

@@ -1,30 +0,0 @@
-" Author: Cian Butler https://github.com/butlerx
-" Description: msgfmt for PO files
-
-function! ale_linters#po#msgfmt#Handle(buffer, lines) abort
-    let l:results = ale#handlers#unix#HandleAsWarning(a:buffer, a:lines)
-    let l:index = 0
-
-    for l:item in l:results
-        if l:index > 0 && l:item.text =~? 'this is the location of the first definition'
-            let l:last_item = l:results[l:index - 1]
-
-            if l:last_item.text =~? 'duplicate message definition'
-                let l:last_item.text = 'duplicate of message at line ' . l:item.lnum
-                let l:item.text = 'first location of duplicate of message at line ' . l:last_item.lnum
-            endif
-        endif
-
-        let l:index += 1
-    endfor
-
-    return l:results
-endfunction
-
-call ale#linter#Define('po', {
-\   'name': 'msgfmt',
-\   'executable': 'msgfmt',
-\   'output_stream': 'stderr',
-\   'command': 'msgfmt --statistics --output-file=- %t',
-\   'callback': 'ale_linters#po#msgfmt#Handle',
-\})

ale_linters/po/proselint.vim

@@ -1,9 +0,0 @@
-" Author: Cian Butler https://github.com/butlerx
-" Description: proselint for PO files
-
-call ale#linter#Define('po', {
-\   'name': 'proselint',
-\   'executable': 'proselint',
-\   'command': 'proselint %t',
-\   'callback': 'ale#handlers#unix#HandleAsWarning',
-\})

ale_linters/po/write-good.vim

@@ -1,9 +0,0 @@
-" Author: Cian Butler https://github.com/butlerx
-" Description: write-good for PO files
-
-call ale#linter#Define('po', {
-\   'name': 'write-good',
-\   'executable_callback': 'ale#handlers#writegood#GetExecutable',
-\   'command_callback': 'ale#handlers#writegood#GetCommand',
-\   'callback': 'ale#handlers#writegood#Handle',
-\})

ale_linters/pony/ponyc.vim

@@ -1,21 +0,0 @@
-" Description: ponyc linter for pony files
-
-call ale#Set('pony_ponyc_executable', 'ponyc')
-call ale#Set('pony_ponyc_options', '--pass paint')
-
-function! ale_linters#pony#ponyc#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'pony_ponyc_executable')
-endfunction
-
-function! ale_linters#pony#ponyc#GetCommand(buffer) abort
-    return ale#Escape(ale_linters#pony#ponyc#GetExecutable(a:buffer))
-    \   . ' ' . ale#Var(a:buffer, 'pony_ponyc_options')
-endfunction
-
-call ale#linter#Define('pony', {
-\   'name': 'ponyc',
-\   'output_stream': 'stderr',
-\   'executable_callback': 'ale_linters#pony#ponyc#GetExecutable',
-\   'command_callback': 'ale_linters#pony#ponyc#GetCommand',
-\   'callback': 'ale#handlers#pony#HandlePonycFormat',
-\})

ale_linters/proto/protoc_gen_lint.vim

@@ -1,20 +1,12 @@
 " Author: Jeff Willette <jrwillette88@gmail.com>
 " Description: run the protoc-gen-lint plugin for the protoc binary
 
-call ale#Set('proto_protoc_gen_lint_options', '')
-
 function! ale_linters#proto#protoc_gen_lint#GetCommand(buffer) abort
     let l:dirname = expand('#' . a:buffer . ':p:h')
 
-    let l:options = ['-I ' . ale#Escape(l:dirname)]
+    return 'protoc'
-
+    \   . ' -I ' . ale#Escape(l:dirname)
-    if !empty(ale#Var(a:buffer, 'proto_protoc_gen_lint_options'))
+    \   . ' --lint_out=. ' . '%s'
-        let l:options += [ale#Var(a:buffer, 'proto_protoc_gen_lint_options')]
-    endif
-
-    let l:options += ['--lint_out=. ' . '%s']
-
-    return 'protoc' . ' ' . join(l:options)
 endfunction
 
 call ale#linter#Define('proto', {

ale_linters/pug/puglint.vim

@@ -3,7 +3,7 @@
 
 call ale#Set('pug_puglint_options', '')
 call ale#Set('pug_puglint_executable', 'pug-lint')
-call ale#Set('pug_puglint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('pug_puglint_use_global', 0)
 
 function! ale_linters#pug#puglint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'pug_puglint', [

ale_linters/puppet/puppet.vim

@@ -4,15 +4,14 @@ function! ale_linters#puppet#puppet#Handle(buffer, lines) abort
     " Matches patterns like the following:
     " Error: Could not parse for environment production: Syntax error at ':' at /root/puppetcode/modules/nginx/manifests/init.pp:43:12
     " Error: Could not parse for environment production: Syntax error at '='; expected '}' at /root/puppetcode/modules/pancakes/manifests/init.pp:5"
-    " Error: Could not parse for environment production: Syntax error at 'parameter1' (file: /tmp/modules/mariadb/manifests/slave.pp, line: 4, column: 5)
 
-    let l:pattern = '^Error: .*: \(.\+\) \((file:\|at\) .\+\.pp\(, line: \|:\)\(\d\+\)\(, column: \|:\)\=\(\d*\)'
+    let l:pattern = '^Error: .*: \(.\+\) at .\+\.pp:\(\d\+\):\=\(\d*\)'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
         call add(l:output, {
-        \   'lnum': l:match[4] + 0,
+        \   'lnum': l:match[2] + 0,
-        \   'col': l:match[6] + 0,
+        \   'col': l:match[3] + 0,
         \   'text': l:match[1],
         \})
     endfor

ale_linters/pyrex/cython.vim

@@ -1,43 +1,10 @@
-" Author: w0rp <devw0rp@gmail.com>,
+" Author: w0rp <devw0rp@gmail.com>
-" Nicolas Pauss <https://github.com/nicopauss>
 " Description: cython syntax checking for cython files.
 
-call ale#Set('pyrex_cython_executable', 'cython')
-call ale#Set('pyrex_cython_options', '--warning-extra')
-
-function! ale_linters#pyrex#cython#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'pyrex_cython_executable')
-endfunction
-
-function! ale_linters#pyrex#cython#GetCommand(buffer) abort
-    let l:local_dir = ale#Escape(fnamemodify(bufname(a:buffer), ':p:h'))
-
-    return ale#Escape(ale_linters#pyrex#cython#GetExecutable(a:buffer))
-    \   . ' --working ' . l:local_dir . ' --include-dir ' . l:local_dir
-    \   . ' ' . ale#Var(a:buffer, 'pyrex_cython_options')
-    \   . ' --output-file ' . g:ale#util#nul_file . ' %t'
-endfunction
-
-function! ale_linters#pyrex#cython#Handle(buffer, lines) abort
-    let l:pattern = '\v^(\w+: )?[^:]+:(\d+):?(\d+)?:? ?(.+)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        call add(l:output, {
-        \   'lnum': l:match[2] + 0,
-        \   'col': l:match[3] + 0,
-        \   'text': l:match[4],
-        \   'type': l:match[1][0] is# 'w' ? 'W' : 'E',
-        \})
-    endfor
-
-    return l:output
-endfunction
-
 call ale#linter#Define('pyrex', {
 \   'name': 'cython',
 \   'output_stream': 'stderr',
-\   'executable_callback': 'ale_linters#pyrex#cython#GetExecutable',
+\   'executable': 'cython',
-\   'command_callback': 'ale_linters#pyrex#cython#GetCommand',
+\   'command': 'cython --warning-extra -o ' . g:ale#util#nul_file . ' %t',
-\   'callback': 'ale_linters#pyrex#cython#Handle',
+\   'callback': 'ale#handlers#unix#HandleAsError',
 \})

ale_linters/python/flake8.vim

@@ -1,10 +1,14 @@
 " Author: w0rp <devw0rp@gmail.com>
 " Description: flake8 for python files
 
-call ale#Set('python_flake8_executable', 'flake8')
+let g:ale_python_flake8_executable =
-call ale#Set('python_flake8_options', '')
+\   get(g:, 'ale_python_flake8_executable', 'flake8')
-call ale#Set('python_flake8_use_global', get(g:, 'ale_use_global_executables', 0))
+
-call ale#Set('python_flake8_change_directory', 1)
+" Support an old setting as a fallback.
+let s:default_options = get(g:, 'ale_python_flake8_args', '')
+let g:ale_python_flake8_options =
+\   get(g:, 'ale_python_flake8_options', s:default_options)
+let g:ale_python_flake8_use_global = get(g:, 'ale_python_flake8_use_global', 0)
 
 function! s:UsingModule(buffer) abort
     return ale#Var(a:buffer, 'python_flake8_options') =~# ' *-m flake8'
@@ -35,16 +39,9 @@ function! ale_linters#python#flake8#VersionCheck(buffer) abort
 endfunction
 
 function! ale_linters#python#flake8#GetCommand(buffer, version_output) abort
-    let l:cd_string = ale#Var(a:buffer, 'python_flake8_change_directory')
-    \   ? ale#path#BufferCdString(a:buffer)
-    \   : ''
     let l:executable = ale_linters#python#flake8#GetExecutable(a:buffer)
     let l:version = ale#semver#GetVersion(l:executable, a:version_output)
 
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run flake8'
-    \   : ''
-
     " Only include the --stdin-display-name argument if we can parse the
     " flake8 version, and it is recent enough to support it.
     let l:display_name_args = ale#semver#GTE(l:version, [3, 0, 0])
@@ -53,8 +50,7 @@ function! ale_linters#python#flake8#GetCommand(buffer, version_output) abort
 
     let l:options = ale#Var(a:buffer, 'python_flake8_options')
 
-    return l:cd_string
+    return ale#Escape(l:executable)
-    \   . ale#Escape(l:executable) . l:exec_args
     \   . (!empty(l:options) ? ' ' . l:options : '')
     \   . ' --format=default'
     \   . l:display_name_args . ' -'
@@ -109,16 +105,11 @@ function! ale_linters#python#flake8#Handle(buffer, lines) abort
         \   'type': 'W',
         \}
 
-        if l:code[:0] is# 'F'
+        if l:code[:0] is# 'F' || l:code is# 'E999'
-            if l:code isnot# 'F401'
             let l:item.type = 'E'
-            endif
         elseif l:code[:0] is# 'E'
             let l:item.type = 'E'
-
-            if l:code isnot# 'E999' && l:code isnot# 'E112'
             let l:item.sub_type = 'style'
-            endif
         elseif l:code[:0] is# 'W'
             let l:item.sub_type = 'style'
         endif

ale_linters/python/mypy.vim

@@ -1,10 +1,10 @@
 " Author: Keith Smiley <k@keith.so>, w0rp <devw0rp@gmail.com>
 " Description: mypy support for optional python typechecking
 
-call ale#Set('python_mypy_executable', 'mypy')
+let g:ale_python_mypy_executable =
-call ale#Set('python_mypy_ignore_invalid_syntax', 0)
+\   get(g:, 'ale_python_mypy_executable', 'mypy')
-call ale#Set('python_mypy_options', '')
+let g:ale_python_mypy_options = get(g:, 'ale_python_mypy_options', '')
-call ale#Set('python_mypy_use_global', get(g:, 'ale_use_global_executables', 0))
+let g:ale_python_mypy_use_global = get(g:, 'ale_python_mypy_use_global', 0)
 
 function! ale_linters#python#mypy#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_mypy', ['mypy'])
@@ -23,14 +23,10 @@ function! ale_linters#python#mypy#GetCommand(buffer) abort
     let l:dir = s:GetDir(a:buffer)
     let l:executable = ale_linters#python#mypy#GetExecutable(a:buffer)
 
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run mypy'
-    \   : ''
-
     " We have to always switch to an explicit directory for a command so
     " we can know with certainty the base path for the 'filename' keys below.
     return ale#path#CdString(l:dir)
-    \   . ale#Escape(l:executable) . l:exec_args
+    \   . ale#Escape(l:executable)
     \   . ' --show-column-numbers '
     \   . ale#Var(a:buffer, 'python_mypy_options')
     \   . ' --shadow-file %s %t %s'
@@ -49,12 +45,6 @@ function! ale_linters#python#mypy#Handle(buffer, lines) abort
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        " Skip invalid syntax errors if the option is on.
-        if l:match[5] is# 'invalid syntax'
-        \&& ale#Var(a:buffer, 'python_mypy_ignore_invalid_syntax')
-            continue
-        endif
-
         call add(l:output, {
         \   'filename': ale#path#GetAbsPath(l:dir, l:match[1]),
         \   'lnum': l:match[2] + 0,

ale_linters/python/prospector.vim

@@ -7,21 +7,14 @@ let g:ale_python_prospector_executable =
 let g:ale_python_prospector_options =
 \   get(g:, 'ale_python_prospector_options', '')
 
-let g:ale_python_prospector_use_global = get(g:, 'ale_python_prospector_use_global', get(g:, 'ale_use_global_executables', 0))
+let g:ale_python_prospector_use_global = get(g:, 'ale_python_prospector_use_global', 0)
 
 function! ale_linters#python#prospector#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_prospector', ['prospector'])
 endfunction
 
 function! ale_linters#python#prospector#GetCommand(buffer) abort
-    let l:executable = ale_linters#python#prospector#GetExecutable(a:buffer)
+    return ale#Escape(ale_linters#python#prospector#GetExecutable(a:buffer))
-
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run prospector'
-    \   : ''
-
-    return ale#Escape(l:executable)
-    \   . l:exec_args
     \   . ' ' . ale#Var(a:buffer, 'python_prospector_options')
     \   . ' --messages-only --absolute-paths --zero-exit --output-format json'
     \   . ' %s'
@@ -30,10 +23,6 @@ endfunction
 function! ale_linters#python#prospector#Handle(buffer, lines) abort
     let l:output = []
 
-    if empty(a:lines)
-        return []
-    endif
-
     let l:prospector_error = json_decode(join(a:lines, ''))
 
     for l:error in l:prospector_error.messages

ale_linters/python/pycodestyle.vim

@@ -3,20 +3,14 @@
 
 call ale#Set('python_pycodestyle_executable', 'pycodestyle')
 call ale#Set('python_pycodestyle_options', '')
-call ale#Set('python_pycodestyle_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('python_pycodestyle_use_global', 0)
 
 function! ale_linters#python#pycodestyle#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_pycodestyle', ['pycodestyle'])
 endfunction
 
 function! ale_linters#python#pycodestyle#GetCommand(buffer) abort
-    let l:executable = ale_linters#python#pycodestyle#GetExecutable(a:buffer)
+    return ale#Escape(ale_linters#python#pycodestyle#GetExecutable(a:buffer))
-
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run pycodestyle'
-    \   : ''
-
-    return ale#Escape(l:executable) . l:exec_args
     \   . ' '
     \   . ale#Var(a:buffer, 'python_pycodestyle_options')
     \   . ' -'
@@ -50,8 +44,8 @@ function! ale_linters#python#pycodestyle#Handle(buffer, lines) abort
         \   'code': l:match[4],
         \}
 
-        " E999 and E112 are syntax errors.
+        " E999 is not a style error, it's a syntax error.
-        if l:match[4] is# 'E999' || l:match[4] is# 'E112'
+        if l:match[4] is# 'E999'
             unlet l:item.sub_type
         endif
 

ale_linters/python/pyflakes.vim

@@ -2,7 +2,7 @@
 " Description: pyflakes for python files
 
 call ale#Set('python_pyflakes_executable', 'pyflakes')
-call ale#Set('python_pyflakes_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('python_pyflakes_use_global', 0)
 
 function! ale_linters#python#pyflakes#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_pyflakes', ['pyflakes'])
@@ -11,13 +11,7 @@ endfunction
 function! ale_linters#python#pyflakes#GetCommand(buffer) abort
     let l:executable = ale_linters#python#pyflakes#GetExecutable(a:buffer)
 
-    let l:exec_args = l:executable =~? 'pipenv$'
+    return ale#Escape(l:executable) . ' %t'
-    \   ? ' run pyflakes'
-    \   : ''
-
-    return ale#Escape(l:executable)
-    \   . l:exec_args
-    \   . ' %t'
 endfunction
 
 function! ale_linters#python#pyflakes#Handle(buffer, lines) abort

ale_linters/python/pylint.vim

@@ -1,28 +1,20 @@
 " Author: keith <k@keith.so>
 " Description: pylint for python files
 
-call ale#Set('python_pylint_executable', 'pylint')
+let g:ale_python_pylint_executable =
-call ale#Set('python_pylint_options', '')
+\   get(g:, 'ale_python_pylint_executable', 'pylint')
-call ale#Set('python_pylint_use_global', get(g:, 'ale_use_global_executables', 0))
+
-call ale#Set('python_pylint_change_directory', 1)
+let g:ale_python_pylint_options =
+\   get(g:, 'ale_python_pylint_options', '')
+
+let g:ale_python_pylint_use_global = get(g:, 'ale_python_pylint_use_global', 0)
 
 function! ale_linters#python#pylint#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_pylint', ['pylint'])
 endfunction
 
 function! ale_linters#python#pylint#GetCommand(buffer) abort
-    let l:cd_string = ale#Var(a:buffer, 'python_pylint_change_directory')
+    return ale#Escape(ale_linters#python#pylint#GetExecutable(a:buffer))
-    \   ? ale#path#BufferCdString(a:buffer)
-    \   : ''
-
-    let l:executable = ale_linters#python#pylint#GetExecutable(a:buffer)
-
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run pylint'
-    \   : ''
-
-    return l:cd_string
-    \   . ale#Escape(l:executable) . l:exec_args
     \   . ' ' . ale#Var(a:buffer, 'python_pylint_options')
     \   . ' --output-format text --msg-template="{path}:{line}:{column}: {msg_id} ({symbol}) {msg}" --reports n'
     \   . ' %s'
@@ -32,7 +24,7 @@ function! ale_linters#python#pylint#Handle(buffer, lines) abort
     " Matches patterns like the following:
     "
     " test.py:4:4: W0101 (unreachable) Unreachable code
-    let l:pattern = '\v^[a-zA-Z]?:?[^:]+:(\d+):(\d+): ([[:alnum:]]+) \(([^(]*)\) (.*)$'
+    let l:pattern = '\v^[^:]+:(\d+):(\d+): ([[:alnum:]]+) \(([^(]*)\) (.*)$'
     let l:output = []
 
     for l:match in ale#util#GetMatches(a:lines, l:pattern)

ale_linters/python/pyls.vim

@@ -2,7 +2,7 @@
 " Description: A language server for Python
 
 call ale#Set('python_pyls_executable', 'pyls')
-call ale#Set('python_pyls_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('python_pyls_use_global', 0)
 
 function! ale_linters#python#pyls#GetExecutable(buffer) abort
     return ale#python#FindExecutable(a:buffer, 'python_pyls', ['pyls'])
@@ -11,11 +11,11 @@ endfunction
 function! ale_linters#python#pyls#GetCommand(buffer) abort
     let l:executable = ale_linters#python#pyls#GetExecutable(a:buffer)
 
-    let l:exec_args = l:executable =~? 'pipenv$'
+    return ale#Escape(l:executable)
-    \   ? ' run pyls'
+endfunction
-    \   : ''
 
-    return ale#Escape(l:executable) . l:exec_args
+function! ale_linters#python#pyls#GetLanguage(buffer) abort
+    return 'python'
 endfunction
 
 call ale#linter#Define('python', {
@@ -23,7 +23,6 @@ call ale#linter#Define('python', {
 \   'lsp': 'stdio',
 \   'executable_callback': 'ale_linters#python#pyls#GetExecutable',
 \   'command_callback': 'ale_linters#python#pyls#GetCommand',
-\   'language': 'python',
+\   'language_callback': 'ale_linters#python#pyls#GetLanguage',
 \   'project_root_callback': 'ale#python#FindProjectRoot',
-\   'completion_filter': 'ale#completion#python#CompletionItemFilter',
 \})

ale_linters/python/pyre.vim

@@ -1,29 +0,0 @@
-" Author: dsifford <dereksifford@gmail.com>
-" Description: A performant type-checker supporting LSP for Python 3 created by Facebook
-
-call ale#Set('python_pyre_executable', 'pyre')
-call ale#Set('python_pyre_use_global', get(g:, 'ale_use_global_executables', 0))
-
-function! ale_linters#python#pyre#GetExecutable(buffer) abort
-    return ale#python#FindExecutable(a:buffer, 'python_pyre', ['pyre'])
-endfunction
-
-function! ale_linters#python#pyre#GetCommand(buffer) abort
-    let l:executable = ale_linters#python#pyre#GetExecutable(a:buffer)
-
-    let l:exec_args = l:executable =~? 'pipenv$'
-    \   ? ' run pyre persistent'
-    \   : ' persistent'
-
-    return ale#Escape(l:executable) . l:exec_args
-endfunction
-
-call ale#linter#Define('python', {
-\   'name': 'pyre',
-\   'lsp': 'stdio',
-\   'executable_callback': 'ale_linters#python#pyre#GetExecutable',
-\   'command_callback': 'ale_linters#python#pyre#GetCommand',
-\   'language': 'python',
-\   'project_root_callback': 'ale#python#FindProjectRoot',
-\   'completion_filter': 'ale#completion#python#CompletionItemFilter',
-\})

ale_linters/qml/qmlfmt.vim

@@ -1,40 +0,0 @@
-" Author: pylipp (www.github.com/pylipp)
-" Description: qmlfmt for QML files
-
-let g:ale_qml_qmlfmt_executable = get(g:, 'ale_qml_qmlfmt_executable', 'qmlfmt')
-
-function! ale_linters#qml#qmlfmt#GetExecutable(buffer) abort
-    return ale#Var(a:buffer, 'qml_qmlfmt_executable')
-endfunction
-
-function! ale_linters#qml#qmlfmt#GetCommand(buffer) abort
-    return ale#Escape(ale_linters#qml#qmlfmt#GetExecutable(a:buffer))
-    \   . ' -e'
-endfunction
-
-" Find lines like
-" Error:11:1: Expected token `}'
-function! ale_linters#qml#qmlfmt#Handle(buffer, lines) abort
-    let l:pattern = '\v^(Error|Warning):(\d+):(\d+): (.+)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:item = {
-        \   'lnum': l:match[2] + 0,
-        \   'col': l:match[3] + 0,
-        \   'text': l:match[4],
-        \   'type': l:match[1] is# 'Warning' ? 'W' : 'E',
-        \}
-        call add(l:output, l:item)
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('qml', {
-\   'name': 'qmlfmt',
-\   'output_stream': 'stderr',
-\   'executable_callback': 'ale_linters#qml#qmlfmt#GetExecutable',
-\   'command_callback': 'ale_linters#qml#qmlfmt#GetCommand',
-\   'callback': 'ale_linters#qml#qmlfmt#Handle',
-\})

ale_linters/qml/qmllint.vim

@@ -1,29 +0,0 @@
-" Author: pylipp (www.github.com/pylipp)
-" Description: qmllint for QML files
-
-" Find lines like
-" /home/foo_user42/code-base/qml/Screen.qml:11 : Expected token `}'
-function! ale_linters#qml#qmllint#Handle(buffer, lines) abort
-    let l:pattern = '\v^[/_-a-zA-z0-9\. ]+:(\d+) : (.*)$'
-    let l:output = []
-
-    for l:match in ale#util#GetMatches(a:lines, l:pattern)
-        let l:item = {
-        \   'lnum': l:match[1] + 0,
-        \   'col': 0,
-        \   'text': l:match[2],
-        \   'type': 'E',
-        \}
-        call add(l:output, l:item)
-    endfor
-
-    return l:output
-endfunction
-
-call ale#linter#Define('qml', {
-\   'name': 'qmllint',
-\   'output_stream': 'stderr',
-\   'executable': 'qmllint',
-\   'command': 'qmllint %t',
-\   'callback': 'ale_linters#qml#qmllint#Handle',
-\})

ale_linters/r/lintr.vim

@@ -1,29 +1,14 @@
-" Author: Michel Lang <michellang@gmail.com>, w0rp <devw0rp@gmail.com>,
+" Author: Michel Lang <michellang@gmail.com>, w0rp <devw0rp@gmail.com>
-"         Fenner Macrae <fmacrae.dev@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', 'with_defaults()')
+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', 'with_defaults(object_usage_linter = NULL)')
+" \   get(g:, 'ale_r_lintr_options', 'lintr::with_defaults(object_usage_linter = NULL)')
-
-
-let g:ale_r_lintr_lint_package = get(g:, 'ale_r_lintr_lint_package', 0)
 
 function! ale_linters#r#lintr#GetCommand(buffer) abort
-    if ale#Var(a:buffer, 'r_lintr_lint_package')
-        let l:lint_cmd = 'lint_package(cache = FALSE, linters = '
-        \   . ale#Var(a:buffer, 'r_lintr_options') . ')'
-    else
-        let l:lint_cmd = 'lint(cache = FALSE, commandArgs(TRUE), '
-        \   . ale#Var(a:buffer, 'r_lintr_options') . ')'
-    endif
-
-    let l:cmd_string = 'suppressPackageStartupMessages(library(lintr));'
-    \   . l:lint_cmd
-
     return ale#path#BufferCdString(a:buffer)
-    \   . 'Rscript --vanilla -e '
+    \   . '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'))
-    \   . ale#Escape(l:cmd_string) . ' %t'
 endfunction
 
 call ale#linter#Define('r', {

ale_linters/reason/ols.vim

@@ -2,7 +2,7 @@
 " Description: A language server for Reason
 
 call ale#Set('reason_ols_executable', 'ocaml-language-server')
-call ale#Set('reason_ols_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('reason_ols_use_global', 0)
 
 call ale#linter#Define('reason', {
 \   'name': 'ols',

ale_linters/ruby/reek.vim

@@ -4,45 +4,6 @@
 call ale#Set('ruby_reek_show_context', 0)
 call ale#Set('ruby_reek_show_wiki_link', 0)
 
-function! ale_linters#ruby#reek#VersionCheck(buffer) abort
-    " If we have previously stored the version number in a cache, then
-    " don't look it up again.
-    if ale#semver#HasVersion('reek')
-        " Returning an empty string skips this command.
-        return ''
-    endif
-
-    return 'reek --version'
-endfunction
-
-function! ale_linters#ruby#reek#GetCommand(buffer, version_output) abort
-    let l:version = ale#semver#GetVersion('reek', a:version_output)
-
-    " Tell reek what the filename is if the version of reek is new enough.
-    let l:display_name_args = ale#semver#GTE(l:version, [5, 0, 0])
-    \   ? ' --stdin-filename %s'
-    \   : ''
-
-    return 'reek -f json --no-progress --no-color'
-    \   . l:display_name_args
-endfunction
-
-function! s:BuildText(buffer, error) abort
-    let l:parts = []
-
-    if ale#Var(a:buffer, 'ruby_reek_show_context')
-        call add(l:parts, a:error.context)
-    endif
-
-    call add(l:parts, a:error.message)
-
-    if ale#Var(a:buffer, 'ruby_reek_show_wiki_link')
-        call add(l:parts, '[' . a:error.wiki_link . ']')
-    endif
-
-    return join(l:parts, ' ')
-endfunction
-
 function! ale_linters#ruby#reek#Handle(buffer, lines) abort
     let l:output = []
 
@@ -60,12 +21,25 @@ function! ale_linters#ruby#reek#Handle(buffer, lines) abort
     return l:output
 endfunction
 
+function! s:BuildText(buffer, error) abort
+    let l:parts = []
+
+    if ale#Var(a:buffer, 'ruby_reek_show_context')
+        call add(l:parts, a:error.context)
+    endif
+
+    call add(l:parts, a:error.message)
+
+    if ale#Var(a:buffer, 'ruby_reek_show_wiki_link')
+        call add(l:parts, '[' . a:error.wiki_link . ']')
+    endif
+
+    return join(l:parts, ' ')
+endfunction
+
 call ale#linter#Define('ruby', {
 \    'name': 'reek',
 \    'executable': 'reek',
-\   'command_chain': [
+\    'command': 'reek -f json --no-progress --no-color',
-\       {'callback': 'ale_linters#ruby#reek#VersionCheck'},
-\       {'callback': 'ale_linters#ruby#reek#GetCommand'},
-\   ],
 \    'callback': 'ale_linters#ruby#reek#Handle',
 \})

ale_linters/rust/cargo.vim

@@ -1,14 +1,8 @@
-" Author: Daniel Schemala <istjanichtzufassen@gmail.com>,
+" Author: Daniel Schemala <istjanichtzufassen@gmail.com>
-" Ivan Petkov <ivanppetkov@gmail.com>
 " Description: rustc invoked by cargo for rust files
 
 call ale#Set('rust_cargo_use_check', 1)
 call ale#Set('rust_cargo_check_all_targets', 0)
-call ale#Set('rust_cargo_check_examples', 0)
-call ale#Set('rust_cargo_check_tests', 0)
-call ale#Set('rust_cargo_avoid_whole_workspace', 1)
-call ale#Set('rust_cargo_default_feature_behavior', 'default')
-call ale#Set('rust_cargo_include_features', '')
 
 function! ale_linters#rust#cargo#GetCargoExecutable(bufnr) abort
     if ale#path#FindNearestFile(a:bufnr, 'Cargo.toml') isnot# ''
@@ -34,48 +28,11 @@ function! ale_linters#rust#cargo#GetCommand(buffer, version_output) abort
     let l:use_all_targets = l:use_check
     \   && ale#Var(a:buffer, 'rust_cargo_check_all_targets')
     \   && ale#semver#GTE(l:version, [0, 22, 0])
-    let l:use_examples = l:use_check
-    \   && ale#Var(a:buffer, 'rust_cargo_check_examples')
-    \   && ale#semver#GTE(l:version, [0, 22, 0])
-    let l:use_tests = l:use_check
-    \   && ale#Var(a:buffer, 'rust_cargo_check_tests')
-    \   && ale#semver#GTE(l:version, [0, 22, 0])
 
-    let l:include_features = ale#Var(a:buffer, 'rust_cargo_include_features')
+    return 'cargo '
-    if !empty(l:include_features)
-        let l:include_features = ' --features ' . ale#Escape(l:include_features)
-    endif
-
-    let l:avoid_whole_workspace = ale#Var(a:buffer, 'rust_cargo_avoid_whole_workspace')
-    let l:nearest_cargo_prefix = ''
-
-    if l:avoid_whole_workspace
-        let l:nearest_cargo = ale#path#FindNearestFile(a:buffer, 'Cargo.toml')
-        let l:nearest_cargo_dir = fnamemodify(l:nearest_cargo, ':h')
-
-        if l:nearest_cargo_dir isnot# '.'
-            let l:nearest_cargo_prefix = 'cd '. ale#Escape(l:nearest_cargo_dir) .' && '
-        endif
-    endif
-
-    let l:default_feature_behavior = ale#Var(a:buffer, 'rust_cargo_default_feature_behavior')
-    if l:default_feature_behavior is# 'all'
-        let l:include_features = ''
-        let l:default_feature = ' --all-features'
-    elseif l:default_feature_behavior is# 'none'
-        let l:default_feature = ' --no-default-features'
-    else
-        let l:default_feature = ''
-    endif
-
-    return l:nearest_cargo_prefix . 'cargo '
     \   . (l:use_check ? 'check' : 'build')
     \   . (l:use_all_targets ? ' --all-targets' : '')
-    \   . (l:use_examples ? ' --examples' : '')
-    \   . (l:use_tests ? ' --tests' : '')
     \   . ' --frozen --message-format=json -q'
-    \   . l:default_feature
-    \   . l:include_features
 endfunction
 
 call ale#linter#Define('rust', {

ale_linters/rust/rls.vim

@@ -12,11 +12,12 @@ function! ale_linters#rust#rls#GetCommand(buffer) abort
     let l:executable = ale_linters#rust#rls#GetExecutable(a:buffer)
     let l:toolchain = ale#Var(a:buffer, 'rust_rls_toolchain')
 
-    if empty(l:toolchain)
     return ale#Escape(l:executable)
-    else
+    \   . ' +' . ale#Escape(l:toolchain)
-      return ale#Escape(l:executable) . ' +' . ale#Escape(l:toolchain)
+endfunction
-    endif
+
+function! ale_linters#rust#rls#GetLanguage(buffer) abort
+    return 'rust'
 endfunction
 
 function! ale_linters#rust#rls#GetProjectRoot(buffer) abort
@@ -30,6 +31,6 @@ call ale#linter#Define('rust', {
 \   'lsp': 'stdio',
 \   'executable_callback': 'ale_linters#rust#rls#GetExecutable',
 \   'command_callback': 'ale_linters#rust#rls#GetCommand',
-\   'language': 'rust',
+\   'language_callback': 'ale_linters#rust#rls#GetLanguage',
 \   'project_root_callback': 'ale_linters#rust#rls#GetProjectRoot',
 \})

ale_linters/sass/sasslint.vim

@@ -1,9 +1,8 @@
-" Author: KabbAmine - https://github.com/KabbAmine,
+" Author: KabbAmine - https://github.com/KabbAmine
-"   Ben Falconer <ben@falconers.me.uk>
 
 call ale#linter#Define('sass', {
 \   'name': 'sasslint',
 \   'executable': 'sass-lint',
-\   'command_callback': 'ale#handlers#sasslint#GetCommand',
+\   'command': 'sass-lint -v -q -f compact %t',
 \   'callback': 'ale#handlers#css#HandleCSSLintFormat',
 \})

ale_linters/sass/stylelint.vim

@@ -1,7 +1,7 @@
 " Author: diartyz <diartyz@gmail.com>
 
 call ale#Set('sass_stylelint_executable', 'stylelint')
-call ale#Set('sass_stylelint_use_global', get(g:, 'ale_use_global_executables', 0))
+call ale#Set('sass_stylelint_use_global', 0)
 
 function! ale_linters#sass#stylelint#GetExecutable(buffer) abort
     return ale#node#FindExecutable(a:buffer, 'sass_stylelint', [

ale_linters/scala/fsc.vim

@@ -1,29 +0,0 @@
-" Author: Nils Leuzinger - https://github.com/PawkyPenguin
-" Description: Basic scala support using fsc
-"
-function! ale_linters#scala#fsc#GetExecutable(buffer) abort
-    if index(split(getbufvar(a:buffer, '&filetype'), '\.'), 'sbt') >= 0
-        " Don't check sbt files
-        return ''
-    endif
-
-    return 'fsc'
-endfunction
-
-function! ale_linters#scala#fsc#GetCommand(buffer) abort
-    let l:executable = ale_linters#scala#fsc#GetExecutable(a:buffer)
-
-    if empty(l:executable)
-        return ''
-    endif
-
-    return ale#Escape(l:executable) . ' -Ystop-after:parser %t'
-endfunction
-
-call ale#linter#Define('scala', {
-\   'name': 'fsc',
-\   'executable_callback': 'ale_linters#scala#fsc#GetExecutable',
-\   'command_callback': 'ale_linters#scala#fsc#GetCommand',
-\   'callback': 'ale#handlers#scala#HandleScalacLintFormat',
-\   'output_stream': 'stderr',
-\})

ale_linters/scala/scalac.vim

@@ -4,7 +4,7 @@
 
 function! ale_linters#scala#scalac#GetExecutable(buffer) abort
     if index(split(getbufvar(a:buffer, '&filetype'), '\.'), 'sbt') >= 0
-        " Don't check sbt files
+        " Don't check sbt files with scalac.
         return ''
     endif
 
@@ -21,10 +21,45 @@ function! ale_linters#scala#scalac#GetCommand(buffer) abort
     return ale#Escape(l:executable) . ' -Ystop-after:parser %t'
 endfunction
 
+function! ale_linters#scala#scalac#Handle(buffer, lines) abort
+    " Matches patterns line the following:
+    "
+    " /var/folders/5q/20rgxx3x1s34g3m14n5bq0x80000gn/T/vv6pSsy/0:26: error: expected class or object definition
+    let l:pattern = '^.\+:\(\d\+\): \(\w\+\): \(.\+\)'
+    let l:output = []
+    let l:ln = 0
+
+    for l:line in a:lines
+        let l:ln = l:ln + 1
+        let l:match = matchlist(l:line, l:pattern)
+
+        if len(l:match) == 0
+            continue
+        endif
+
+        let l:text = l:match[3]
+        let l:type = l:match[2] is# 'error' ? 'E' : 'W'
+        let l:col = 0
+
+        if l:ln + 1 < len(a:lines)
+            let l:col = stridx(a:lines[l:ln + 1], '^')
+        endif
+
+        call add(l:output, {
+        \   'lnum': l:match[1] + 0,
+        \   'col': l:col + 1,
+        \   'text': l:text,
+        \   'type': l:type,
+        \})
+    endfor
+
+    return l:output
+endfunction
+
 call ale#linter#Define('scala', {
 \   'name': 'scalac',
 \   'executable_callback': 'ale_linters#scala#scalac#GetExecutable',
 \   'command_callback': 'ale_linters#scala#scalac#GetCommand',
-\   'callback': 'ale#handlers#scala#HandleScalacLintFormat',
+\   'callback': 'ale_linters#scala#scalac#Handle',
 \   'output_stream': 'stderr',
 \})