9594d34003
Remove the call to deepcopy() and use some alternative logic instead. This improves performance massively for large location lists. More aggressive caching is needed really though since this function is called multiple times to return the same data.
620 lines
18 KiB
VimL
620 lines
18 KiB
VimL
"============================================================================
|
|
"File: syntastic.vim
|
|
"Description: vim plugin for on the fly syntax checking
|
|
"Maintainer: Martin Grenfell <martin.grenfell at gmail dot com>
|
|
"Version: 2.3.0
|
|
"Last Change: 16 Feb, 2012
|
|
"License: This program is free software. It comes without any warranty,
|
|
" to the extent permitted by applicable law. You can redistribute
|
|
" it and/or modify it under the terms of the Do What The Fuck You
|
|
" Want To Public License, Version 2, as published by Sam Hocevar.
|
|
" See http://sam.zoy.org/wtfpl/COPYING for more details.
|
|
"
|
|
"============================================================================
|
|
|
|
if exists("g:loaded_syntastic_plugin")
|
|
finish
|
|
endif
|
|
let g:loaded_syntastic_plugin = 1
|
|
|
|
let s:running_windows = has("win16") || has("win32") || has("win64")
|
|
|
|
if !s:running_windows
|
|
let s:uname = system('uname')
|
|
endif
|
|
|
|
if !exists("g:syntastic_enable_signs")
|
|
let g:syntastic_enable_signs = 1
|
|
endif
|
|
if !has('signs')
|
|
let g:syntastic_enable_signs = 0
|
|
endif
|
|
|
|
if !exists("g:syntastic_enable_balloons")
|
|
let g:syntastic_enable_balloons = 1
|
|
endif
|
|
if !has('balloon_eval')
|
|
let g:syntastic_enable_balloons = 0
|
|
endif
|
|
|
|
if !exists("g:syntastic_enable_highlighting")
|
|
let g:syntastic_enable_highlighting = 1
|
|
endif
|
|
|
|
if !exists("g:syntastic_echo_current_error")
|
|
let g:syntastic_echo_current_error = 1
|
|
endif
|
|
|
|
if !exists("g:syntastic_auto_loc_list")
|
|
let g:syntastic_auto_loc_list = 2
|
|
endif
|
|
|
|
if !exists("g:syntastic_auto_jump")
|
|
let syntastic_auto_jump=0
|
|
endif
|
|
|
|
if !exists("g:syntastic_quiet_warnings")
|
|
let g:syntastic_quiet_warnings = 0
|
|
endif
|
|
|
|
if !exists("g:syntastic_stl_format")
|
|
let g:syntastic_stl_format = '[Syntax: line:%F (%t)]'
|
|
endif
|
|
|
|
if !exists("g:syntastic_mode_map")
|
|
let g:syntastic_mode_map = {}
|
|
endif
|
|
|
|
if !has_key(g:syntastic_mode_map, "mode")
|
|
let g:syntastic_mode_map['mode'] = 'active'
|
|
endif
|
|
|
|
if !has_key(g:syntastic_mode_map, "active_filetypes")
|
|
let g:syntastic_mode_map['active_filetypes'] = []
|
|
endif
|
|
|
|
if !has_key(g:syntastic_mode_map, "passive_filetypes")
|
|
let g:syntastic_mode_map['passive_filetypes'] = []
|
|
endif
|
|
|
|
if !exists("g:syntastic_check_on_open")
|
|
let g:syntastic_check_on_open = 0
|
|
endif
|
|
|
|
if !exists("g:syntastic_loc_list_height")
|
|
let g:syntastic_loc_list_height = 10
|
|
endif
|
|
|
|
command! SyntasticToggleMode call s:ToggleMode()
|
|
command! SyntasticCheck call s:UpdateErrors(0) <bar> redraw!
|
|
command! Errors call s:ShowLocList()
|
|
|
|
highlight link SyntasticError SpellBad
|
|
highlight link SyntasticWarning SpellCap
|
|
|
|
augroup syntastic
|
|
if g:syntastic_echo_current_error
|
|
autocmd cursormoved * call s:EchoCurrentError()
|
|
endif
|
|
|
|
autocmd BufReadPost * if g:syntastic_check_on_open | call s:UpdateErrors(1) | endif
|
|
autocmd BufWritePost * call s:UpdateErrors(1)
|
|
|
|
autocmd BufWinEnter * if empty(&bt) | call s:AutoToggleLocList() | endif
|
|
autocmd BufWinLeave * if empty(&bt) | lclose | endif
|
|
augroup END
|
|
|
|
|
|
"refresh and redraw all the error info for this buf when saving or reading
|
|
function! s:UpdateErrors(auto_invoked)
|
|
if !empty(&buftype)
|
|
return
|
|
endif
|
|
|
|
if !a:auto_invoked || s:ModeMapAllowsAutoChecking()
|
|
call s:CacheErrors()
|
|
end
|
|
|
|
if s:BufHasErrorsOrWarningsToDisplay()
|
|
call setloclist(0, s:LocList())
|
|
endif
|
|
|
|
if g:syntastic_enable_balloons
|
|
call s:RefreshBalloons()
|
|
endif
|
|
|
|
if g:syntastic_enable_signs
|
|
call s:RefreshSigns()
|
|
endif
|
|
|
|
if g:syntastic_auto_jump && s:BufHasErrorsOrWarningsToDisplay()
|
|
silent! ll
|
|
endif
|
|
|
|
call s:AutoToggleLocList()
|
|
endfunction
|
|
|
|
"automatically open/close the location list window depending on the users
|
|
"config and buffer error state
|
|
function! s:AutoToggleLocList()
|
|
if s:BufHasErrorsOrWarningsToDisplay()
|
|
if g:syntastic_auto_loc_list == 1
|
|
call s:ShowLocList()
|
|
endif
|
|
else
|
|
if g:syntastic_auto_loc_list > 0
|
|
|
|
"TODO: this will close the loc list window if one was opened by
|
|
"something other than syntastic
|
|
lclose
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"lazy init the loc list for the current buffer
|
|
function! s:LocList()
|
|
if !exists("b:syntastic_loclist")
|
|
let b:syntastic_loclist = []
|
|
endif
|
|
return b:syntastic_loclist
|
|
endfunction
|
|
|
|
"clear the loc list for the buffer
|
|
function! s:ClearLocList()
|
|
let b:syntastic_loclist = []
|
|
endfunction
|
|
|
|
"detect and cache all syntax errors in this buffer
|
|
"
|
|
"depends on a function called SyntaxCheckers_{&ft}_GetLocList() existing
|
|
"elsewhere
|
|
function! s:CacheErrors()
|
|
call s:ClearLocList()
|
|
|
|
if filereadable(expand("%"))
|
|
|
|
"sub - for _ in filetypes otherwise we cant name syntax checker
|
|
"functions legally for filetypes like "gentoo-metadata"
|
|
let fts = substitute(&ft, '-', '_', 'g')
|
|
for ft in split(fts, '\.')
|
|
if s:Checkable(ft)
|
|
let errors = SyntaxCheckers_{ft}_GetLocList()
|
|
"make errors have type "E" by default
|
|
call SyntasticAddToErrors(errors, {'type': 'E'})
|
|
call extend(s:LocList(), errors)
|
|
endif
|
|
endfor
|
|
endif
|
|
endfunction
|
|
|
|
"toggle the g:syntastic_mode_map['mode']
|
|
function! s:ToggleMode()
|
|
if g:syntastic_mode_map['mode'] == "active"
|
|
let g:syntastic_mode_map['mode'] = "passive"
|
|
else
|
|
let g:syntastic_mode_map['mode'] = "active"
|
|
endif
|
|
|
|
call s:ClearLocList()
|
|
call s:UpdateErrors(1)
|
|
|
|
echo "Syntastic: " . g:syntastic_mode_map['mode'] . " mode enabled"
|
|
endfunction
|
|
|
|
"check the current filetypes against g:syntastic_mode_map to determine whether
|
|
"active mode syntax checking should be done
|
|
function! s:ModeMapAllowsAutoChecking()
|
|
let fts = split(&ft, '\.')
|
|
|
|
if g:syntastic_mode_map['mode'] == 'passive'
|
|
"check at least one filetype is active
|
|
let actives = g:syntastic_mode_map["active_filetypes"]
|
|
return !empty(filter(fts, 'index(actives, v:val) != -1'))
|
|
else
|
|
"check no filetypes are passive
|
|
let passives = g:syntastic_mode_map["passive_filetypes"]
|
|
return empty(filter(fts, 'index(passives, v:val) != -1'))
|
|
endif
|
|
endfunction
|
|
|
|
"return true if there are cached errors/warnings for this buf
|
|
function! s:BufHasErrorsOrWarnings()
|
|
return !empty(s:LocList())
|
|
endfunction
|
|
|
|
"return true if there are cached errors for this buf
|
|
function! s:BufHasErrors()
|
|
return len(s:ErrorsForType('E')) > 0
|
|
endfunction
|
|
|
|
function! s:BufHasErrorsOrWarningsToDisplay()
|
|
return s:BufHasErrors() || (!g:syntastic_quiet_warnings && s:BufHasErrorsOrWarnings())
|
|
endfunction
|
|
|
|
function! s:ErrorsForType(type)
|
|
return s:FilterLocList({'type': a:type})
|
|
endfunction
|
|
|
|
function! s:Errors()
|
|
return s:ErrorsForType("E")
|
|
endfunction
|
|
|
|
function! s:Warnings()
|
|
return s:ErrorsForType("W")
|
|
endfunction
|
|
|
|
"Filter a loc list (defaults to s:LocList()) by a:filters
|
|
"e.g.
|
|
" s:FilterLocList({'bufnr': 10, 'type': 'e'})
|
|
"
|
|
"would return all errors in s:LocList() for buffer 10.
|
|
"
|
|
"Note that all comparisons are done with ==?
|
|
function! s:FilterLocList(filters, ...)
|
|
let llist = a:0 ? a:1 : s:LocList()
|
|
|
|
let rv = []
|
|
|
|
for error in llist
|
|
|
|
let passes_filters = 1
|
|
for key in keys(a:filters)
|
|
if error[key] !=? a:filters[key]
|
|
let passes_filters = 0
|
|
break
|
|
endif
|
|
endfor
|
|
|
|
if passes_filters
|
|
call add(rv, error)
|
|
endif
|
|
endfor
|
|
return rv
|
|
endfunction
|
|
|
|
if g:syntastic_enable_signs
|
|
"define the signs used to display syntax and style errors/warns
|
|
sign define SyntasticError text=>> texthl=error
|
|
sign define SyntasticWarning text=>> texthl=todo
|
|
sign define SyntasticStyleError text=S> texthl=error
|
|
sign define SyntasticStyleWarning text=S> texthl=todo
|
|
endif
|
|
|
|
"start counting sign ids at 5000, start here to hopefully avoid conflicting
|
|
"with any other code that places signs (not sure if this precaution is
|
|
"actually needed)
|
|
let s:first_sign_id = 5000
|
|
let s:next_sign_id = s:first_sign_id
|
|
|
|
"place signs by all syntax errs in the buffer
|
|
function! s:SignErrors()
|
|
if s:BufHasErrorsOrWarningsToDisplay()
|
|
|
|
let errors = s:FilterLocList({'bufnr': bufnr('')})
|
|
for i in errors
|
|
let sign_severity = 'Error'
|
|
let sign_subtype = ''
|
|
if has_key(i,'subtype')
|
|
let sign_subtype = i['subtype']
|
|
endif
|
|
if i['type'] ==? 'w'
|
|
let sign_severity = 'Warning'
|
|
endif
|
|
let sign_type = 'Syntastic' . sign_subtype . sign_severity
|
|
|
|
if !s:WarningMasksError(i, errors)
|
|
exec "sign place ". s:next_sign_id ." line=". i['lnum'] ." name=". sign_type ." file=". expand("%:p")
|
|
call add(s:BufSignIds(), s:next_sign_id)
|
|
let s:next_sign_id += 1
|
|
endif
|
|
endfor
|
|
endif
|
|
endfunction
|
|
|
|
"return true if the given error item is a warning that, if signed, would
|
|
"potentially mask an error if displayed at the same time
|
|
function! s:WarningMasksError(error, llist)
|
|
if a:error['type'] !=? 'w'
|
|
return 0
|
|
endif
|
|
|
|
return len(s:FilterLocList({ 'type': "E", 'lnum': a:error['lnum'] }, a:llist)) > 0
|
|
endfunction
|
|
|
|
"remove the signs with the given ids from this buffer
|
|
function! s:RemoveSigns(ids)
|
|
for i in a:ids
|
|
exec "sign unplace " . i
|
|
call remove(s:BufSignIds(), index(s:BufSignIds(), i))
|
|
endfor
|
|
endfunction
|
|
|
|
"get all the ids of the SyntaxError signs in the buffer
|
|
function! s:BufSignIds()
|
|
if !exists("b:syntastic_sign_ids")
|
|
let b:syntastic_sign_ids = []
|
|
endif
|
|
return b:syntastic_sign_ids
|
|
endfunction
|
|
|
|
"update the error signs
|
|
function! s:RefreshSigns()
|
|
let old_signs = copy(s:BufSignIds())
|
|
call s:SignErrors()
|
|
call s:RemoveSigns(old_signs)
|
|
let s:first_sign_id = s:next_sign_id
|
|
endfunction
|
|
|
|
"display the cached errors for this buf in the location list
|
|
function! s:ShowLocList()
|
|
if !empty(s:LocList())
|
|
let num = winnr()
|
|
exec "lopen " . g:syntastic_loc_list_height
|
|
if num != winnr()
|
|
wincmd p
|
|
endif
|
|
endif
|
|
endfunction
|
|
|
|
"remove all error highlights from the window
|
|
function! s:ClearErrorHighlights()
|
|
for match in getmatches()
|
|
if stridx(match['group'], 'Syntastic') == 0
|
|
call matchdelete(match['id'])
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
"check if a syntax checker exists for the given filetype - and attempt to
|
|
"load one
|
|
function! s:Checkable(ft)
|
|
if !exists("g:loaded_" . a:ft . "_syntax_checker")
|
|
exec "runtime syntax_checkers/" . a:ft . ".vim"
|
|
endif
|
|
|
|
return exists("*SyntaxCheckers_". a:ft ."_GetLocList")
|
|
endfunction
|
|
|
|
"set up error ballons for the current set of errors
|
|
function! s:RefreshBalloons()
|
|
let b:syntastic_balloons = {}
|
|
if s:BufHasErrorsOrWarningsToDisplay()
|
|
for i in s:LocList()
|
|
let b:syntastic_balloons[i['lnum']] = i['text']
|
|
endfor
|
|
set beval bexpr=SyntasticErrorBalloonExpr()
|
|
endif
|
|
endfunction
|
|
|
|
"print as much of a:msg as possible without "Press Enter" prompt appearing
|
|
function! s:WideMsg(msg)
|
|
let old_ruler = &ruler
|
|
let old_showcmd = &showcmd
|
|
|
|
let msg = strpart(a:msg, 0, winwidth(0)-1)
|
|
|
|
"This is here because it is possible for some error messages to begin with
|
|
"\n which will cause a "press enter" prompt. I have noticed this in the
|
|
"javascript:jshint checker and have been unable to figure out why it
|
|
"happens
|
|
let msg = substitute(msg, "\n", "", "g")
|
|
|
|
set noruler noshowcmd
|
|
redraw
|
|
|
|
echo msg
|
|
|
|
let &ruler=old_ruler
|
|
let &showcmd=old_showcmd
|
|
endfunction
|
|
|
|
"echo out the first error we find for the current line in the cmd window
|
|
function! s:EchoCurrentError()
|
|
"If we have an error or warning at the current line, show it
|
|
let errors = s:FilterLocList({'lnum': line("."), "type": 'e'})
|
|
let warnings = s:FilterLocList({'lnum': line("."), "type": 'w'})
|
|
|
|
let b:syntastic_echoing_error = len(errors) || len(warnings)
|
|
if len(errors)
|
|
return s:WideMsg(errors[0]['text'])
|
|
endif
|
|
if len(warnings)
|
|
return s:WideMsg(warnings[0]['text'])
|
|
endif
|
|
|
|
"Otherwise, clear the status line
|
|
if b:syntastic_echoing_error
|
|
echo
|
|
let b:syntastic_echoing_error = 0
|
|
endif
|
|
endfunction
|
|
|
|
"load the chosen checker for the current filetype - useful for filetypes like
|
|
"javascript that have more than one syntax checker
|
|
function! s:LoadChecker(checker)
|
|
exec "runtime syntax_checkers/" . &ft . "/" . a:checker . ".vim"
|
|
endfunction
|
|
|
|
"return a string representing the state of buffer according to
|
|
"g:syntastic_stl_format
|
|
"
|
|
"return '' if no errors are cached for the buffer
|
|
function! SyntasticStatuslineFlag()
|
|
if s:BufHasErrorsOrWarningsToDisplay()
|
|
let errors = s:Errors()
|
|
let warnings = s:Warnings()
|
|
|
|
let output = g:syntastic_stl_format
|
|
|
|
"hide stuff wrapped in %E(...) unless there are errors
|
|
let output = substitute(output, '\C%E{\([^}]*\)}', len(errors) ? '\1' : '' , 'g')
|
|
|
|
"hide stuff wrapped in %W(...) unless there are warnings
|
|
let output = substitute(output, '\C%W{\([^}]*\)}', len(warnings) ? '\1' : '' , 'g')
|
|
|
|
"hide stuff wrapped in %B(...) unless there are both errors and warnings
|
|
let output = substitute(output, '\C%B{\([^}]*\)}', (len(warnings) && len(errors)) ? '\1' : '' , 'g')
|
|
|
|
"sub in the total errors/warnings/both
|
|
let output = substitute(output, '\C%w', len(warnings), 'g')
|
|
let output = substitute(output, '\C%e', len(errors), 'g')
|
|
let output = substitute(output, '\C%t', len(s:LocList()), 'g')
|
|
|
|
"first error/warning line num
|
|
let output = substitute(output, '\C%F', s:LocList()[0]['lnum'], 'g')
|
|
|
|
"first error line num
|
|
let output = substitute(output, '\C%fe', len(errors) ? errors[0]['lnum'] : '', 'g')
|
|
|
|
"first warning line num
|
|
let output = substitute(output, '\C%fw', len(warnings) ? warnings[0]['lnum'] : '', 'g')
|
|
|
|
return output
|
|
else
|
|
return ''
|
|
endif
|
|
endfunction
|
|
|
|
"A wrapper for the :lmake command. Sets up the make environment according to
|
|
"the options given, runs make, resets the environment, returns the location
|
|
"list
|
|
"
|
|
"a:options can contain the following keys:
|
|
" 'makeprg'
|
|
" 'errorformat'
|
|
"
|
|
"The corresponding options are set for the duration of the function call. They
|
|
"are set with :let, so dont escape spaces.
|
|
"
|
|
"a:options may also contain:
|
|
" 'defaults' - a dict containing default values for the returned errors
|
|
" 'subtype' - all errors will be assigned the given subtype
|
|
function! SyntasticMake(options)
|
|
let old_loclist = getloclist(0)
|
|
let old_makeprg = &makeprg
|
|
let old_shellpipe = &shellpipe
|
|
let old_shell = &shell
|
|
let old_errorformat = &errorformat
|
|
|
|
if !s:running_windows && (s:uname !~ "FreeBSD")
|
|
"this is a hack to stop the screen needing to be ':redraw'n when
|
|
"when :lmake is run. Otherwise the screen flickers annoyingly
|
|
let &shellpipe='&>'
|
|
let &shell = '/bin/bash'
|
|
endif
|
|
|
|
if has_key(a:options, 'makeprg')
|
|
let &makeprg = a:options['makeprg']
|
|
endif
|
|
|
|
if has_key(a:options, 'errorformat')
|
|
let &errorformat = a:options['errorformat']
|
|
endif
|
|
|
|
silent lmake!
|
|
let errors = getloclist(0)
|
|
|
|
call setloclist(0, old_loclist)
|
|
let &makeprg = old_makeprg
|
|
let &errorformat = old_errorformat
|
|
let &shellpipe=old_shellpipe
|
|
let &shell=old_shell
|
|
|
|
if !s:running_windows && s:uname =~ "FreeBSD"
|
|
redraw!
|
|
endif
|
|
|
|
if has_key(a:options, 'defaults')
|
|
call SyntasticAddToErrors(errors, a:options['defaults'])
|
|
endif
|
|
|
|
" Add subtype info if present.
|
|
if has_key(a:options, 'subtype')
|
|
call SyntasticAddToErrors(errors, {'subtype': a:options['subtype']})
|
|
endif
|
|
|
|
return errors
|
|
endfunction
|
|
|
|
"get the error balloon for the current mouse position
|
|
function! SyntasticErrorBalloonExpr()
|
|
if !exists('b:syntastic_balloons')
|
|
return ''
|
|
endif
|
|
return get(b:syntastic_balloons, v:beval_lnum, '')
|
|
endfunction
|
|
|
|
"highlight the list of errors (a:errors) using matchadd()
|
|
"
|
|
"a:termfunc is provided to highlight errors that do not have a 'col' key (and
|
|
"hence cant be done automatically). This function must take one arg (an error
|
|
"item) and return a regex to match that item in the buffer.
|
|
"
|
|
"an optional boolean third argument can be provided to force a:termfunc to be
|
|
"used regardless of whether a 'col' key is present for the error
|
|
function! SyntasticHighlightErrors(errors, termfunc, ...)
|
|
if !g:syntastic_enable_highlighting
|
|
return
|
|
endif
|
|
|
|
call s:ClearErrorHighlights()
|
|
|
|
let force_callback = a:0 && a:1
|
|
for item in a:errors
|
|
let group = item['type'] == 'E' ? 'SyntasticError' : 'SyntasticWarning'
|
|
if item['col'] && !force_callback
|
|
let lastcol = col([item['lnum'], '$'])
|
|
let lcol = min([lastcol, item['col']])
|
|
call matchadd(group, '\%'.item['lnum'].'l\%'.lcol.'c')
|
|
else
|
|
let term = a:termfunc(item)
|
|
if len(term) > 0
|
|
call matchadd(group, '\%' . item['lnum'] . 'l' . term)
|
|
endif
|
|
endif
|
|
endfor
|
|
endfunction
|
|
|
|
"take a list of errors and add default values to them from a:options
|
|
function! SyntasticAddToErrors(errors, options)
|
|
for i in range(0, len(a:errors)-1)
|
|
for key in keys(a:options)
|
|
if !has_key(a:errors[i], key) || empty(a:errors[i][key])
|
|
let a:errors[i][key] = a:options[key]
|
|
endif
|
|
endfor
|
|
endfor
|
|
return a:errors
|
|
endfunction
|
|
|
|
"take a list of syntax checkers for the current filetype and load the right
|
|
"one based on the global settings and checker executable availabity
|
|
"
|
|
"a:checkers should be a list of syntax checker names. These names are assumed
|
|
"to be the names of the vim syntax checker files that should be sourced, as
|
|
"well as the names of the actual syntax checker executables. The checkers
|
|
"should be listed in order of default preference.
|
|
"
|
|
"if a option called 'g:syntastic_[filetype]_checker' exists then attempt to
|
|
"load the checker that it points to
|
|
function! SyntasticLoadChecker(checkers)
|
|
let opt_name = "g:syntastic_" . &ft . "_checker"
|
|
|
|
if exists(opt_name)
|
|
let opt_val = {opt_name}
|
|
if index(a:checkers, opt_val) != -1 && executable(opt_val)
|
|
call s:LoadChecker(opt_val)
|
|
else
|
|
echoerr &ft . " syntax not supported or not installed."
|
|
endif
|
|
else
|
|
for checker in a:checkers
|
|
if executable(checker)
|
|
return s:LoadChecker(checker)
|
|
endif
|
|
endfor
|
|
endif
|
|
endfunction
|
|
|
|
" vim: set et sts=4 sw=4:
|