mirror of
https://github.com/neovim/neovim.git
synced 2026-01-02 17:36:56 +10:00
ab20681c52
This reverts commits:
- 6b652a785033fd4164e049492a7327c1ed7c3e5f
- 2f689d5abde0ccddca9e20d8c93a0299bd054e32
- a025a46d4169587145fb54f04af349cd05cb6122
Several email addresses that are known to be valid caused bounces
due to an issue with my email setup. The previous commits incorrectly
marked these addresses as invalid. So revert the whole thing again.
62d8f3dab5
N/A patch:
vim-patch:2f689d5: runtime: mark more invalid email addresses
Co-authored-by: Christian Brabandt <cb@256bit.org>
428 lines
11 KiB
VimL
428 lines
11 KiB
VimL
" Vim indent file
|
||
" Language: Clojure
|
||
" Maintainer: Alex Vear <alex@vear.uk>
|
||
" Former Maintainers: Sung Pae <self@sungpae.com>
|
||
" Meikel Brandmeyer <mb@kotka.de>
|
||
" URL: https://github.com/clojure-vim/clojure.vim
|
||
" License: Vim (see :h license)
|
||
" Last Change: 2022-03-24
|
||
|
||
if exists("b:did_indent")
|
||
finish
|
||
endif
|
||
let b:did_indent = 1
|
||
|
||
let s:save_cpo = &cpo
|
||
set cpo&vim
|
||
|
||
let b:undo_indent = 'setlocal autoindent< smartindent< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<'
|
||
|
||
setlocal noautoindent nosmartindent
|
||
setlocal softtabstop=2 shiftwidth=2 expandtab
|
||
setlocal indentkeys=!,o,O
|
||
|
||
if exists("*searchpairpos")
|
||
|
||
if !exists('g:clojure_maxlines')
|
||
let g:clojure_maxlines = 300
|
||
endif
|
||
|
||
if !exists('g:clojure_fuzzy_indent')
|
||
let g:clojure_fuzzy_indent = 1
|
||
endif
|
||
|
||
if !exists('g:clojure_fuzzy_indent_patterns')
|
||
let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let']
|
||
endif
|
||
|
||
if !exists('g:clojure_fuzzy_indent_blacklist')
|
||
let g:clojure_fuzzy_indent_blacklist = ['-fn$', '\v^with-%(meta|out-str|loading-context)$']
|
||
endif
|
||
|
||
if !exists('g:clojure_special_indent_words')
|
||
let g:clojure_special_indent_words = 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn'
|
||
endif
|
||
|
||
if !exists('g:clojure_align_multiline_strings')
|
||
let g:clojure_align_multiline_strings = 0
|
||
endif
|
||
|
||
if !exists('g:clojure_align_subforms')
|
||
let g:clojure_align_subforms = 0
|
||
endif
|
||
|
||
function! s:syn_id_name()
|
||
return synIDattr(synID(line("."), col("."), 0), "name")
|
||
endfunction
|
||
|
||
function! s:ignored_region()
|
||
return s:syn_id_name() =~? '\vstring|regex|comment|character'
|
||
endfunction
|
||
|
||
function! s:current_char()
|
||
return getline('.')[col('.')-1]
|
||
endfunction
|
||
|
||
function! s:current_word()
|
||
return getline('.')[col('.')-1 : searchpos('\v>', 'n', line('.'))[1]-2]
|
||
endfunction
|
||
|
||
function! s:is_paren()
|
||
return s:current_char() =~# '\v[\(\)\[\]\{\}]' && !s:ignored_region()
|
||
endfunction
|
||
|
||
" Returns 1 if string matches a pattern in 'patterns', which should be
|
||
" a list of patterns.
|
||
function! s:match_one(patterns, string)
|
||
for pat in a:patterns
|
||
if a:string =~# pat | return 1 | endif
|
||
endfor
|
||
endfunction
|
||
|
||
function! s:match_pairs(open, close, stopat)
|
||
" Stop only on vector and map [ resp. {. Ignore the ones in strings and
|
||
" comments.
|
||
if a:stopat == 0 && g:clojure_maxlines > 0
|
||
let stopat = max([line(".") - g:clojure_maxlines, 0])
|
||
else
|
||
let stopat = a:stopat
|
||
endif
|
||
|
||
let pos = searchpairpos(a:open, '', a:close, 'bWn', "!s:is_paren()", stopat)
|
||
return [pos[0], col(pos)]
|
||
endfunction
|
||
|
||
function! s:clojure_check_for_string_worker()
|
||
" Check whether there is the last character of the previous line is
|
||
" highlighted as a string. If so, we check whether it's a ". In this
|
||
" case we have to check also the previous character. The " might be the
|
||
" closing one. In case the we are still in the string, we search for the
|
||
" opening ". If this is not found we take the indent of the line.
|
||
let nb = prevnonblank(v:lnum - 1)
|
||
|
||
if nb == 0
|
||
return -1
|
||
endif
|
||
|
||
call cursor(nb, 0)
|
||
call cursor(0, col("$") - 1)
|
||
if s:syn_id_name() !~? "string"
|
||
return -1
|
||
endif
|
||
|
||
" This will not work for a " in the first column...
|
||
if s:current_char() == '"'
|
||
call cursor(0, col("$") - 2)
|
||
if s:syn_id_name() !~? "string"
|
||
return -1
|
||
endif
|
||
if s:current_char() != '\'
|
||
return -1
|
||
endif
|
||
call cursor(0, col("$") - 1)
|
||
endif
|
||
|
||
let p = searchpos('\(^\|[^\\]\)\zs"', 'bW')
|
||
|
||
if p != [0, 0]
|
||
return p[1] - 1
|
||
endif
|
||
|
||
return indent(".")
|
||
endfunction
|
||
|
||
function! s:check_for_string()
|
||
let pos = getpos('.')
|
||
try
|
||
let val = s:clojure_check_for_string_worker()
|
||
finally
|
||
call setpos('.', pos)
|
||
endtry
|
||
return val
|
||
endfunction
|
||
|
||
function! s:strip_namespace_and_macro_chars(word)
|
||
return substitute(a:word, "\\v%(.*/|[#'`~@^,]*)(.*)", '\1', '')
|
||
endfunction
|
||
|
||
function! s:clojure_is_method_special_case_worker(position)
|
||
" Find the next enclosing form.
|
||
call search('\S', 'Wb')
|
||
|
||
" Special case: we are at a '(('.
|
||
if s:current_char() == '('
|
||
return 0
|
||
endif
|
||
call cursor(a:position)
|
||
|
||
let next_paren = s:match_pairs('(', ')', 0)
|
||
|
||
" Special case: we are now at toplevel.
|
||
if next_paren == [0, 0]
|
||
return 0
|
||
endif
|
||
call cursor(next_paren)
|
||
|
||
call search('\S', 'W')
|
||
let w = s:strip_namespace_and_macro_chars(s:current_word())
|
||
|
||
if g:clojure_special_indent_words =~# '\V\<' . w . '\>'
|
||
|
||
" `letfn` is a special-special-case.
|
||
if w ==# 'letfn'
|
||
" Earlier code left the cursor at:
|
||
" (letfn [...] ...)
|
||
" ^
|
||
|
||
" Search and get coordinates of first `[`
|
||
" (letfn [...] ...)
|
||
" ^
|
||
call search('\[', 'W')
|
||
let pos = getcurpos()
|
||
let letfn_bracket = [pos[1], pos[2]]
|
||
|
||
" Move cursor to start of the form this function was
|
||
" initially called on. Grab the coordinates of the
|
||
" closest outer `[`.
|
||
call cursor(a:position)
|
||
let outer_bracket = s:match_pairs('\[', '\]', 0)
|
||
|
||
" If the located square brackets are not the same,
|
||
" don't use special-case formatting.
|
||
if outer_bracket != letfn_bracket
|
||
return 0
|
||
endif
|
||
endif
|
||
|
||
return 1
|
||
endif
|
||
|
||
return 0
|
||
endfunction
|
||
|
||
function! s:is_method_special_case(position)
|
||
let pos = getpos('.')
|
||
try
|
||
let val = s:clojure_is_method_special_case_worker(a:position)
|
||
finally
|
||
call setpos('.', pos)
|
||
endtry
|
||
return val
|
||
endfunction
|
||
|
||
" Check if form is a reader conditional, that is, it is prefixed by #?
|
||
" or #?@
|
||
function! s:is_reader_conditional_special_case(position)
|
||
return getline(a:position[0])[a:position[1] - 3 : a:position[1] - 2] == "#?"
|
||
\|| getline(a:position[0])[a:position[1] - 4 : a:position[1] - 2] == "#?@"
|
||
endfunction
|
||
|
||
" Returns 1 for opening brackets, -1 for _anything else_.
|
||
function! s:bracket_type(char)
|
||
return stridx('([{', a:char) > -1 ? 1 : -1
|
||
endfunction
|
||
|
||
" Returns: [opening-bracket-lnum, indent]
|
||
function! s:clojure_indent_pos()
|
||
" Get rid of special case.
|
||
if line(".") == 1
|
||
return [0, 0]
|
||
endif
|
||
|
||
" We have to apply some heuristics here to figure out, whether to use
|
||
" normal lisp indenting or not.
|
||
let i = s:check_for_string()
|
||
if i > -1
|
||
return [0, i + !!g:clojure_align_multiline_strings]
|
||
endif
|
||
|
||
call cursor(0, 1)
|
||
|
||
" Find the next enclosing [ or {. We can limit the second search
|
||
" to the line, where the [ was found. If no [ was there this is
|
||
" zero and we search for an enclosing {.
|
||
let paren = s:match_pairs('(', ')', 0)
|
||
let bracket = s:match_pairs('\[', '\]', paren[0])
|
||
let curly = s:match_pairs('{', '}', bracket[0])
|
||
|
||
" In case the curly brace is on a line later then the [ or - in
|
||
" case they are on the same line - in a higher column, we take the
|
||
" curly indent.
|
||
if curly[0] > bracket[0] || curly[1] > bracket[1]
|
||
if curly[0] > paren[0] || curly[1] > paren[1]
|
||
return curly
|
||
endif
|
||
endif
|
||
|
||
" If the curly was not chosen, we take the bracket indent - if
|
||
" there was one.
|
||
if bracket[0] > paren[0] || bracket[1] > paren[1]
|
||
return bracket
|
||
endif
|
||
|
||
" There are neither { nor [ nor (, ie. we are at the toplevel.
|
||
if paren == [0, 0]
|
||
return paren
|
||
endif
|
||
|
||
" Now we have to reimplement lispindent. This is surprisingly easy, as
|
||
" soon as one has access to syntax items.
|
||
"
|
||
" - Check whether we are in a special position after a word in
|
||
" g:clojure_special_indent_words. These are special cases.
|
||
" - Get the next keyword after the (.
|
||
" - If its first character is also a (, we have another sexp and align
|
||
" one column to the right of the unmatched (.
|
||
" - In case it is in lispwords, we indent the next line to the column of
|
||
" the ( + sw.
|
||
" - If not, we check whether it is last word in the line. In that case
|
||
" we again use ( + sw for indent.
|
||
" - In any other case we use the column of the end of the word + 2.
|
||
call cursor(paren)
|
||
|
||
if s:is_method_special_case(paren)
|
||
return [paren[0], paren[1] + &shiftwidth - 1]
|
||
endif
|
||
|
||
if s:is_reader_conditional_special_case(paren)
|
||
return paren
|
||
endif
|
||
|
||
" In case we are at the last character, we use the paren position.
|
||
if col("$") - 1 == paren[1]
|
||
return paren
|
||
endif
|
||
|
||
" In case after the paren is a whitespace, we search for the next word.
|
||
call cursor(0, col('.') + 1)
|
||
if s:current_char() == ' '
|
||
call search('\v\S', 'W')
|
||
endif
|
||
|
||
" If we moved to another line, there is no word after the (. We
|
||
" use the ( position for indent.
|
||
if line(".") > paren[0]
|
||
return paren
|
||
endif
|
||
|
||
" We still have to check, whether the keyword starts with a (, [ or {.
|
||
" In that case we use the ( position for indent.
|
||
let w = s:current_word()
|
||
if s:bracket_type(w[0]) == 1
|
||
return paren
|
||
endif
|
||
|
||
" If the keyword begins with #, check if it is an anonymous
|
||
" function or set, in which case we indent by the shiftwidth
|
||
" (minus one if g:clojure_align_subforms = 1), or if it is
|
||
" ignored, in which case we use the ( position for indent.
|
||
if w[0] == "#"
|
||
" TODO: Handle #=() and other rare reader invocations?
|
||
if w[1] == '(' || w[1] == '{'
|
||
return [paren[0], paren[1] + (g:clojure_align_subforms ? 0 : &shiftwidth - 1)]
|
||
elseif w[1] == '_'
|
||
return paren
|
||
endif
|
||
endif
|
||
|
||
" Test words without namespace qualifiers and leading reader macro
|
||
" metacharacters.
|
||
"
|
||
" e.g. clojure.core/defn and #'defn should both indent like defn.
|
||
let ww = s:strip_namespace_and_macro_chars(w)
|
||
|
||
if &lispwords =~# '\V\<' . ww . '\>'
|
||
return [paren[0], paren[1] + &shiftwidth - 1]
|
||
endif
|
||
|
||
if g:clojure_fuzzy_indent
|
||
\ && !s:match_one(g:clojure_fuzzy_indent_blacklist, ww)
|
||
\ && s:match_one(g:clojure_fuzzy_indent_patterns, ww)
|
||
return [paren[0], paren[1] + &shiftwidth - 1]
|
||
endif
|
||
|
||
call search('\v\_s', 'cW')
|
||
call search('\v\S', 'W')
|
||
if paren[0] < line(".")
|
||
return [paren[0], paren[1] + (g:clojure_align_subforms ? 0 : &shiftwidth - 1)]
|
||
endif
|
||
|
||
call search('\v\S', 'bW')
|
||
return [line('.'), col('.') + 1]
|
||
endfunction
|
||
|
||
function! GetClojureIndent()
|
||
let lnum = line('.')
|
||
let orig_lnum = lnum
|
||
let orig_col = col('.')
|
||
let [opening_lnum, indent] = s:clojure_indent_pos()
|
||
|
||
" Account for multibyte characters
|
||
if opening_lnum > 0
|
||
let indent -= indent - virtcol([opening_lnum, indent])
|
||
endif
|
||
|
||
" Return if there are no previous lines to inherit from
|
||
if opening_lnum < 1 || opening_lnum >= lnum - 1
|
||
call cursor(orig_lnum, orig_col)
|
||
return indent
|
||
endif
|
||
|
||
let bracket_count = 0
|
||
|
||
" Take the indent of the first previous non-white line that is
|
||
" at the same sexp level. cf. src/misc1.c:get_lisp_indent()
|
||
while 1
|
||
let lnum = prevnonblank(lnum - 1)
|
||
let col = 1
|
||
|
||
if lnum <= opening_lnum
|
||
break
|
||
endif
|
||
|
||
call cursor(lnum, col)
|
||
|
||
" Handle bracket counting edge case
|
||
if s:is_paren()
|
||
let bracket_count += s:bracket_type(s:current_char())
|
||
endif
|
||
|
||
while 1
|
||
if search('\v[(\[{}\])]', '', lnum) < 1
|
||
break
|
||
elseif !s:ignored_region()
|
||
let bracket_count += s:bracket_type(s:current_char())
|
||
endif
|
||
endwhile
|
||
|
||
if bracket_count == 0
|
||
" Check if this is part of a multiline string
|
||
call cursor(lnum, 1)
|
||
if s:syn_id_name() !~? '\vstring|regex'
|
||
call cursor(orig_lnum, orig_col)
|
||
return indent(lnum)
|
||
endif
|
||
endif
|
||
endwhile
|
||
|
||
call cursor(orig_lnum, orig_col)
|
||
return indent
|
||
endfunction
|
||
|
||
setlocal indentexpr=GetClojureIndent()
|
||
|
||
else
|
||
|
||
" In case we have searchpairpos not available we fall back to
|
||
" normal lisp indenting.
|
||
setlocal indentexpr=
|
||
setlocal lisp
|
||
let b:undo_indent .= '| setlocal lisp<'
|
||
|
||
endif
|
||
|
||
let &cpo = s:save_cpo
|
||
unlet! s:save_cpo
|
||
|
||
" vim:sts=8:sw=8:ts=8:noet
|