init commit, extracted vim config from i3rice

1 files changed, 2582 insertions, 0 deletions

diff --git a/.vim/autoload/neomake.vim b/.vim/autoload/neomake.vim
new file mode 100644
index 0000000..6322a05
--- /dev/null
+++ b/.vim/autoload/neomake.vim
@@ -0,0 +1,2582 @@
+" vim: ts=4 sw=4 et
+scriptencoding utf-8
+
+if !exists('s:make_id')
+    let s:make_id = 0
+endif
+" A map of make_id to options, e.g. cwd when jobs where started.
+if !exists('s:make_info')
+    let s:make_info = {}
+endif
+if !exists('s:job_id')
+    let s:job_id = 1
+endif
+if !exists('s:jobs')
+    let s:jobs = {}
+endif
+if !exists('s:map_job_ids')
+    let s:map_job_ids = {}
+endif
+
+" Errors by [maker_type][bufnr][lnum]
+let s:current_errors = {'project': {}, 'file': {}}
+
+if !has('nvim')
+    let s:kill_vim_timers = {}
+endif
+
+" A list of references to keep when profiling.
+" Workaround for https://github.com/vim/vim/issues/2350, where
+" https://github.com/blueyed/vader.vim/commit/e66d91dea is not enough.
+let s:hack_keep_refs_for_profiling = []
+
+" Can Neovim buffer output?
+let s:nvim_can_buffer_output = has('nvim-0.3.0') ? 1 : 0
+
+" Private function to access script-local variables during tests.
+function! neomake#_get_s() abort
+    return s:
+endfunction
+
+" Sentinels.
+let s:unset_list = []
+let s:unset_dict = {}
+let s:unset = {}
+
+let s:can_use_env_in_job_opts = has('patch-8.0.0902') && has('patch-8.0.1832')
+
+let s:is_testing = exists('g:neomake_test_messages')
+
+let s:async = has('nvim')
+            \ || has('channel') && has('job') && has('patch-8.0.0027')
+function! neomake#has_async_support() abort
+    return s:async
+endfunction
+
+if v:version >= 704 || (v:version == 703 && has('patch1058'))
+    function! s:function(name) abort
+        return function(a:name)
+    endfunction
+else
+    " Older Vim does not handle s: function references across files.
+    function! s:function(name) abort
+        return function(substitute(a:name,'^s:',matchstr(expand('<sfile>'), '.*\zs<SNR>\d\+_'),''))
+    endfunction
+endif
+
+function! s:sort_jobs(a, b) abort
+    return a:a.id - a:b.id
+endfunction
+
+function! neomake#GetJobs(...) abort
+    if empty(s:jobs)
+        return []
+    endif
+    let jobs = copy(values(s:jobs))
+    if a:0
+        call filter(jobs, 'index(a:1, v:val.id) != -1')
+    endif
+    return sort(jobs, function('s:sort_jobs'))
+endfunction
+
+function! neomake#GetJob(job_id) abort
+    return s:jobs[a:job_id]
+endfunction
+
+" Not documented, only used in tests for now.
+function! neomake#GetStatus() abort
+    return {
+                \ 'last_make_id': s:make_id,
+                \ 'make_info': s:make_info,
+                \ 'action_queue': g:neomake#action_queue#_s.action_queue,
+                \ }
+endfunction
+
+" neomake#GetMakeOptions: not documented, only used internally for now.
+" More lax when not being used in tests to avoid errors, but fail during tests.
+if s:is_testing
+    function! neomake#GetMakeOptions(...) abort
+        let make_id = a:0 ? a:1 : s:make_id
+        try
+            let r = s:make_info[make_id]
+        catch
+            let msg = printf('GetMakeOptions failed: %s (in %s)', v:exception, v:throwpoint)
+            call vader#log(msg)
+            let g:neomake_test_errors += [msg]
+            return {'verbosity': 3}
+        endtry
+        return r
+    endfunction
+else
+    function! neomake#GetMakeOptions(...) abort
+        let make_id = a:0 ? a:1 : s:make_id
+        if !has_key(s:make_info, make_id)
+            call neomake#log#warning('warning: missing make_info key: '.make_id.'.')
+            return {'verbosity': get(g:, 'neomake_verbose', 1)}
+        endif
+        return s:make_info[make_id]
+    endfunction
+endif
+
+function! neomake#ListJobs() abort
+    if !s:async
+        echom 'This Vim version has no support for jobs.'
+        return
+    endif
+    let jobs = neomake#GetJobs()
+    if empty(jobs)
+        return
+    endif
+    echom 'make_id | job_id | name/maker'
+    for jobinfo in jobs
+        let desc = !empty(jobinfo.maker.name) && jobinfo.name != jobinfo.maker.name
+                    \ ? jobinfo.name. ' ('.jobinfo.maker.name.')'
+                    \ : jobinfo.name
+        echom printf('%7d | %6d | %s', jobinfo.make_id, jobinfo.id, desc)
+    endfor
+endfunction
+
+function! neomake#CancelMake(...) abort
+    let make_id = a:0 ? a:1 : s:make_id
+    if !has_key(s:make_info, make_id)
+        call neomake#log#error('CancelMake: make not found: '.make_id.'.')
+        return 0
+    endif
+    let bang = a:0 > 1 ? a:1 : 0
+    let make_info = s:make_info[make_id]
+    call neomake#log#debug('Canceling make.', make_info)
+    let make_info.canceled = 1
+    let jobs = filter(copy(values(s:jobs)), 'v:val.make_id == make_id')
+    call s:abort_next_makers(make_id)
+    for job in jobs
+        call neomake#CancelJob(job.id, bang)
+    endfor
+    call neomake#action_queue#clean(make_info)
+    " Ensure that make info gets cleaned really, e.g. if there were no jobs yet.
+    if has_key(s:make_info, make_id)
+        call s:clean_make_info(make_info, bang)
+    endif
+    return 1
+endfunction
+
+function! neomake#CancelAllMakes(...) abort
+    let bang = a:0 ? a:1 : 0
+    for make_id in keys(s:make_info)
+        call neomake#CancelMake(make_id, bang)
+    endfor
+endfunction
+
+" Returns 1 if a job was canceled, 0 otherwise.
+function! neomake#CancelJob(job_id, ...) abort
+    let job_id = type(a:job_id) == type({}) ? a:job_id.id : +a:job_id
+    let remove_always = a:0 ? a:1 : 0
+    let jobinfo = get(s:jobs, job_id, {})
+    call neomake#log#debug('Canceling job.', jobinfo)
+
+    call neomake#action_queue#clean(empty(jobinfo) ? {'id': job_id} : jobinfo)
+
+    if empty(jobinfo)
+        call neomake#log#error('CancelJob: job not found: '.job_id.'.')
+        return 0
+    endif
+
+    if get(jobinfo, 'canceled', 0)
+        call neomake#log#info('Job was canceled already.', jobinfo)
+        if remove_always
+            call s:CleanJobinfo(jobinfo)
+        endif
+        return 0
+    endif
+    let jobinfo.canceled = 1
+
+    let ret = 0
+    if get(jobinfo, 'finished')
+        call neomake#log#debug('Removing already finished job.', jobinfo)
+    elseif has_key(jobinfo, 'exit_code')
+        call neomake#log#debug('Job exited already.', jobinfo)
+    elseif has_key(jobinfo.maker, 'get_list_entries')
+        call neomake#log#debug('Removing job for get_list_entries.', jobinfo)
+    elseif s:async
+        if has('nvim')
+            let job = jobinfo.nvim_job
+            call neomake#log#debug(printf('Stopping Neovim job: %s.', job), jobinfo)
+        else
+            let job = jobinfo.vim_job
+            call neomake#log#debug(printf('Stopping Vim job: %s.', job), jobinfo)
+        endif
+        if has('nvim')
+            try
+                call jobstop(job)
+                let ret = 1
+            catch /^Vim\%((\a\+)\)\=:\(E474\|E900\):/
+                call neomake#log#info(printf(
+                            \ 'jobstop failed: %s.', v:exception), jobinfo)
+            endtry
+        else
+            " Use ch_status here, since job_status might be 'dead' already,
+            " without the exit handler being called yet.
+            if job_status(job) !=# 'run'
+                call neomake#log#info(
+                            \ 'job_stop: job was not running anymore.', jobinfo)
+            else
+                " NOTE: might be "dead" already, but that is fine.
+                call job_stop(job)
+                let ret = 1
+                if job_status(job) ==# 'run'
+                    let timer = timer_start(1000, function('s:kill_vimjob_cb'))
+                    let s:kill_vim_timers[timer] = jobinfo
+                endif
+            endif
+        endif
+    endif
+
+    if ret == 0 || remove_always
+        call s:CleanJobinfo(jobinfo)
+    endif
+    return ret
+endfunction
+
+function! s:kill_vimjob_cb(timer) abort
+    let jobinfo = s:kill_vim_timers[a:timer]
+    let vim_job = jobinfo.vim_job
+    if job_status(vim_job) ==# 'run'
+        call neomake#log#debug('Forcefully killing still running Vim job.', jobinfo)
+        call job_stop(vim_job, 'kill')
+    endif
+    unlet s:kill_vim_timers[a:timer]
+endfunction
+
+function! neomake#CancelJobs(bang) abort
+    call neomake#log#debug(printf('Canceling %d jobs.', len(s:jobs)))
+    for job in neomake#GetJobs()
+        call neomake#CancelJob(job.id, a:bang)
+    endfor
+endfunction
+
+function! s:handle_get_list_entries(jobinfo, ...) abort
+    if !a:0
+        return s:pcall('s:handle_get_list_entries', [a:jobinfo])
+    endif
+    let jobinfo = a:jobinfo
+    let jobinfo.serialize = 0
+    let maker = jobinfo.maker
+    try
+        let entries = maker.get_list_entries(jobinfo)
+    catch /^\%(Vim\%((\a\+)\)\=:\%(E48\|E523\)\)\@!/  " everything, but E48/E523 (sandbox / not allowed here)
+        if v:exception ==# 'NeomakeTestsException'
+            throw v:exception
+        endif
+        call neomake#log#exception(printf(
+                    \ 'Error during get_list_entries for %s: %s.',
+                    \ jobinfo.maker.name, v:exception), jobinfo)
+        call s:CleanJobinfo(jobinfo)
+        return g:neomake#action_queue#processed
+    endtry
+
+    if type(entries) != type([])
+        call neomake#log#error(printf('The get_list_entries method for maker %s did not return a list, but: %s.', jobinfo.maker.name, string(entries)[:100]), jobinfo)
+    elseif !empty(entries) && type(entries[0]) != type({})
+        call neomake#log#error(printf('The get_list_entries method for maker %s did not return a list of dicts, but: %s.', jobinfo.maker.name, string(entries)[:100]), jobinfo)
+    else
+        call s:ProcessEntries(jobinfo, entries)
+    endif
+    call s:CleanJobinfo(jobinfo)
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:MakeJob(make_id, options) abort
+    let job_id = s:job_id
+    let s:job_id += 1
+
+    " Optional:
+    "  - serialize (default: 0 for async (and get_list_entries),
+    "                        1 for non-async)
+    "  - serialize_abort_on_error (default: 0)
+    "  - exit_callback (string/function, default: 0)
+    let jobinfo = extend(deepcopy(g:neomake#jobinfo#base), extend({
+        \ 'id': job_id,
+        \ 'make_id': a:make_id,
+        \ 'name': empty(get(a:options.maker, 'name', '')) ? 'neomake_'.job_id : a:options.maker.name,
+        \ 'maker': a:options.maker,
+        \ 'bufnr': a:options.bufnr,
+        \ 'file_mode': a:options.file_mode,
+        \ 'ft': a:options.ft,
+        \ 'cwd': s:make_info[a:make_id].cwd,
+        \ }, a:options))
+
+    let maker = jobinfo.maker
+
+    if has_key(maker, 'get_list_entries')
+        call neomake#log#info(printf(
+                    \ '%s: getting entries via get_list_entries.',
+                    \ maker.name), jobinfo)
+        let s:jobs[jobinfo.id] = jobinfo
+        let s:make_info[a:make_id].active_jobs += [jobinfo]
+        call s:handle_get_list_entries(jobinfo)
+        return jobinfo
+    endif
+
+    call extend(jobinfo, {
+        \ 'output_stream': a:options.maker.output_stream,
+        \ 'buffer_output': a:options.maker.buffer_output,
+        \ }, 'keep')
+
+    let error = ''
+    try
+        " Change to job's cwd (before args, for relative filename).
+        let cd_error = jobinfo.cd()
+        if !empty(cd_error)
+            throw printf("Neomake: %s: could not change to maker's cwd (%s): %s.",
+                        \ maker.name, jobinfo.cd_from_setting, cd_error)
+        endif
+        let jobinfo.argv = maker._get_argv(jobinfo)
+
+        call neomake#utils#hook('NeomakeJobInit', {'jobinfo': jobinfo})
+
+        let start_msg = s:async ? 'Starting async job' : 'Starting'
+        if type(jobinfo.argv) == type('')
+            let start_msg .= ' [string]: '.jobinfo.argv
+        else
+            let start_msg .= ': '.join(map(copy(jobinfo.argv), 'neomake#utils#shellescape(v:val)'))
+        endif
+        call neomake#log#info(start_msg.'.', jobinfo)
+
+        let cwd = jobinfo.cwd
+        let changed = !empty(jobinfo.cd_back_cmd)
+        if changed
+            call neomake#log#debug('cwd: '.cwd.' (changed).', jobinfo)
+        else
+            call neomake#log#debug('cwd: '.cwd.'.', jobinfo)
+        endif
+
+        let base_job_opts = {}
+        if has_key(jobinfo, 'filename')
+            if s:can_use_env_in_job_opts
+                let base_job_opts = {
+                            \ 'env': {
+                            \   'NEOMAKE_FILE': jobinfo.filename
+                            \ }}
+            else
+                let save_env_file = exists('$NEOMAKE_FILE') ? $NEOMAKE_FILE : s:unset
+                let $NEOMAKE_FILE = jobinfo.filename
+            endif
+        endif
+
+        " Lock maker to make sure it does not get changed accidentally, but
+        " only with depth=1, so that a postprocess object can change itself.
+        lockvar 1 maker
+        if s:async
+            if has('nvim')
+                if jobinfo.buffer_output
+                    let opts = extend(base_job_opts, {
+                                \ 'stdout_buffered': 1,
+                                \ 'stderr_buffered': 1,
+                                \ })
+                    if s:nvim_can_buffer_output == 1
+                        let opts.on_exit = function('s:nvim_exit_handler_buffered')
+                    else
+                        call extend(opts, {
+                                \ 'on_stdout': function('s:nvim_output_handler'),
+                                \ 'on_stderr': function('s:nvim_output_handler'),
+                                \ })
+                        let opts.on_exit = function('s:nvim_exit_handler')
+                    endif
+                    let jobinfo.jobstart_opts = opts
+                else
+                    let opts = {
+                                \ 'on_stdout': function('s:nvim_output_handler'),
+                                \ 'on_stderr': function('s:nvim_output_handler'),
+                                \ 'on_exit': function('s:nvim_exit_handler'),
+                                \ }
+                endif
+                if has_key(maker, 'nvim_job_opts')
+                    call extend(opts, maker.nvim_job_opts)
+                endif
+                if !has('nvim-0.3.0')
+                            \ && !neomake#utils#IsRunningWindows()
+                            \ && !has_key(opts, 'detach')
+                            \ && !has_key(opts, 'pty')
+                    " Always use detach to trigger setsid() with older Neovim.
+                    let opts.detach = 1
+                endif
+                try
+                    let job = jobstart(jobinfo.argv, opts)
+                catch
+                    let error = printf('Failed to start Neovim job: %s: %s.',
+                                \ string(jobinfo.argv), v:exception)
+                endtry
+                if empty(error)
+                    if job == 0
+                        let error = printf('Failed to start Neovim job: %s: %s.',
+                                    \ 'Job table is full or invalid arguments given', string(jobinfo.argv))
+                    elseif job == -1
+                        let error = printf('Failed to start Neovim job: %s: %s.',
+                                    \ 'Executable not found', string(jobinfo.argv))
+                    else
+                        let s:map_job_ids[job] = jobinfo.id
+                        let jobinfo.nvim_job = job
+                        let s:jobs[jobinfo.id] = jobinfo
+
+                        if get(jobinfo, 'uses_stdin', 0)
+                            call jobsend(job, s:make_info[a:make_id].buffer_lines)
+                            call jobclose(job, 'stdin')
+                        endif
+                    endif
+                endif
+            else
+                " vim-async.
+                let opts = extend(base_job_opts, {
+                            \ 'out_cb': function('s:vim_output_handler_stdout'),
+                            \ 'err_cb': function('s:vim_output_handler_stderr'),
+                            \ 'close_cb': function('s:vim_exit_handler'),
+                            \ 'mode': 'raw',
+                            \ })
+                if has_key(maker, 'vim_job_opts')
+                    call extend(opts, maker.vim_job_opts)
+                endif
+                try
+                    let job = job_start(jobinfo.argv, opts)
+                    " Get this as early as possible!
+                    let channel_id = ch_info(job)['id']
+                catch
+                    " NOTE: not covered in tests. Vim seems to always return
+                    " a job. Might be able to trigger this using custom opts?!
+                    let error = printf('Failed to start Vim job: %s: %s.',
+                                \ jobinfo.argv, v:exception)
+                endtry
+                if empty(error)
+                    let jobinfo.vim_job = job
+                    let s:map_job_ids[channel_id] = jobinfo.id
+                    let s:jobs[jobinfo.id] = jobinfo
+                    call neomake#log#debug(printf('Vim job: %s.',
+                                \ string(job_info(job))), jobinfo)
+                    call neomake#log#debug(printf('Vim channel: %s.',
+                                \ string(ch_info(job))), jobinfo)
+
+                    if get(jobinfo, 'uses_stdin', 0)
+                        call ch_sendraw(job, join(s:make_info[a:make_id].buffer_lines, "\n"))
+                        call ch_close_in(job)
+                    endif
+                endif
+            endif
+
+            " Bail out on errors.
+            if !empty(error)
+                throw 'Neomake: '.error
+            endif
+
+            call neomake#utils#hook('NeomakeJobStarted', {'jobinfo': jobinfo})
+        else
+            " vim-sync.
+            " Use a temporary file to capture stderr.
+            let stderr_file = tempname()
+            let argv = jobinfo.argv . ' 2>'.stderr_file
+
+            try
+                if get(jobinfo, 'uses_stdin', 0)
+                    " Pass stdin to system(), but only if non-empty.
+                    " Otherwise it might cause E677 (vim74-trusty at least).
+                    let stdin = join(s:make_info[a:make_id].buffer_lines, "\n")
+                    if !empty(stdin)
+                        let output = system(argv, stdin)
+                    else
+                        let output = system(argv)
+                    endif
+                else
+                    let output = system(argv)
+                endif
+            catch /^Vim(let):E484:/
+                throw printf('Neomake: Could not run %s: %s.', argv, v:exception)
+            endtry
+
+            let jobinfo.id = job_id
+            let s:jobs[job_id] = jobinfo
+            let s:make_info[a:make_id].active_jobs += [jobinfo]
+
+            call s:output_handler(jobinfo, split(output, '\r\?\n', 1), 'stdout', 0)
+            let stderr_output = readfile(stderr_file)
+            if !empty(stderr_output)
+                call s:output_handler(jobinfo, stderr_output, 'stderr', 1)
+            endif
+            call delete(stderr_file)
+
+            call s:exit_handler(jobinfo, v:shell_error)
+            return jobinfo
+        endif
+    finally
+        call jobinfo.cd_back()
+        if exists('save_env_file')
+            call s:restore_env('NEOMAKE_FILE', save_env_file)
+        endif
+    endtry
+    let s:make_info[a:make_id].active_jobs += [jobinfo]
+    return jobinfo
+endfunction
+
+if !s:can_use_env_in_job_opts
+    function! s:restore_env(var, value) abort
+        " Cannot unlet environment vars without patch 8.0.1832.
+        exe printf('let $%s = %s', a:var, string(a:value is s:unset ? '' : a:value))
+    endfunction
+endif
+
+let s:command_maker_base = copy(g:neomake#core#command_maker_base)
+" Check if a temporary file is used, and set it in s:make_info in case it is.
+function! s:command_maker_base._get_tempfilename(jobinfo) abort dict
+    let l:Supports_stdin = neomake#utils#GetSetting('supports_stdin', self, s:unset_dict, a:jobinfo.ft, a:jobinfo.bufnr)
+    if Supports_stdin isnot s:unset_dict
+        if type(Supports_stdin) == type(function('tr'))
+            let supports_stdin = call(Supports_stdin, [a:jobinfo], self)
+        else
+            let supports_stdin = Supports_stdin
+        endif
+        if supports_stdin
+            let a:jobinfo.uses_stdin = 1
+            return get(self, 'tempfile_name', '-')
+        endif
+    endif
+
+    if has_key(self, 'tempfile_name')
+        return self.tempfile_name
+    endif
+
+    let tempfile_enabled = neomake#utils#GetSetting('tempfile_enabled', self, 1, a:jobinfo.ft, a:jobinfo.bufnr)
+    if !tempfile_enabled
+        return ''
+    endif
+
+    let make_id = a:jobinfo.make_id
+    if !has_key(s:make_info[make_id], 'tempfile_name')
+        if !exists('s:pid')
+            let s:pid = getpid()
+        endif
+        let slash = neomake#utils#Slash()
+
+        let dir = neomake#utils#GetSetting('tempfile_dir', self, '', a:jobinfo.ft, a:jobinfo.bufnr)
+
+        " Use absolute path internally, which is important for removal.
+        let orig_fname = neomake#utils#fnamemodify(a:jobinfo.bufnr, ':p')
+        if empty(dir)
+            if empty(orig_fname)
+                let dir = tempname()
+            else
+                let dir = fnamemodify(orig_fname, ':h')
+                if filewritable(dir) != 2
+                    let dir = tempname()
+                    let s:make_info[make_id].tempfile_dir = dir
+                    call neomake#log#debug('Using temporary directory for non-writable parent directory.')
+                endif
+            endif
+
+            if empty(orig_fname)
+                let filename = 'neomaketmp.'.a:jobinfo.ft
+            else
+                let filename = fnamemodify(orig_fname, ':t')
+                            \ .'@neomake_'.s:pid.'_'.make_id
+                let ext = fnamemodify(orig_fname, ':e')
+                if !empty(ext)
+                    let filename .= '.'.ext
+                endif
+                " Use hidden files to make e.g. pytest not trying to import it.
+                if filename[0] !=# '.'
+                    let filename = '.' . filename
+                endif
+            endif
+        else
+            let dir = neomake#utils#ExpandArgs([dir], a:jobinfo)[0]
+            if empty(orig_fname)
+                let filename = 'neomaketmp.'.a:jobinfo.ft
+            else
+                let filename = fnamemodify(orig_fname, ':t')
+            endif
+        endif
+
+        let temp_file = dir . slash . filename
+        let s:make_info[make_id].tempfile_name = temp_file
+    endif
+    return s:make_info[make_id].tempfile_name
+endfunction
+
+" Get the filename to use for a:jobinfo's make/buffer.
+function! s:command_maker_base._get_fname_for_buffer(jobinfo) abort
+    let bufnr = a:jobinfo.bufnr
+    let bufname = bufname(bufnr)
+    let temp_file = ''
+    let _uses_stdin = neomake#utils#GetSetting('uses_stdin', a:jobinfo.maker, s:unset_dict, a:jobinfo.ft, bufnr)
+    if _uses_stdin isnot s:unset_dict
+        let a:jobinfo.uses_stdin = _uses_stdin
+        let uses_stdin = _uses_stdin
+        call neomake#log#debug(printf('Using uses_stdin (%s) from setting.',
+                    \ a:jobinfo.uses_stdin), a:jobinfo)
+        if a:jobinfo.uses_stdin
+            let temp_file = neomake#utils#GetSetting('tempfile_name', a:jobinfo.maker, '-', a:jobinfo.ft, bufnr)
+        endif
+    else
+        if empty(bufname)
+            let temp_file = self._get_tempfilename(a:jobinfo)
+            if !get(a:jobinfo, 'uses_stdin', 0) && empty(temp_file)
+                throw 'Neomake: no file name.'
+            endif
+            let used_for = 'unnamed'
+        elseif getbufvar(bufnr, '&modified')
+            let temp_file = self._get_tempfilename(a:jobinfo)
+            if !get(a:jobinfo, 'uses_stdin', 0) && empty(temp_file)
+                throw 'Neomake: skip_job: buffer is modified, but temporary files are disabled.'
+            endif
+            let used_for = 'modified'
+        elseif !filereadable(bufname)
+            let temp_file = self._get_tempfilename(a:jobinfo)
+            if !get(a:jobinfo, 'uses_stdin', 0) && empty(temp_file)
+                " Using ':p' as modifier is unpredictable as per doc, but OK.
+                throw printf('Neomake: file is not readable (%s)', fnamemodify(bufname, ':p'))
+            endif
+            let used_for = 'unreadable'
+        else
+            let bufname = fnamemodify(bufname, ':.')
+            let used_for = ''
+        endif
+
+        let uses_stdin = get(a:jobinfo, 'uses_stdin', 0)
+
+        if !empty(used_for)
+            if uses_stdin
+                call neomake#log#debug(printf(
+                            \ 'Using stdin for %s buffer (%s).', used_for, temp_file),
+                            \ a:jobinfo)
+            elseif !empty(temp_file)
+                call neomake#log#debug(printf(
+                            \ 'Using tempfile for %s buffer: "%s".', used_for, temp_file),
+                            \ a:jobinfo)
+            endif
+        endif
+    endif
+
+    let make_info = s:make_info[a:jobinfo.make_id]
+    " Handle stdin when supports_stdin sets self.tempfile_name = ''.
+    if uses_stdin
+        if !has_key(make_info, 'buffer_lines')
+            let make_info.buffer_lines = neomake#utils#get_buffer_lines(bufnr)
+        endif
+        let bufname = temp_file
+    elseif !empty(temp_file)
+        " Use relative path for args.
+        let bufname = fnamemodify(temp_file, ':.')
+        let temp_file = fnamemodify(temp_file, ':p')
+        if !has_key(make_info, 'tempfiles')
+            let make_info.tempfiles = [temp_file]
+            let make_info.created_dirs = s:create_dirs_for_file(temp_file)
+            call neomake#utils#write_tempfile(bufnr, temp_file)
+        elseif temp_file !=# make_info.tempfiles[0]
+            call extend(make_info.created_dirs, s:create_dirs_for_file(temp_file))
+            call writefile(readfile(make_info.tempfiles[0], 'b'), temp_file, 'b')
+            call add(make_info.tempfiles, temp_file)
+        endif
+        let a:jobinfo.tempfile = temp_file
+    endif
+
+    let a:jobinfo.filename = bufname
+    return bufname
+endfunction
+
+function! s:create_dirs_for_file(fpath) abort
+    let created_dirs = []
+    let last_dir = a:fpath
+    while 1
+        let temp_dir = fnamemodify(last_dir, ':h')
+        if isdirectory(temp_dir) || last_dir ==# temp_dir
+            break
+        endif
+        call insert(created_dirs, temp_dir)
+        let last_dir = temp_dir
+    endwhile
+    for dir in created_dirs
+        call mkdir(dir, '', 0700)
+    endfor
+    return created_dirs
+endfunction
+
+function! s:command_maker_base._bind_args() abort dict
+    " Resolve args, which might be a function or dictionary.
+    if type(self.args) == type(function('tr'))
+        " Deprecated: use InitForJob
+        call neomake#log#warn_once(printf("Please use 'InitForJob' instead of 'args' for maker %s.", self.name),
+                    \ printf('deprecated-args-%s', self.name))
+        let args = call(self.args, [])
+    elseif type(self.args) == type({})
+        " Deprecated: use InitForJob
+        call neomake#log#warn_once(printf("Please use 'InitForJob' instead of 'args.fn' for maker %s.", self.name),
+                    \ printf('deprecated-args-fn-%s', self.name))
+        let args = call(self.args.fn, [], self.args)
+    else
+        let args = copy(self.args)
+    endif
+    let self.args = args
+    return self
+endfunction
+
+function! s:command_maker_base._get_argv(jobinfo) abort dict
+    let filename = self._get_fname_for_args(a:jobinfo)
+    let args_is_list = type(self.args) == type([])
+    if args_is_list
+        let args = neomake#utils#ExpandArgs(self.args, a:jobinfo)
+        if !empty(filename)
+            call add(args, filename)
+        endif
+    elseif !empty(filename)
+        let args = copy(self.args)
+        let args .= (empty(args) ? '' : ' ').neomake#utils#shellescape(filename)
+    else
+        let args = self.args
+    endif
+    return neomake#compat#get_argv(self.exe, args, args_is_list)
+endfunction
+
+function! s:GetMakerForFiletype(ft, maker_name) abort
+    for config_ft in neomake#utils#get_config_fts(a:ft)
+        call neomake#utils#load_ft_makers(config_ft)
+        let f = 'neomake#makers#ft#'.config_ft.'#'.a:maker_name
+        if exists('*'.f)
+            let maker = call(f, [])
+            return maker
+        endif
+    endfor
+    return s:unset_dict
+endfunction
+
+function! neomake#get_maker_by_name(maker_name, ...) abort
+    let for_ft = a:0 ? a:1 : 0
+    let ft_config = for_ft is# 0 ? &filetype : for_ft
+    let bufnr = bufnr('%')
+    if a:maker_name !~# '\v^\w+$'
+        throw printf('Neomake: Invalid maker name: "%s"', a:maker_name)
+    endif
+
+    let maker = neomake#utils#GetSetting('maker', {'name': a:maker_name}, s:unset_dict, ft_config, bufnr)
+    if maker is# s:unset_dict
+        if a:maker_name ==# 'makeprg'
+            let maker = s:get_makeprg_maker()
+        elseif for_ft isnot# 0
+            let maker = s:GetMakerForFiletype(for_ft, a:maker_name)
+        else
+            call neomake#utils#load_global_makers()
+            let f = 'neomake#makers#'.a:maker_name.'#'.a:maker_name
+            if exists('*'.f)
+                let maker = call(f, [])
+            endif
+        endif
+    endif
+    if type(maker) != type({})
+        throw printf('Neomake: Got non-dict for maker %s: %s',
+                    \ a:maker_name, maker)
+    endif
+    if maker isnot# s:unset_dict && !has_key(maker, 'name')
+        let maker.name = a:maker_name
+    endif
+    return maker
+endfunction
+
+function! neomake#GetMaker(name_or_maker, ...) abort
+    let for_ft = a:0 ? a:1 : 0
+    if type(a:name_or_maker) == type({})
+        let maker = a:name_or_maker
+        if !has_key(maker, 'name')
+            let maker.name = 'unnamed_maker'
+        endif
+    else
+        let maker = neomake#get_maker_by_name(a:name_or_maker, for_ft)
+        if maker is# s:unset_dict
+            if !a:0
+                " Check &filetype if no args where provided.
+                let maker = neomake#get_maker_by_name(a:name_or_maker, &filetype)
+            endif
+        endif
+        if maker is# s:unset_dict
+            if for_ft isnot# 0
+                throw printf('Neomake: Maker not found (for %s): %s',
+                            \ !empty(for_ft) ? 'filetype '.for_ft : 'empty filetype',
+                            \ a:name_or_maker)
+            else
+                throw printf('Neomake: Maker not found (without filetype): %s',
+                            \ a:name_or_maker)
+            endif
+        endif
+    endif
+    return neomake#create_maker_object(maker, a:0 ? a:1 : &filetype)
+endfunction
+
+" NOTE: uses ft and bufnr for config only.
+function! neomake#create_maker_object(maker, ft) abort
+    let [maker, ft, bufnr] = [a:maker, a:ft, bufnr('%')]
+
+    " Create the maker object.
+    let l:GetEntries = neomake#utils#GetSetting('get_list_entries', maker, -1, ft, bufnr)
+    if GetEntries isnot# -1
+        let maker = copy(maker)
+        let maker.get_list_entries = GetEntries
+    else
+        let maker = extend(copy(s:command_maker_base), copy(maker))
+    endif
+    if !has_key(maker, 'get_list_entries')
+        " Set defaults for command/job based makers.
+        let defaults = extend(
+                    \ copy(g:neomake#config#_defaults['maker_defaults']),
+                    \ neomake#config#get('maker_defaults'))
+        call extend(defaults, {
+            \ 'exe': maker.name,
+            \ 'args': [],
+            \ })
+        if !has_key(maker, 'process_output') && !has_key(maker, 'process_json')
+            call extend(defaults, {
+                \ 'errorformat': &errorformat,
+                \ })
+        endif
+        for [key, default] in items(defaults)
+            let maker[key] = neomake#utils#GetSetting(key, {'name': maker.name}, get(maker, key, default), ft, bufnr, 1)
+            unlet default  " for Vim without patch-7.4.1546
+        endfor
+    endif
+    if v:profiling
+        call add(s:hack_keep_refs_for_profiling, maker)
+    endif
+    return maker
+endfunction
+
+if exists('*getcompletion')
+    function! s:get_makers_for_pattern(pattern) abort
+        " Get function prefix based on pattern, until the first backslash.
+        let prefix = substitute(a:pattern, '\v\\.*', '', '')
+
+        " NOTE: the pattern uses &ignorecase.
+        let funcs = getcompletion(prefix.'[a-z]', 'function')
+        call filter(funcs, 'v:val =~# a:pattern')
+        " Remove prefix.
+        call map(funcs, 'v:val['.len(prefix).':]')
+        " Only keep lowercase function names.
+        call filter(funcs, "v:val =~# '\\m^[a-z].*('")
+        " Remove parenthesis and #.* (for project makers).
+        return sort(map(funcs, "substitute(v:val, '\\v[(#].*', '', '')"))
+    endfunction
+else
+    function! s:get_makers_for_pattern(pattern) abort
+        let funcs_output = neomake#utils#redir('fun /'.a:pattern)
+        return sort(map(split(funcs_output, '\n'),
+                    \ "substitute(v:val, '\\v^.*#(.*)\\(.*$', '\\1', '')"))
+    endfunction
+endif
+
+function! neomake#GetMakers(ft) abort
+    " Get all makers for a given filetype.  This is used from completion.
+    " XXX: this should probably use a callback or some other more stable
+    " approach to get the list of makers (than looking at the lowercase
+    " functions)?!
+
+    let makers = []
+    " Do not use 'b:neomake_jsx_javascript_foo_maker' twice for
+    " ft=jsx.javascript.
+    let used_vars = []
+    for ft in neomake#utils#get_config_fts(a:ft)
+        call neomake#utils#load_ft_makers(ft)
+
+        " Add sorted list per filetype.
+        let add = []
+
+        let maker_names = s:get_makers_for_pattern('neomake#makers#ft#'.ft.'#\l')
+        for maker_name in maker_names
+            if index(makers, maker_name) == -1 && index(add, maker_name) == -1
+                let add += [maker_name]
+            endif
+        endfor
+
+        " Get makers from g:/b: variables.
+        for v in sort(extend(keys(g:), keys(b:)))
+            if index(used_vars, v) != -1
+                continue
+            endif
+            let maker_name = matchstr(v, '\v^neomake_'.ft.'_\zs[0-9a-z_]+\ze_maker$')
+            if !empty(maker_name)
+                        \ && index(makers, maker_name) == -1
+                        \ && index(add, maker_name) == -1
+                let used_vars += [v]
+                let add += [maker_name]
+            endif
+        endfor
+
+        " Get makers from new-style config.
+        for [maker_name, val] in items(neomake#config#get('ft.'.ft))
+            if has_key(val, 'maker')
+                        \ && index(makers, maker_name) == -1
+                        \ && index(add, maker_name) == -1
+                let add += [maker_name]
+            endif
+        endfor
+
+        call sort(add)
+        call extend(makers, add)
+    endfor
+    return makers
+endfunction
+
+function! neomake#GetProjectMakers() abort
+    call neomake#utils#load_global_makers()
+    return s:get_makers_for_pattern('neomake#makers#\(ft#\)\@!\l')
+endfunction
+
+function! neomake#GetEnabledMakers(...) abort
+    let file_mode = a:0
+    if !file_mode
+        " If we have no filetype, use the global default makers.
+        " This variable is also used for project jobs, so it has no
+        " buffer local ('b:') counterpart for now.
+        let enabled_makers = copy(get(g:, 'neomake_enabled_makers', []))
+        if empty(enabled_makers)
+            let makeprg_maker = s:get_makeprg_maker()
+            if !empty(makeprg_maker)
+                let makeprg_maker = neomake#GetMaker(makeprg_maker)
+                let makeprg_maker.auto_enabled = 1
+                let enabled_makers = [makeprg_maker]
+            endif
+        else
+            call map(enabled_makers, "extend(neomake#GetMaker(v:val),
+                        \ {'auto_enabled': 0}, 'error')")
+        endif
+    else
+        let enabled_makers = []
+        let bufnr = bufnr('%')
+        let makers = neomake#utils#GetSetting('enabled_makers', {}, s:unset_list, a:1, bufnr)
+        if makers is# s:unset_list
+            let auto_enabled = 1
+            for config_ft in neomake#utils#get_config_fts(a:1)
+                call neomake#utils#load_ft_makers(config_ft)
+                let fnname = 'neomake#makers#ft#'.config_ft.'#EnabledMakers'
+                if exists('*'.fnname)
+                    try
+                        let makers = call(fnname, [])
+                    catch /^Vim(let):E119:/  " Not enough arguments for function
+                        let makers = call(fnname, [{'file_mode': file_mode, 'bufnr': bufnr}])
+                    endtry
+                    break
+                endif
+            endfor
+        else
+            let auto_enabled = 0
+        endif
+
+        let makers = neomake#map_makers(makers, a:1, auto_enabled)
+        for maker in makers
+            let maker.auto_enabled = auto_enabled
+            let enabled_makers += [maker]
+        endfor
+    endif
+    return enabled_makers
+endfunction
+
+" a:1: override "open_list" setting.
+function! s:HandleLoclistQflistDisplay(jobinfo, loc_or_qflist, ...) abort
+    let open_list_default = a:0 ? a:1 : 0
+    let open_val = neomake#utils#GetSetting('open_list', a:jobinfo.maker, open_list_default, a:jobinfo.ft, a:jobinfo.bufnr)
+    if !open_val
+        return
+    endif
+    let height = neomake#utils#GetSetting('list_height', a:jobinfo.maker, 10, a:jobinfo.ft, a:jobinfo.bufnr)
+    if !height
+        return
+    endif
+    let height = min([len(a:loc_or_qflist), height])
+    if a:jobinfo.file_mode
+        call neomake#log#debug('Handling location list: executing lwindow.', a:jobinfo)
+        let cmd = 'lwindow'
+    else
+        call neomake#log#debug('Handling quickfix list: executing cwindow.', a:jobinfo)
+        let cmd = 'botright cwindow'
+    endif
+    if open_val == 2
+        let make_id = a:jobinfo.make_id
+        let make_info = s:make_info[make_id]
+        let g:neomake#core#_ignore_autocommands += 1
+        try
+            call neomake#compat#save_prev_windows()
+
+            let win_count = winnr('$')
+            exe cmd height
+            let new_win_count = winnr('$')
+            if win_count == new_win_count
+                " No new window, adjust height eventually.
+                let found = 0
+
+                if get(make_info, '_did_lwindow', 0)
+                    for w in range(1, winnr('$'))
+                        if getwinvar(w, 'neomake_window_for_make_id') == make_id
+                            let found = w
+                            break
+                        endif
+                    endfor
+                    if found
+                        let cmd = printf('%dresize %d', found, height)
+                        if winheight(found) != height
+                            call neomake#log#debug(printf(
+                                        \ 'Resizing existing quickfix window: %s.',
+                                        \ cmd), a:jobinfo)
+                            exe cmd
+                        endif
+                    else
+                        call neomake#log#debug(
+                                    \ 'Could not find corresponding quickfix window.',
+                                    \ a:jobinfo)
+                    endif
+                endif
+            elseif new_win_count > win_count
+                if &filetype !=# 'qf'
+                    call neomake#log#debug(printf(
+                                \ 'WARN: unexpected filetype for new window: %s',
+                                \ &filetype), a:jobinfo)
+                else
+                    call neomake#log#debug(printf(
+                                \ 'list window has been opened (old count: %d, new count: %d, height: %d).',
+                                \ win_count, new_win_count, winheight(0)), a:jobinfo)
+                    let w:neomake_window_for_make_id = a:jobinfo.make_id
+                endif
+            else
+                call neomake#log#debug(printf(
+                            \ 'list window has been closed (old count: %d, new count: %d).',
+                            \ win_count, new_win_count), a:jobinfo)
+            endif
+            call neomake#compat#restore_prev_windows()
+            let make_info._did_lwindow = 1
+        finally
+            let g:neomake#core#_ignore_autocommands -= 1
+        endtry
+    else
+        exe cmd height
+    endif
+endfunction
+
+" Experimental/private wrapper.
+function! neomake#_handle_list_display(jobinfo, ...) abort
+    if a:0
+        let list = a:1
+    else
+        let list = a:jobinfo.file_mode ? getloclist(0) : getqflist()
+    endif
+    call s:HandleLoclistQflistDisplay(a:jobinfo, list, 2)
+endfunction
+
+" Get a maker for &makeprg.
+" This could be cached, but needs to take into account / set &errorformat,
+" and other settings that are handled by neomake#GetMaker.
+function! s:get_makeprg_maker() abort
+    if empty(&makeprg)
+        return {}
+    elseif &makeprg =~# '\s'
+        let maker = neomake#utils#MakerFromCommand(&makeprg)
+    else
+        let maker = neomake#utils#MakerFromCommand([&makeprg])
+    endif
+    let maker.name = 'makeprg'
+    " Do not append file.  &makeprg should contain %/# for this instead.
+    let maker.append_file = 0
+    return neomake#GetMaker(maker)
+endfunction
+
+function! s:Make(options) abort
+    let is_automake = get(a:options, 'automake', !empty(expand('<abuf>')))
+    if is_automake
+        if g:neomake#core#_ignore_autocommands
+            call neomake#log#debug(printf(
+                        \ 'Ignoring Make through autocommand due to ignore_autocommands=%d.', g:neomake#core#_ignore_autocommands), {'winnr': winnr()})
+            return []
+        endif
+        let disabled = neomake#config#get_with_source('disabled', 0)
+        if disabled[0]
+            call neomake#log#debug(printf(
+                        \ 'Make through autocommand disabled via %s.', disabled[1]))
+            return []
+        endif
+    endif
+
+    let s:make_id += 1
+    let make_id = s:make_id
+    let options = extend(copy(a:options), {
+                \ 'file_mode': 1,
+                \ 'ft': &filetype,
+                \ }, 'keep')
+    let options.make_id = make_id  " Deprecated.
+    let file_mode = options.file_mode
+
+    " Require winid/winnr with non-current buffer in file_mode.
+    if has_key(options, 'bufnr')
+        if options.bufnr != bufnr('%')
+            if !has_key(options, 'winid') && !has_key(options, 'winnr')
+                throw 'Neomake: winid or winnr are required for non-current buffer.'
+            endif
+        endif
+        if !bufexists(options.bufnr)
+            throw printf('Neomake: buffer %d does not exist.', options.bufnr)
+        endif
+    else
+        let options.bufnr = bufnr('%')
+    endif
+
+    " Validate winid/winnr (required for location list windows).
+    let file_mode_win = 0
+    if file_mode
+        if has_key(options, 'winid')
+            if win_id2tabwin(options.winid) == [0, 0]
+                throw printf('Neomake: window id %d does not exist.', options.winid)
+            endif
+            let file_mode_win = options.winid
+        elseif has_key(options, 'winnr')
+            if winbufnr(options.winnr) == -1
+                throw printf('Neomake: window %d does not exist.', options.winnr)
+            endif
+            let file_mode_win = options.winnr
+        elseif exists('*win_getid')
+            let options.winid = win_getid()
+        endif
+    elseif has_key(options, 'winid')
+        throw 'Neomake: do not use winid with file_mode=0.'
+    elseif has_key(options, 'winnr')
+        throw 'Neomake: do not use winnr with file_mode=0.'
+    endif
+
+    lockvar 1 options
+    let s:make_info[make_id] = {
+                \ 'make_id': make_id,
+                \ 'cwd': getcwd(),
+                \ 'verbosity': get(g:, 'neomake_verbose', 1),
+                \ 'active_jobs': [],
+                \ 'finished_jobs': [],
+                \ 'options': options,
+                \ }
+    let make_info = s:make_info[make_id]
+    let bufnr = options.bufnr
+    if &verbose
+        let make_info.verbosity += &verbose
+        call neomake#log#debug(printf(
+                    \ 'Adding &verbose (%d) to verbosity level: %d.',
+                    \ &verbose, make_info.verbosity), make_info)
+    endif
+    if make_info.verbosity >= 3
+        call neomake#log#debug(printf(
+                    \ 'Calling Make with options %s.',
+                    \ string(filter(copy(options), "index(['bufnr', 'make_id'], v:key) == -1"))), {'make_id': make_id, 'bufnr': bufnr})
+    endif
+
+    " Use pre-compiled jobs (used with automake).
+    if has_key(options, 'jobs')
+        let jobs = map(copy(options.jobs), "extend(v:val, {'make_id': make_id})")
+    else
+        if has_key(options, 'enabled_makers')
+            if file_mode
+                let makers = neomake#map_makers(options.enabled_makers, options.ft, 0)
+            else
+                let makers = neomake#map_makers(options.enabled_makers, -1, 0)
+            endif
+        else
+            let makers = call('neomake#GetEnabledMakers', file_mode ? [options.ft] : [])
+            if empty(makers)
+                if file_mode
+                    let msg = printf('Nothing to make: no enabled file mode makers (filetype=%s).', options.ft)
+                    if is_automake
+                        call neomake#log#debug(msg, make_info)
+                    else
+                        call neomake#log#warning(msg, make_info)
+                    endif
+                    unlet s:make_info[make_id]
+                    return []
+                endif
+            endif
+        endif
+        let job_options = copy(options)
+        let job_options.make_id = make_id  " Used for logging.
+        let jobs = neomake#core#create_jobs(job_options, makers)
+    endif
+
+    if empty(jobs)
+        call neomake#log#debug('Nothing to make: no valid makers.', make_info)
+        call s:clean_make_info(make_info)
+        return []
+    endif
+    let make_info.jobs = copy(jobs)
+
+    let maker_info = join(map(copy(jobs),
+                \ "v:val.maker.name . (get(v:val.maker, 'auto_enabled', 0) ? ' (auto)' : '')"), ', ')
+    call neomake#log#debug(printf('Running makers: %s.', maker_info), make_info)
+
+    let make_info.jobs_queue = jobs
+
+    if file_mode
+        " XXX: this clears counts for job's buffer only, but we add counts for
+        " the entry's buffers, which might be different!
+        call neomake#statusline#ResetCountsForBuf(bufnr)
+        if g:neomake_place_signs
+            call neomake#signs#Reset(bufnr, 'file')
+        endif
+    else
+        call neomake#statusline#ResetCountsForProject()
+        if g:neomake_place_signs
+            call neomake#signs#ResetProject()
+        endif
+    endif
+
+    " Store make_id on window (used to find window for location lists (without
+    " winid, but also used to check the current window via w: directly)).
+    if file_mode
+        call setwinvar(file_mode_win, 'neomake_make_ids',
+                    \ neomake#compat#getwinvar(file_mode_win, 'neomake_make_ids', []) + [make_id])
+    endif
+
+    let use_list = get(options, 'use_list', 1)
+    if use_list
+        let any_job_uses_list = 0
+        for job in jobs
+            if get(job.maker, 'use_list', 1)
+                let any_job_uses_list = 1
+                break
+            endif
+        endfor
+        if !any_job_uses_list
+            let use_list = 0
+        endif
+    endif
+
+    if use_list
+        let make_info.entries_list = neomake#list#ListForMake(make_info)
+
+        " Reuse existing location list window with automake.
+        if is_automake && has('patch-7.4.2200')
+            if file_mode
+                let title = get(getloclist(0, {'title': 1}), 'title')
+            else
+                let title = get(getqflist({'title': 1}), 'title')
+            endif
+            if title =~# '\V\^Neomake[auto]'
+                let make_info.entries_list.reset_existing_qflist = 1
+            endif
+        endif
+    endif
+
+    " Cancel any already running jobs for the makers from these jobs.
+    if !empty(s:jobs)
+        " @vimlint(EVL102, 1, l:job)
+        for job in jobs
+            let running_already = values(filter(copy(s:jobs),
+                        \ 'v:val.maker == job.maker'
+                        \ .' && v:val.bufnr == job.bufnr'
+                        \ .' && v:val.file_mode == job.file_mode'
+                        \ ." && !get(v:val, 'canceled')"))
+            if !empty(running_already)
+                let jobinfo = running_already[0]
+                call neomake#log#info(printf(
+                            \ 'Canceling already running job (%d.%d) for the same maker.',
+                            \ jobinfo.make_id, jobinfo.id), {'make_id': make_id})
+                call neomake#CancelJob(jobinfo.id, 1)
+            endif
+        endfor
+    endif
+
+    " Update automake tick (used to skip unchanged buffers).
+    call neomake#configure#_update_automake_tick(bufnr, options.ft)
+
+    " Start all jobs in the queue (until serialized).
+    let jobinfos = []
+    while 1
+        if empty(make_info.jobs_queue)
+            break
+        endif
+        let jobinfo = s:handle_next_job({})
+        if empty(jobinfo)
+            break
+        endif
+        call add(jobinfos, jobinfo)
+        if jobinfo.serialize
+            let make_info.serializing_for_job = jobinfo.id
+            " Break and continue through exit handler.
+            break
+        endif
+    endwhile
+    return jobinfos
+endfunction
+
+function! s:AddExprCallback(jobinfo, lines) abort
+    if s:need_to_postpone_loclist(a:jobinfo)
+        return neomake#action_queue#add(['BufEnter', 'WinEnter'], [s:function('s:AddExprCallback'),
+                    \ [a:jobinfo, a:lines] + a:000])
+    endif
+
+    " Create location/quickfix list and add lines to it.
+    let cd_error = a:jobinfo.cd()
+    if !empty(cd_error)
+        call neomake#log#debug(printf(
+                    \ "Could not change to job's cwd (%s): %s.",
+                    \ a:jobinfo.cd_from_setting, cd_error), a:jobinfo)
+    endif
+
+    let make_list = s:make_info[a:jobinfo.make_id].entries_list
+    let prev_list = copy(make_list.entries)
+
+    let added_entries = make_list.add_lines_with_efm(a:lines, a:jobinfo)
+    return s:ProcessEntries(a:jobinfo, added_entries, prev_list)
+endfunction
+
+function! s:CleanJobinfo(jobinfo, ...) abort
+    if get(a:jobinfo, '_in_exit_handler', 0)
+        " Do not clean job yet.
+        return
+    endif
+    if !empty(a:jobinfo.pending_output) && !get(a:jobinfo, 'canceled', 0)
+        call neomake#log#debug(
+                    \ 'Output left to be processed, not cleaning job yet.', a:jobinfo)
+        return g:neomake#action_queue#not_processed
+    endif
+
+    let queued_actions = neomake#action_queue#get_queued_actions(a:jobinfo)
+    if !empty(queued_actions)
+        call neomake#log#debug(printf(
+                    \ 'Skipping cleaning of job info because of queued actions: %s.',
+                    \ join(queued_actions, ', ')), a:jobinfo)
+        return neomake#action_queue#add(['WinEnter'], [s:function('s:CleanJobinfo'), [a:jobinfo]])
+    endif
+
+    call neomake#log#debug('Cleaning jobinfo.', a:jobinfo)
+    let a:jobinfo.finished = 1
+
+    if !has_key(s:make_info, a:jobinfo.make_id)
+        return g:neomake#action_queue#processed
+    endif
+    let make_info = s:make_info[a:jobinfo.make_id]
+
+    if has_key(s:jobs, get(a:jobinfo, 'id', -1))
+        call remove(s:jobs, a:jobinfo.id)
+        call filter(s:map_job_ids, 'v:val != a:jobinfo.id')
+    endif
+
+    if exists('s:kill_vim_timers')
+        for [timer, job] in items(s:kill_vim_timers)
+            if job == a:jobinfo
+                call timer_stop(+timer)
+                unlet s:kill_vim_timers[timer]
+                break
+            endif
+        endfor
+    endif
+
+    if !get(a:jobinfo, 'canceled', 0)
+                \ && !get(a:jobinfo, 'failed_to_start', 0)
+        let make_info.finished_jobs += [a:jobinfo]
+        call neomake#utils#hook('NeomakeJobFinished', {'jobinfo': a:jobinfo})
+    endif
+
+    call filter(make_info.active_jobs, 'v:val != a:jobinfo')
+
+    " Trigger cleanup (and autocommands) if all jobs have finished.
+    if empty(make_info.active_jobs) && empty(make_info.jobs_queue)
+        call s:clean_make_info(make_info)
+    endif
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:clean_make_info(make_info, ...) abort
+    let make_id = a:make_info.make_id
+    let bang = a:0 ? a:1 : 0
+    if !bang && !empty(a:make_info.active_jobs)
+        call neomake#log#debug(printf(
+                    \ 'Skipping cleaning of make info: %d active jobs: %s.',
+                    \ len(a:make_info.active_jobs),
+                    \ string(map(copy(a:make_info.active_jobs), 'v:val.as_string()'))),
+                    \ a:make_info)
+        return
+    endif
+
+    " Queue cleanup in case of queued actions, e.g. NeomakeJobFinished hook.
+    let queued = []
+    for [_, v] in g:neomake#action_queue#_s.action_queue
+        if has_key(v[1][0], 'id')
+            let jobinfo = v[1][0]
+            if jobinfo.make_id == make_id
+                let queued += ['job '.jobinfo.id]
+            endif
+        else
+            if v[1][0] == a:make_info
+                let queued += ['make '.make_id]
+            endif
+        endif
+    endfor
+    if !empty(queued)
+        call neomake#log#debug(printf('Queuing clean_make_info for already queued actions: %s', string(queued)))
+        return neomake#action_queue#add(
+                    \ g:neomake#action_queue#any_event,
+                    \ [s:function('s:clean_make_info'), [a:make_info]])
+    endif
+
+    if exists('*neomake#statusline#make_finished')
+        call neomake#statusline#make_finished(a:make_info)
+    endif
+
+    if !empty(a:make_info.finished_jobs)
+        " Clean old signs after all jobs have finished, so that they can be
+        " reused, avoiding flicker and keeping them for longer in general.
+        if g:neomake_place_signs
+            if a:make_info.options.file_mode
+                call neomake#signs#CleanOldSigns(a:make_info.options.bufnr, 'file')
+            else
+                call neomake#signs#CleanAllOldSigns('project')
+            endif
+        endif
+        call s:clean_for_new_make(a:make_info)
+
+        call neomake#EchoCurrentError(1)
+        call neomake#virtualtext#handle_current_error()
+
+        if get(a:make_info, 'canceled', 0)
+            call neomake#log#debug('Skipping final processing for canceled make.', a:make_info)
+            call s:do_clean_make_info(a:make_info)
+        elseif has_key(a:make_info, 'entries_list')  " use_list option
+            return s:handle_locqf_list_for_finished_jobs(a:make_info)
+        else
+            call s:handle_finished_make(a:make_info)
+        endif
+    else
+        call s:do_clean_make_info(a:make_info)
+    endif
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:do_clean_make_info(make_info) abort
+    call neomake#log#debug('Cleaning make info.', a:make_info)
+    let make_id = a:make_info.make_id
+
+    " Remove make_id from its window.
+    let [t, w] = neomake#core#get_tabwin_for_makeid(make_id)
+    if [t, w] != [-1, -1]
+        let make_ids = neomake#compat#gettabwinvar(t, w, 'neomake_make_ids', [])
+        let idx = index(make_ids, make_id)
+        if idx != -1
+            call remove(make_ids, idx)
+            call settabwinvar(t, w, 'neomake_make_ids', make_ids)
+        endif
+    endif
+
+    " Clean up temporary files and buffers.
+    let wipe_unlisted_buffers = get(a:make_info, '_wipe_unlisted_buffers', [])
+    let tempfiles = get(a:make_info, 'tempfiles')
+    if !empty(tempfiles)
+        for tempfile in tempfiles
+            let delete_ret = delete(tempfile)
+            if delete_ret == 0
+                call neomake#log#debug(printf('Removing temporary file: "%s".',
+                            \ tempfile))
+            else
+                call neomake#log#warning(printf('Failed to remove temporary file: "%s" (%d).',
+                            \ tempfile, delete_ret))
+            endif
+            let bufnr_tempfile = bufnr(tempfile)
+            if bufnr_tempfile != -1 && !buflisted(bufnr_tempfile)
+                let wipe_unlisted_buffers += [bufnr_tempfile]
+            endif
+        endfor
+
+        " Only delete the dir, if Vim supports it.
+        if v:version >= 705 || (v:version == 704 && has('patch1107'))
+            for dir in reverse(copy(get(a:make_info, 'created_dirs')))
+                call delete(dir, 'd')
+            endfor
+        endif
+    endif
+    if !empty(wipe_unlisted_buffers)
+        if !empty(wipe_unlisted_buffers)
+            call neomake#compat#uniq(sort(wipe_unlisted_buffers))
+        endif
+        call neomake#log#debug(printf('Wiping out %d unlisted/remapped buffers: %s.',
+                    \ len(wipe_unlisted_buffers),
+                    \ string(wipe_unlisted_buffers)))
+        " NOTE: needs to be silent with more than a single buffer.
+        exe 'silent bwipeout '.join(wipe_unlisted_buffers)
+    endif
+
+    let buf_prev_makes = getbufvar(a:make_info.options.bufnr, '_neomake_automake_make_ids')
+    if !empty(buf_prev_makes)
+        call filter(buf_prev_makes, 'v:val != make_id')
+        call setbufvar(a:make_info.options.bufnr, '_neomake_automake_make_ids', buf_prev_makes)
+    endif
+
+    unlet s:make_info[make_id]
+endfunction
+
+function! s:handle_locqf_list_for_finished_jobs(make_info) abort
+    let file_mode = a:make_info.options.file_mode
+    let create_list = a:make_info.entries_list.need_init
+
+    let open_val = get(g:, 'neomake_open_list', 0)
+    let height = open_val ? get(g:, 'neomake_list_height', 10) : 0
+    if height
+        let close_list = create_list || empty(file_mode ? getloclist(0) : getqflist())
+    else
+        let close_list = 0
+    endif
+
+    if file_mode
+        if create_list && !bufexists(a:make_info.options.bufnr)
+            call neomake#log#info('No buffer found for location list!', a:make_info)
+            let create_list = 0
+            let close_list = 0
+        elseif (create_list || close_list)
+            if index(get(w:, 'neomake_make_ids', []), a:make_info.make_id) == -1
+                call neomake#log#debug(
+                            \ 'Postponing final location list handling (in another window).',
+                            \ a:make_info)
+                return neomake#action_queue#add(['WinEnter'], [s:function('s:handle_locqf_list_for_finished_jobs'),
+                            \ [a:make_info] + a:000])
+            endif
+
+            " TODO: merge with s:need_to_postpone_output_processing.
+            if neomake#compat#in_completion()
+                call neomake#log#debug(
+                            \ 'Postponing final location list handling during completion.',
+                            \ a:make_info)
+                return neomake#action_queue#add(['CompleteDone'], [s:function('s:handle_locqf_list_for_finished_jobs'),
+                            \ [a:make_info] + a:000])
+            endif
+            let mode = neomake#compat#get_mode()
+            if index(['n', 'i'], mode) == -1
+                call neomake#log#debug(printf(
+                            \ 'Postponing final location list handling for mode "%s".', mode),
+                            \ a:make_info)
+                return neomake#action_queue#add(['CursorHold', 'WinEnter'], [s:function('s:handle_locqf_list_for_finished_jobs'),
+                            \ [a:make_info] + a:000])
+            endif
+        endif
+    endif
+
+    " Update list title.
+    " This has to be done currently by itself to reflect running/finished
+    " state properly.
+    if create_list || !a:make_info.entries_list.need_init
+        if has_key(a:make_info, 'entries_list')
+            call a:make_info.entries_list.finish_for_make()
+        endif
+    endif
+
+    " Close empty list.
+    if close_list
+        if file_mode
+            call neomake#log#debug('Handling location list: executing lclose.', {'winnr': winnr()})
+            lclose
+        else
+            call neomake#log#debug('Handling quickfix list: executing cclose.')
+            cclose
+        endif
+    endif
+
+    call s:handle_finished_make(a:make_info)
+
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:handle_finished_make(make_info) abort
+    let hook_context = {
+                \ 'make_info': a:make_info,
+                \ 'make_id': a:make_info.make_id,
+                \ 'options': a:make_info.options,
+                \ 'finished_jobs': a:make_info.finished_jobs,
+                \ }
+    call neomake#utils#hook('NeomakeFinished', hook_context)
+
+    call neomake#configure#_reset_automake_cancelations(a:make_info.options.bufnr)
+
+    call s:do_clean_make_info(a:make_info)
+endfunction
+
+function! neomake#VimLeave() abort
+    call neomake#log#debug('Calling VimLeave.')
+    for make_id in keys(s:make_info)
+        call neomake#CancelMake(make_id)
+    endfor
+endfunction
+
+function! s:clean_for_new_make(make_info) abort
+    if get(a:make_info, 'cleaned_for_make', 0)
+        return
+    endif
+    " XXX: needs to handle buffers for list entries?!
+    " See "get_list_entries: minimal example (from doc)" in
+    " tests/makers.vader.
+    call neomake#_clean_errors(extend(copy(a:make_info.options), {'make_id': a:make_info.make_id}))
+    let a:make_info.cleaned_for_make = 1
+endfunction
+
+" a:context: dictionary with keys:
+"  - file_mode
+"  - bufnr (required for file_mode)
+"  - make_id (used for logging)
+function! neomake#_clean_errors(context) abort
+    if a:context.file_mode
+        let bufnr = a:context.bufnr
+        if has_key(s:current_errors['file'], bufnr)
+            unlet s:current_errors['file'][bufnr]
+        endif
+        call neomake#highlights#ResetFile(bufnr)
+        call neomake#log#debug('File-level errors cleaned.', a:context)
+    else
+        let s:current_errors['project'] = {}
+        call neomake#highlights#ResetProject()
+        call neomake#log#debug('Project-level errors cleaned.', a:context)
+    endif
+endfunction
+
+" Change to a job's cwd, if any.
+" Returns: a list:
+"  - error (empty for success)
+"  - directory changed into (empty if skipped)
+"  - command to change back to the current workding dir (might be empty)
+
+" Call a:fn with a:args and queue it, in case if fails with E48/E523.
+function! s:pcall(fn, args) abort
+    let jobinfo = a:args[0]
+    try
+        return call(a:fn, a:args + [1])
+    catch /^\%(Vim\%((\a\+)\)\=:\%(E48\|E523\)\)/  " only E48/E523 (sandbox / not allowed here)
+        call neomake#log#debug('Error during pcall: '.v:exception.'.', jobinfo)
+        call neomake#log#debug(printf('(in %s)', v:throwpoint), jobinfo)
+        " Might throw in case of X failed attempts.
+        call neomake#action_queue#add(['Timer', 'WinEnter'], [s:function(a:fn), a:args])
+    endtry
+    return g:neomake#action_queue#not_processed
+endfunction
+
+function! s:ProcessEntries(jobinfo, entries, ...) abort
+    if empty(a:entries)
+        return
+    endif
+    if get(a:jobinfo, 'canceled')
+        return
+    endif
+    if s:need_to_postpone_loclist(a:jobinfo)
+        return neomake#action_queue#add(['BufEnter', 'WinEnter'], [s:function('s:ProcessEntries'),
+                    \ [a:jobinfo, a:entries] + a:000])
+    endif
+    if !a:0 || type(a:[len(a:000)]) != 0
+        return s:pcall('s:ProcessEntries', [a:jobinfo, a:entries] + a:000)
+    endif
+    let file_mode = a:jobinfo.file_mode
+
+    call neomake#log#debug(printf(
+                \ 'Processing %d entries.', len(a:entries)), a:jobinfo)
+
+    let make_info = s:make_info[a:jobinfo.make_id]
+    let make_list = make_info.entries_list
+    let maker_name = a:jobinfo.maker.name
+    if a:0 > 1
+        " Via errorformat processing, where the list has been set already.
+        let prev_list = a:1
+        let parsed_entries = a:entries
+    else
+        " Fix entries with get_list_entries/process_output/process_json.
+        " @vimlint(EVL102, 1, l:default_type)
+        let default_type = neomake#utils#GetSetting('default_entry_type', a:jobinfo.maker, 'W', a:jobinfo.ft, a:jobinfo.bufnr)
+        call map(a:entries, 'extend(v:val, {'
+                    \ . "'bufnr': str2nr(get(v:val, 'bufnr', 0)),"
+                    \ . "'lnum': str2nr(get(v:val, 'lnum', 0)),"
+                    \ . "'col': str2nr(get(v:val, 'col', 0)),"
+                    \ . "'vcol': str2nr(get(v:val, 'vcol', 0)),"
+                    \ . "'type': get(v:val, 'type', default_type),"
+                    \ . "'nr': get(v:val, 'nr', has_key(v:val, 'text') ? -1 : 0),"
+                    \ . "'text': get(v:val, 'text', ''),"
+                    \ . '})')
+
+        let cd_error = a:jobinfo.cd()
+        if !empty(cd_error)
+            call neomake#log#debug(printf(
+                        \ "Could not change to job's cwd (%s): %s.",
+                        \ a:jobinfo.cd_from_setting, cd_error), a:jobinfo)
+        endif
+
+        let prev_list = file_mode ? getloclist(0) : getqflist()
+        try
+            let parsed_entries = make_list.add_entries_for_job(a:entries, a:jobinfo)
+            if exists(':Assert') && !empty(a:entries)
+                Assert get(a:entries[0], 'text', '') !~# 'nmcfg:'
+            endif
+        finally
+            call a:jobinfo.cd_back()
+        endtry
+    endif
+    call s:clean_for_new_make(make_info)
+
+    let counts_changed = 0
+    let maker_type = file_mode ? 'file' : 'project'
+    let do_highlight = get(g:, 'neomake_highlight_columns', 1)
+                \ || get(g:, 'neomake_highlight_lines', 0)
+    let signs_by_bufnr = {}
+    let debug = neomake#utils#get_verbosity(a:jobinfo) >= 3 || !empty(get(g:, 'neomake_logfile')) || s:is_testing
+    let entries_with_lnum_by_bufnr = {}
+    let skipped_without_bufnr = []
+    let skipped_without_lnum = []
+
+    let idx = -1
+    for entry in parsed_entries
+        let idx += 1
+        if !file_mode
+            if neomake#statusline#AddQflistCount(entry)
+                let counts_changed = 1
+            endif
+        endif
+
+        if !entry.bufnr
+            if debug
+                let skipped_without_bufnr += [idx]
+            endif
+            continue
+        endif
+
+        if file_mode
+            if neomake#statusline#AddLoclistCount(entry.bufnr, entry)
+                let counts_changed = 1
+            endif
+        endif
+
+        if !entry.lnum
+            if debug
+                let skipped_without_lnum += [idx]
+            endif
+            continue
+        endif
+
+        if !has_key(entries_with_lnum_by_bufnr, entry.bufnr)
+            let entries_with_lnum_by_bufnr[entry.bufnr] = []
+            let signs_by_bufnr[entry.bufnr] = []
+        endif
+
+        if do_highlight || g:neomake_place_signs
+            " NOTE: only lnum/type required for signs.  Similar for do_highlight?!
+            call add(entries_with_lnum_by_bufnr[entry.bufnr], entry)
+        endif
+
+        " Track all errors by buffer and line
+        let entry.maker_name = maker_name
+        call neomake#_add_error(maker_type, entry)
+    endfor
+
+    " Handle placing signs and highlights.
+    for [b, entries] in items(entries_with_lnum_by_bufnr)
+        if g:neomake_place_signs
+            call neomake#signs#PlaceSigns(b, entries, maker_type)
+        endif
+        if do_highlight
+            for entry in entries
+                call neomake#highlights#AddHighlight(entry, maker_type)
+            endfor
+        endif
+    endfor
+
+    if !empty(skipped_without_bufnr)
+        call neomake#log#debug(printf('Skipped %d entries without bufnr: %s.',
+                    \ len(skipped_without_bufnr),
+                    \ string(map(skipped_without_bufnr, 'a:entries[v:val]'))), a:jobinfo)
+    endif
+
+    if !empty(skipped_without_lnum)
+        call neomake#log#debug(printf(
+                    \ 'Could not place signs for %d entries without line number: %s.',
+                    \ len(skipped_without_lnum),
+                    \ string(map(skipped_without_lnum, 'a:entries[v:val]'))), a:jobinfo)
+    endif
+
+    let new_list = make_list.entries
+    if !counts_changed
+        let counts_changed = new_list != prev_list
+    endif
+    if counts_changed
+        call neomake#utils#hook('NeomakeCountsChanged', {'reset': 0, 'jobinfo': a:jobinfo})
+    endif
+
+    if has_key(a:jobinfo, '_delayed_qf_autocmd') && exists('#QuickfixCmdPost')
+        " NOTE: need to use :silent, since we can only check the event, but
+        " not the pattern - `exists()` for 'laddexpr' will not match '*'.
+        silent call neomake#compat#doautocmd(a:jobinfo._delayed_qf_autocmd)
+        unlet a:jobinfo._delayed_qf_autocmd
+    endif
+
+    if !empty(new_list)
+        call s:HandleLoclistQflistDisplay(a:jobinfo, new_list)
+    endif
+    call neomake#highlights#ShowHighlights()
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:ProcessJobOutput(jobinfo, lines, source, ...) abort
+    if s:need_to_postpone_loclist(a:jobinfo)
+        return neomake#action_queue#add(['BufEnter', 'WinEnter'], [s:function('s:ProcessJobOutput'),
+                    \ [a:jobinfo, a:lines, a:source]])
+    endif
+    if !a:0
+        return s:pcall('s:ProcessJobOutput', [a:jobinfo, a:lines, a:source])
+    endif
+
+    let maker = a:jobinfo.maker
+    call neomake#log#debug(printf('Processing %d lines of output.',
+                \ len(a:lines)), a:jobinfo)
+    let cd_error = a:jobinfo.cd()
+    if !empty(cd_error)
+        call neomake#log#debug(printf(
+                    \ "Could not change to job's cwd (%s): %s.",
+                    \ a:jobinfo.cd_from_setting, cd_error), a:jobinfo)
+    endif
+    try
+        if has_key(maker, 'process_json') || has_key(maker, 'process_output')
+            if has_key(maker, 'process_json')
+                let method = 'process_json'
+                let output = join(a:lines, "\n")
+                try
+                    let json = neomake#compat#json_decode(output)
+                catch
+                    let error = printf(
+                                \ 'Failed to decode JSON: %s (output: %s).',
+                                \ substitute(v:exception, '^Neomake: ', '', ''), string(output))
+                    call neomake#log#exception(error, a:jobinfo)
+                    return g:neomake#action_queue#not_processed
+                endtry
+                call neomake#log#debug(printf(
+                            \ "Calling maker's process_json method with %d JSON entries.",
+                            \ len(json)), a:jobinfo)
+                let entries = call(maker.process_json, [{
+                            \ 'json': json,
+                            \ 'source': a:source,
+                            \ 'jobinfo': a:jobinfo}], maker)
+            else
+                call neomake#log#debug(printf(
+                            \ "Calling maker's process_output method with %d lines of output on %s.",
+                            \ len(a:lines), a:source), a:jobinfo)
+                let method = 'process_output'
+                let entries = call(maker.process_output, [{
+                            \ 'output': a:lines,
+                            \ 'source': a:source,
+                            \ 'jobinfo': a:jobinfo}], maker)
+            endif
+            if type(entries) != type([])
+                call neomake#log#error(printf('The %s method for maker %s did not return a list, but: %s.',
+                            \ method, maker.name, string(entries)[:100]), a:jobinfo)
+                return g:neomake#action_queue#not_processed
+            elseif !empty(entries) && type(entries[0]) != type({})
+                call neomake#log#error(printf('The %s method for maker %s did not return a list of dicts, but: %s.',
+                            \ method, maker.name, string(entries)[:100]), a:jobinfo)
+                return g:neomake#action_queue#not_processed
+            endif
+            return s:ProcessEntries(a:jobinfo, entries)
+        endif
+
+        " Old-school handling through errorformat.
+        if has_key(maker, 'mapexpr')
+            let neomake_bufname = fnamemodify(bufname(a:jobinfo.bufnr), ':p')
+            " @vimlint(EVL102, 1, l:neomake_bufdir)
+            let neomake_bufdir = fnamemodify(neomake_bufname, ':h')
+            " @vimlint(EVL102, 1, l:neomake_output_source)
+            let neomake_output_source = a:source
+            call map(a:lines, maker.mapexpr)
+        endif
+
+        if !empty(a:lines)
+            call s:AddExprCallback(a:jobinfo, a:lines)
+        endif
+    catch /^\%(Vim\%((\a\+)\)\=:\%(E48\|E523\)\)\@!/  " everything, but E48/E523 (sandbox / not allowed here)
+        if v:exception ==# 'NeomakeTestsException'
+            throw v:exception
+        endif
+        call neomake#log#exception(printf(
+                    \ 'Error during output processing for %s: %s.',
+                    \ a:jobinfo.maker.name, v:exception), a:jobinfo)
+        return
+    finally
+        call a:jobinfo.cd_back()
+    endtry
+    return g:neomake#action_queue#processed
+endfunction
+
+function! s:process_pending_output(jobinfo, lines, source, ...) abort
+    let retry_events = s:need_to_postpone_output_processing(a:jobinfo)
+    if empty(retry_events)
+        let retry_events = s:ProcessPendingOutput(a:jobinfo, a:lines, a:source)
+        if empty(retry_events)
+            return g:neomake#action_queue#processed
+        endif
+    endif
+    call add(a:jobinfo.pending_output, [a:lines, a:source])
+    if index(neomake#action_queue#get_queued_actions(a:jobinfo),
+                \ ['process_pending_output', retry_events]) == -1
+        return neomake#action_queue#add(retry_events, [s:function('s:process_pending_output'), [a:jobinfo, [], a:source, retry_events]])
+    endif
+    return g:neomake#action_queue#not_processed
+endfunction
+
+function! s:ProcessPendingOutput(jobinfo, lines, source) abort
+    if a:jobinfo.file_mode
+        let window_make_ids = get(w:, 'neomake_make_ids', [])
+        if index(window_make_ids, a:jobinfo.make_id) == -1
+            if !bufexists(a:jobinfo.bufnr)
+                call neomake#log#info('No buffer found for output!', a:jobinfo)
+                return []
+            endif
+
+            if a:jobinfo.bufnr != bufnr('%')
+                call neomake#log#debug(printf('Skipped pending job output for another buffer (current=%d).', bufnr('%')), a:jobinfo)
+                return ['BufEnter', 'WinEnter']
+            elseif neomake#core#get_tabwin_for_makeid(a:jobinfo.make_id) != [-1, -1]
+                call neomake#log#debug('Skipped pending job output (not in origin window).', a:jobinfo)
+                return ['WinEnter']
+            else
+                call neomake#log#debug("Processing pending output for job's buffer in new window.", a:jobinfo)
+                let w:neomake_make_ids = add(get(w:, 'neomake_make_ids', []), a:jobinfo.make_id)
+            endif
+        endif
+    endif
+
+    " Process any pending output first.
+    if !empty(a:jobinfo.pending_output)
+        let outputs = {'stdout': [], 'stderr': []}
+        for [lines, source] in a:jobinfo.pending_output
+            call extend(outputs[source], lines)
+        endfor
+        for [source, lines] in items(outputs)
+            if !empty(lines)
+                call s:ProcessJobOutput(a:jobinfo, lines, source)
+            endif
+        endfor
+        call neomake#log#debug(printf(
+                    \ 'Processed %d pending outputs.', len(a:jobinfo.pending_output)),
+                    \ a:jobinfo)
+        call neomake#action_queue#remove(a:jobinfo, s:function('s:process_pending_output'))
+    endif
+
+    if !empty(a:lines)
+        call s:ProcessJobOutput(a:jobinfo, a:lines, a:source)
+    endif
+
+    " Clean job if it had exited already.
+    if !empty(a:jobinfo.pending_output)
+        let a:jobinfo.pending_output = []
+        if has_key(a:jobinfo, 'exit_code')
+            " XXX: add test (tested manually)
+            call s:CleanJobinfo(a:jobinfo)
+        endif
+    endif
+    return []
+endfunction
+
+" Do we need to postpone location list processing (creation and :laddexpr)?
+function! s:need_to_postpone_loclist(jobinfo) abort
+    if !a:jobinfo.file_mode
+        return 0
+    endif
+    if index(get(w:, 'neomake_make_ids', []), a:jobinfo.make_id) != -1
+        return 0
+    endif
+    call neomake#log#debug('Postponing location list processing.', a:jobinfo)
+    return 1
+endfunction
+
+" TODO: merge with s:handle_locqf_list_for_finished_jobs.
+let s:has_getcmdwintype = exists('*getcmdwintype')
+function! s:need_to_postpone_output_processing(jobinfo) abort
+    " We can only process output (change the location/quickfix list) in
+    " certain modes, otherwise e.g. the visual selection gets lost.
+    if neomake#compat#in_completion()
+        call neomake#log#debug('Not processing output during completion.', a:jobinfo)
+        return ['CompleteDone']
+    endif
+    let mode = neomake#compat#get_mode()
+    if index(['n', 'i'], mode) == -1
+        call neomake#log#debug('Not processing output for mode "'.mode.'".', a:jobinfo)
+        return ['BufEnter', 'WinEnter', 'InsertLeave', 'CursorHold', 'CursorHoldI']
+    endif
+    if s:has_getcmdwintype && !empty(getcmdwintype())
+        call neomake#log#debug('Not processing output from command-line window "'.getcmdwintype().'".', a:jobinfo)
+        return ['InsertLeave', 'CursorHold', 'CursorHoldI']
+    endif
+    return []
+endfunction
+
+function! s:RegisterJobOutput(jobinfo, lines, source) abort
+    " Allow to filter output (storing the setting on the jobinfo lazily).
+    if !has_key(a:jobinfo, 'filter_output')
+        let a:jobinfo.filter_output = neomake#utils#GetSetting('filter_output', a:jobinfo.maker, '', a:jobinfo.ft, a:jobinfo.bufnr)
+    endif
+    if !empty(a:jobinfo.filter_output)
+        call call(a:jobinfo.filter_output, [
+                    \ a:lines, {'source': a:source, 'jobinfo': a:jobinfo}],
+                    \ a:jobinfo.maker)
+    endif
+
+    if empty(a:lines)
+        return
+    endif
+
+    " Register unexpected output.
+    if a:jobinfo.output_stream !=# 'both' && a:jobinfo.output_stream !=# a:source
+        if !has_key(a:jobinfo, 'unexpected_output')
+            let a:jobinfo.unexpected_output = {}
+        endif
+        if !has_key(a:jobinfo.unexpected_output, a:source)
+            let a:jobinfo.unexpected_output[a:source] = []
+        endif
+        let a:jobinfo.unexpected_output[a:source] += a:lines
+        return
+    endif
+
+    let make_info = s:make_info[a:jobinfo.make_id]
+    if has_key(make_info, 'entries_list')  " use_list option
+        " Process output for list processing.
+        call s:process_pending_output(a:jobinfo, a:lines, a:source)
+    endif
+endfunction
+
+function! s:vim_output_handler(channel, output, event_type) abort
+    let channel_id = ch_info(a:channel)['id']
+    let jobinfo = get(s:jobs, get(s:map_job_ids, channel_id, -1), {})
+    if empty(jobinfo)
+        call neomake#log#debug(printf("warn: job '%s' not found for output on %s.",
+                    \ a:channel, a:event_type))
+        return
+    endif
+    let data = split(a:output, '\r\?\n', 1)
+    call s:output_handler_queued(jobinfo, data, a:event_type, 0)
+endfunction
+
+function! s:vim_output_handler_stdout(channel, output) abort
+    call s:vim_output_handler(a:channel, a:output, 'stdout')
+endfunction
+
+function! s:vim_output_handler_stderr(channel, output) abort
+    call s:vim_output_handler(a:channel, a:output, 'stderr')
+endfunction
+
+function! s:vim_exit_handler(channel) abort
+    let channel_id = ch_info(a:channel)['id']
+    let jobinfo = get(s:jobs, get(s:map_job_ids, channel_id, -1), {})
+    if empty(jobinfo)
+        try
+            let job_info = job_info(ch_getjob(a:channel))
+        catch /^Vim(let):E916:/
+            " Might happen with older Vim (8.0.69, but not 8.0.586).
+            call neomake#log#debug(printf('exit: job not found: %s.', a:channel))
+            return
+        endtry
+        call neomake#log#debug(printf('exit: job not found: %s (%s).', a:channel, job_info))
+        return
+    endif
+    let job_info = job_info(ch_getjob(a:channel))
+
+    " Handle failing starts from Vim here.
+    let status = job_info['exitval']
+    if status == 122  " Vim uses EXEC_FAILED, but only on Unix?!
+        let jobinfo.failed_to_start = 1
+        " The error is on stderr.
+        let error = 'Vim job failed to run: '.substitute(join(jobinfo.stderr), '\v\s+$', '', '').'.'
+        let jobinfo.stderr = []
+        call neomake#log#error(error)
+        call s:CleanJobinfo(jobinfo)
+    else
+        call s:exit_handler(jobinfo, status)
+    endif
+endfunction
+
+" @vimlint(EVL108, 1)
+if has('nvim-0.2.0')
+" @vimlint(EVL108, 0)
+    function! s:nvim_output_handler(job_id, data, event_type) abort
+        let jobinfo = get(s:jobs, get(s:map_job_ids, a:job_id, -1), {})
+        if empty(jobinfo)
+            call neomake#log#debug(printf('output [%s]: job %d not found.', a:event_type, a:job_id))
+            return
+        endif
+        if a:data == [''] && !exists('jobinfo[a:event_type]')
+            " EOF in Neovim (see :h on_data).
+            return
+        endif
+        call s:output_handler_queued(jobinfo, copy(a:data), a:event_type, 1)
+    endfunction
+else
+    " Neovim: register output from jobs as quick as possible, and trigger
+    " processing through a timer.
+    " This works around https://github.com/neovim/neovim/issues/5889).
+    " NOTE: a:data is never [''] here (like with other/newer Neovim
+    " handlers)
+    let s:nvim_output_handler_queue = []
+    function! s:nvim_output_handler(job_id, data, event_type) abort
+        let jobinfo = get(s:jobs, get(s:map_job_ids, a:job_id, -1), {})
+        if empty(jobinfo)
+            call neomake#log#debug(printf('output [%s]: job %d not found.', a:event_type, a:job_id))
+            return
+        endif
+        let args = [jobinfo, copy(a:data), a:event_type, 1]
+        call add(s:nvim_output_handler_queue, args)
+        if !exists('jobinfo._nvim_in_handler')
+            let jobinfo._nvim_in_handler = 1
+        else
+            let jobinfo._nvim_in_handler += 1
+        endif
+        if !exists('s:nvim_output_handler_timer')
+            let s:nvim_output_handler_timer = timer_start(0, function('s:nvim_output_handler_cb'))
+        endif
+    endfunction
+
+    function! s:nvim_output_handler_cb(_timer) abort
+        while !empty(s:nvim_output_handler_queue)
+            let args = remove(s:nvim_output_handler_queue, 0)
+            let jobinfo = args[0]
+            call call('s:output_handler', args)
+            let jobinfo._nvim_in_handler -= 1
+
+            if !jobinfo._nvim_in_handler
+                " Trigger previously delayed exit handler.
+                unlet jobinfo._nvim_in_handler
+                if exists('jobinfo._exited_while_in_handler')
+                    call neomake#log#debug('Trigger delayed exit.', jobinfo)
+                    call s:exit_handler(jobinfo, jobinfo._exited_while_in_handler)
+                endif
+            endif
+        endwhile
+        unlet! s:nvim_output_handler_timer
+    endfunction
+endif
+
+" Exit handler for buffered output with Neovim.
+" In this case the output gets stored on the jobstart-options dict.
+function! s:nvim_exit_handler_buffered(job_id, data, _event_type) abort
+    let jobinfo = get(s:jobs, get(s:map_job_ids, a:job_id, -1), {})
+    if empty(jobinfo)
+        call neomake#log#debug(printf('exit: job not found: %d.', a:job_id))
+        return
+    endif
+
+    for stream in ['stdout', 'stderr']
+        if has_key(jobinfo.jobstart_opts, stream)
+            let data = copy(jobinfo.jobstart_opts[stream])
+            if data == ['']
+                " EOF in Neovim (see :h on_data).
+                continue
+            endif
+            call s:output_handler(jobinfo, data, stream, 1)
+        endif
+    endfor
+
+    call s:exit_handler(jobinfo, a:data)
+endfunction
+
+function! s:nvim_exit_handler(job_id, data, _event_type) abort
+    let jobinfo = get(s:jobs, get(s:map_job_ids, a:job_id, -1), {})
+    if empty(jobinfo)
+        call neomake#log#debug(printf('exit: job not found: %d.', a:job_id))
+        return
+    endif
+    call s:exit_handler(jobinfo, a:data)
+endfunction
+
+function! s:exit_handler(jobinfo, data) abort
+    let jobinfo = a:jobinfo
+    let jobinfo.exit_code = a:data
+    if get(jobinfo, 'canceled')
+        call neomake#log#debug('exit: job was canceled.', jobinfo)
+        call s:CleanJobinfo(jobinfo)
+        return
+    endif
+    let maker = jobinfo.maker
+
+    if exists('jobinfo._output_while_in_handler') || exists('jobinfo._nvim_in_handler')
+        let jobinfo._exited_while_in_handler = a:data
+        call neomake#log#debug(printf('exit (delayed): %s: %s.',
+                    \ maker.name, string(a:data)), jobinfo)
+        return
+    endif
+    call neomake#log#debug(printf('exit: %s: %s.',
+                \ maker.name, string(a:data)), jobinfo)
+
+    let jobinfo._in_exit_handler = 1
+    try
+        " Handle any unfinished lines from stdout/stderr callbacks.
+        for event_type in ['stdout', 'stderr']
+            if has_key(jobinfo, event_type)
+                let lines = jobinfo[event_type]
+                if !empty(lines)
+                    if lines[-1] ==# ''
+                        call remove(lines, -1)
+                    endif
+                    if !empty(lines)
+                        call s:RegisterJobOutput(jobinfo, lines, event_type)
+                    endif
+                    unlet jobinfo[event_type]
+                endif
+            endif
+        endfor
+
+        if !get(jobinfo, 'failed_to_start')
+            let l:ExitCallback = neomake#utils#GetSetting('exit_callback',
+                        \ extend(copy(jobinfo), maker), 0, jobinfo.ft, jobinfo.bufnr)
+            if ExitCallback isnot# 0
+                let callback_dict = { 'status': jobinfo.exit_code,
+                                    \ 'name': maker.name,
+                                    \ 'has_next': !empty(s:make_info[jobinfo.make_id].jobs_queue) }
+                try
+                    if type(ExitCallback) == type('')
+                        let l:ExitCallback = function(ExitCallback)
+                    endif
+                    call call(ExitCallback, [callback_dict], jobinfo)
+                catch
+                    call neomake#log#error(printf(
+                                \ 'Error during exit_callback: %s.', v:exception),
+                                \ jobinfo)
+                endtry
+            endif
+        endif
+
+        if s:async
+            if has('nvim') || jobinfo.exit_code != 122
+                call neomake#log#debug(printf(
+                            \ '%s: completed with exit code %d.',
+                            \ maker.name, jobinfo.exit_code), jobinfo)
+            endif
+            let jobinfo.finished = 1
+        endif
+
+        if has_key(jobinfo, 'unexpected_output')
+            redraw
+            for [source, output] in items(jobinfo.unexpected_output)
+                let msg = printf('%s: unexpected output on %s: ', maker.name, source)
+                call neomake#log#debug(msg . join(output, '\n') . '.', jobinfo)
+
+                echohl WarningMsg
+                echom printf('Neomake: %s%s', msg, output[0])
+                for line in output[1:-1]
+                    echom line
+                endfor
+                echohl None
+            endfor
+            call neomake#log#error(printf(
+                        \ '%s: unexpected output. See :messages for more information.', maker.name), jobinfo)
+        endif
+    finally
+        unlet jobinfo._in_exit_handler
+    endtry
+    call s:handle_next_job(jobinfo)
+endfunction
+
+function! s:output_handler_queued(jobinfo, data, event_type, trim_CR) abort
+    let jobinfo = a:jobinfo
+    if exists('jobinfo._output_while_in_handler')
+        call neomake#log#debug(printf('Queuing: %s: %s: %s.',
+                    \ a:event_type, jobinfo.maker.name, string(a:data)), jobinfo)
+        let jobinfo._output_while_in_handler += [[jobinfo, a:data, a:event_type, a:trim_CR]]
+        return
+    else
+        let jobinfo._output_while_in_handler = []
+    endif
+
+    call s:output_handler(jobinfo, a:data, a:event_type, a:trim_CR)
+
+    " Process queued events that might have arrived by now.
+    " The attribute might be unset here, since output_handler might have
+    " been interrupted.
+    if exists('jobinfo._output_while_in_handler')
+        while has_key(jobinfo, '_output_while_in_handler') && !empty(jobinfo._output_while_in_handler)
+            let args = remove(jobinfo._output_while_in_handler, 0)
+            call call('s:output_handler', args)
+        endwhile
+        unlet! jobinfo._output_while_in_handler
+    endif
+    " Trigger previously delayed exit handler.
+    if exists('jobinfo._exited_while_in_handler')
+        call neomake#log#debug('Trigger delayed exit.', jobinfo)
+        call s:exit_handler(jobinfo, jobinfo._exited_while_in_handler)
+    endif
+endfunction
+
+function! s:output_handler(jobinfo, data, event_type, trim_CR) abort
+    let jobinfo = a:jobinfo
+    call neomake#log#debug(printf('output on %s: %s.',
+                \ a:event_type, string(a:data)), jobinfo)
+    if get(jobinfo, 'canceled')
+        call neomake#log#debug('Ignoring output (job was canceled).', jobinfo)
+        return
+    endif
+    let data = copy(a:data)
+    if a:trim_CR && !empty(a:data)
+        call map(data, "substitute(v:val, '\\r$', '', '')")
+    endif
+    let last_event_type = get(jobinfo, 'event_type', a:event_type)
+
+    " data is a list of 'lines' read. Each element *after* the first
+    " element represents a newline.
+    if has_key(jobinfo, a:event_type)
+        let jobinfo[a:event_type][-1] .= data[0]
+        call extend(jobinfo[a:event_type], data[1:])
+    else
+        let jobinfo[a:event_type] = data
+    endif
+
+    if !jobinfo.buffer_output || last_event_type !=# a:event_type
+        let lines = jobinfo[a:event_type][:-2]
+        let jobinfo[a:event_type] = jobinfo[a:event_type][-1:]
+
+        if !empty(lines)
+            call s:RegisterJobOutput(jobinfo, lines, a:event_type)
+        endif
+    endif
+endfunction
+
+function! s:abort_next_makers(make_id) abort
+    let jobs_queue = s:make_info[a:make_id].jobs_queue
+    if !empty(jobs_queue)
+        let next_makers = join(map(copy(jobs_queue), 'v:val.maker.name'), ', ')
+        call neomake#log#info('Aborting next makers: '.next_makers.'.', {'make_id': a:make_id})
+        let s:make_info[a:make_id].aborted_jobs = copy(s:make_info[a:make_id].jobs_queue)
+        let s:make_info[a:make_id].jobs_queue = []
+    endif
+endfunction
+
+function! s:handle_next_job(prev_jobinfo) abort
+    let make_id = get(a:prev_jobinfo, 'make_id', s:make_id)
+    if !has_key(s:make_info, make_id)
+        return {}
+    endif
+    let make_info = s:make_info[make_id]
+
+    if !empty(a:prev_jobinfo)
+        let status = get(a:prev_jobinfo, 'exit_code', 0)
+        if status != 0 && index([122, 127], status) == -1
+            " TODO: mark maker.exe as non-executable with status 127, and
+            "       maybe re-introduce a wrapper for `executable()` to handle it.
+            "       Ref: https://github.com/neomake/neomake/issues/1699
+            if neomake#utils#GetSetting('serialize_abort_on_error', a:prev_jobinfo.maker, 0, a:prev_jobinfo.ft, a:prev_jobinfo.bufnr)
+                let a:prev_jobinfo.aborted = 1
+                call s:abort_next_makers(make_id)
+                call s:CleanJobinfo(a:prev_jobinfo)
+                return {}
+            endif
+        endif
+        call s:CleanJobinfo(a:prev_jobinfo)
+        if !has_key(s:make_info, make_id)
+            " Last job was cleaned.
+            return {}
+        endif
+
+        let serializing_for_job = get(make_info, 'serializing_for_job')
+        if serializing_for_job
+            if serializing_for_job != a:prev_jobinfo.id
+                call neomake#log#debug(printf('waiting for job %d to finish.', serializing_for_job))
+                return {}
+            endif
+            unlet make_info.serializing_for_job
+        endif
+    endif
+
+    " Create job from the start of the queue, returning it.
+    while !empty(make_info.jobs_queue)
+        let options = remove(make_info.jobs_queue, 0)
+        let maker = options.maker
+        if empty(maker)
+            continue
+        endif
+
+        " Serialization of jobs, always for non-async Vim.
+        if !has_key(options, 'serialize')
+            if !s:async || neomake#utils#GetSetting('serialize', maker, 0, options.ft, options.bufnr)
+                let options.serialize = 1
+            else
+                let options.serialize = 0
+            endif
+        endif
+        try
+            let jobinfo = s:MakeJob(make_id, options)
+        catch /^Neomake: /
+            let log_context = extend(options, {'make_id': make_id})
+            if v:exception =~# '\v^Neomake: skip_job: '
+                let msg = substitute(v:exception, '^Neomake: skip_job: ', '', '')
+                call neomake#log#debug(printf('Skipping job: %s', msg), log_context)
+            else
+                let error = substitute(v:exception, '^Neomake: ', '', '')
+                call neomake#log#exception(error, log_context)
+
+                if options.serialize
+                    if neomake#utils#GetSetting('serialize_abort_on_error', maker, 0, options.ft, options.bufnr)
+                        call s:abort_next_makers(make_id)
+                        break
+                    endif
+                endif
+            endif
+            continue
+        endtry
+        if !empty(jobinfo)
+            return jobinfo
+        endif
+    endwhile
+
+    " Cleanup make info, but only if there are no queued actions.
+    for [_, v] in g:neomake#action_queue#_s.action_queue
+        if v[1][0] == make_info
+            call neomake#log#debug('Skipping cleaning of make info for queued actions.', make_info)
+            return {}
+        endif
+    endfor
+    call s:clean_make_info(make_info)
+    return {}
+endfunction
+
+function! neomake#_add_error(maker_type, entry) abort
+    if !has_key(s:current_errors[a:maker_type], a:entry.bufnr)
+        let s:current_errors[a:maker_type][a:entry.bufnr] = {}
+    endif
+    if !has_key(s:current_errors[a:maker_type][a:entry.bufnr], a:entry.lnum)
+        let s:current_errors[a:maker_type][a:entry.bufnr][a:entry.lnum] = [a:entry]
+    else
+        call add(s:current_errors[a:maker_type][a:entry.bufnr][a:entry.lnum], a:entry)
+    endif
+endfunction
+
+function! neomake#get_nearest_error() abort
+    let buf = bufnr('%')
+    let ln = line('.')
+    let ln_errors = []
+
+    for maker_type in ['file', 'project']
+        let buf_errors = get(s:current_errors[maker_type], buf, {})
+        let ln_errors += get(buf_errors, ln, [])
+    endfor
+
+    if empty(ln_errors)
+        return {}
+    endif
+
+    if len(ln_errors) > 1
+        call sort(ln_errors, function('neomake#utils#sort_by_col'))
+    endif
+    return ln_errors[0]
+endfunction
+
+function! neomake#GetCurrentErrorMsg() abort
+    let entry = neomake#get_nearest_error()
+    if empty(entry)
+        return ''
+    endif
+    let r = entry.maker_name . ': ' . entry.text
+    let suffix = entry.type . (entry.nr != -1 ? entry.nr : '')
+    if !empty(suffix)
+        let r .= ' ('.suffix.')'
+    endif
+    return r
+endfunction
+
+function! neomake#EchoCurrentError(...) abort
+    if !get(g:, 'neomake_echo_current_error', 1)
+        return
+    endif
+    " a:1 might be a timer from the VimResized event.
+    let force = a:0 ? a:1 : 0
+
+    let message = neomake#GetCurrentErrorMsg()
+    if empty(message)
+        if exists('s:neomake_last_echoed_error')
+            echon ''
+            unlet s:neomake_last_echoed_error
+        endif
+        return
+    endif
+    if !force && exists('s:neomake_last_echoed_error')
+                \ && s:neomake_last_echoed_error == message
+        return
+    endif
+    let s:neomake_last_echoed_error = message
+    call neomake#utils#WideMessage(message)
+endfunction
+
+function! neomake#CursorMoved() abort
+    call neomake#EchoCurrentError()
+    call neomake#virtualtext#handle_current_error()
+endfunction
+
+function! s:cursormoved_delayed_cb(...) abort
+    if getpos('.') == s:cursormoved_last_pos
+        call neomake#CursorMoved()
+    endif
+endfunction
+function! neomake#CursorMovedDelayed() abort
+    if exists('s:cursormoved_timer')
+        call timer_stop(s:cursormoved_timer)
+    endif
+    let delay = get(g:, 'neomake_cursormoved_delay', 100)
+    let s:cursormoved_timer = timer_start(delay, function('s:cursormoved_delayed_cb'))
+    let s:cursormoved_last_pos = getpos('.')
+endfunction
+
+function! neomake#Make(file_mode_or_options, ...) abort
+    if type(a:file_mode_or_options) == type({})
+        return s:Make(a:file_mode_or_options)
+    endif
+
+    let file_mode = a:file_mode_or_options
+    let options = {'file_mode': file_mode}
+    if file_mode
+        let options.ft = &filetype
+    endif
+    if a:0
+        if !empty(a:1)
+            let maker_names = a:1
+            " Split names on non-breaking space (annotation from completion).
+            call map(maker_names, "type(v:val) == 1 ? split(v:val, ' (')[0] : v:val")
+            let options.enabled_makers = a:1
+        endif
+        if a:0 > 1
+            let options.exit_callback = a:2
+        endif
+    endif
+    return map(copy(s:Make(options)), 'v:val.id')
+endfunction
+
+function! neomake#ShCommand(bang, sh_command, ...) abort
+    let maker = neomake#utils#MakerFromCommand(a:sh_command)
+    let maker.name = 'sh: '.a:sh_command
+    let maker.errorformat = '%m'
+    let maker.default_entry_type = ''
+    let options = {
+                \ 'enabled_makers': [maker],
+                \ 'file_mode': 0,
+                \ 'output_stream': 'both',
+                \ 'buffer_output': !a:bang,
+                \ }
+    if a:0
+        call extend(options, a:1)
+    endif
+    let jobinfos = s:Make(options)
+    return empty(jobinfos) ? -1 : jobinfos[0].id
+endfunction
+
+function! neomake#Sh(sh_command, ...) abort
+    " Deprecated, but documented.
+    let options = a:0 ? { 'exit_callback': a:1 } : {}
+    return neomake#ShCommand(0, a:sh_command, options)
+endfunction
+
+function! neomake#map_makers(makers, ft, auto_enabled) abort
+    let makers = []
+    let errors = []
+    let get_args = a:ft is# -1 ? [] : [a:ft]
+    for maker in a:makers
+        try
+            let m = call('neomake#GetMaker', [maker] + get_args)
+        catch /^Neomake: /
+            call add(errors, substitute(v:exception, '^Neomake: ', '', '').'.')
+            unlet maker  " vim73/vim-trusty
+            continue
+        endtry
+        call add(makers, m)
+        unlet maker  " vim73/vim-trusty
+    endfor
+    if !empty(errors)
+        let log_context = get(s:make_info, s:make_id, {})
+        for error in errors
+            if a:auto_enabled
+                call neomake#log#debug(error, log_context)
+            else
+                call neomake#log#error(error, log_context)
+            endif
+        endfor
+    endif
+    return makers
+endfunction