opensourcemirror
/
neovim
mirror of https://github.com/neovim/neovim.git
1
0
Fork 0
Code Issues Releases Wiki Activity

vim-patch:partial:f269eabc6c4f (#20470) 

Update runtime files
f269eabc6c
This commit is contained in:
Christian Clason 2022-10-05 10:56:53 +02:00 committed by GitHub
parent 759259e8af
commit 06f4edc864
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 153 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
runtime/doc/builtin.txt
View File

@ -6,6 +6,8 @@
Builtin functions *builtin-functions*
For functions grouped by what they are used for see |function-list|.
Type |gO| to see the table of contents.
==============================================================================
@ -6168,7 +6170,9 @@ reg_recording() *reg_recording()*
Returns the single letter name of the register being recorded.
Returns an empty string when not recording. See |q|.
reltime([{start} [, {end}]]) *reltime()*
reltime()
reltime({start})
reltime({start}, {end}) *reltime()*
Return an item that represents a time value. The item is a
list with items that depend on the system.
The item can be passed to |reltimestr()| to convert it to a
@ -6222,7 +6226,8 @@ reltimestr({time}) *reltimestr()*
Can also be used as a |method|: >
reltime(start)->reltimestr()
<
remove({list}, {idx} [, {end}]) *remove()*
remove({list}, {idx})
remove({list}, {idx}, {end}) *remove()*
Without {end}: Remove the item at {idx} from |List| {list} and
return the item.
With {end}: Remove items from {idx} to {end} (inclusive) and
@ -6240,7 +6245,8 @@ remove({list}, {idx} [, {end}]) *remove()*
Can also be used as a |method|: >
mylist->remove(idx)
remove({blob}, {idx} [, {end}])
remove({blob}, {idx})
remove({blob}, {idx}, {end})
Without {end}: Remove the byte at {idx} from |Blob| {blob} and
return the byte.
With {end}: Remove bytes from {idx} to {end} (inclusive) and

2
runtime/doc/fold.txt
View File

@ -491,7 +491,7 @@ is evaluated to obtain the text displayed for a closed fold. Example: >
This shows the first line of the fold, with "/*", "*/" and "{{{" removed.
Note the use of backslashes to avoid some characters to be interpreted by the
":set" command. It's simpler to define a function and call that: >
":set" command. It is much simpler to define a function and call it: >
:set foldtext=MyFoldText()
:function MyFoldText()

14
runtime/doc/insert.txt
View File

@ -650,9 +650,9 @@ When the popup menu is displayed there are a few more special keys, see
|popupmenu-keys|.
Note: The keys that are valid in CTRL-X mode are not mapped. This allows for
":map ^F ^X^F" to work (where ^F is CTRL-F and ^X is CTRL-X). The key that
ends CTRL-X mode (any key that is not a valid CTRL-X mode command) is mapped.
Also, when doing completion with 'complete' mappings apply as usual.
`:map <C-F> <C-X><C-F>` to work. The key that ends CTRL-X mode (any key that
is not a valid CTRL-X mode command) is mapped. Also, when doing completion
with 'complete' mappings apply as usual.
*E565*
Note: While completion is active Insert mode can't be used recursively and
@ -661,10 +661,10 @@ will generate an E565 error.
The following mappings are suggested to make typing the completion commands
a bit easier (although they will hide other commands): >
:inoremap ^] ^X^]
:inoremap ^F ^X^F
:inoremap ^D ^X^D
:inoremap ^L ^X^L
:inoremap <C-]> <C-X><C-]>
:inoremap <C-F> <C-X><C-F>
:inoremap <C-D> <C-X><C-D>
:inoremap <C-L> <C-X><C-L>
As a special case, typing CTRL-R to perform register insertion (see
|i_CTRL-R|) will not exit CTRL-X mode. This is primarily to allow the use of

2
runtime/doc/options.txt
View File

@ -2130,7 +2130,7 @@ A jump table for the options with a short description can be found at |Q_op|.
*'display'* *'dy'*
'display' 'dy' string (default "lastline,msgsep")
global
Change the way text is displayed. This is comma-separated list of
Change the way text is displayed. This is a comma-separated list of
flags:
lastline When included, as much as possible of the last line
in a window will be displayed. "@@@" is put in the

24
runtime/ftplugin/erlang.vim
View File

@ -5,7 +5,7 @@
" Contributors: Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
" Eduardo Lopez (http://github.com/tapichu)
" Arvid Bjurklint (http://github.com/slarwise)
" Last Update: 2021-Jan-08
" Last Update: 2021-Nov-22
" License: Vim license
" URL: https://github.com/vim-erlang/vim-erlang-runtime
@ -30,6 +30,28 @@ setlocal commentstring=%%s
setlocal formatoptions+=ro
if get(g:, 'erlang_extend_path', 1)
" typical erlang.mk paths
let &l:path = join([
\ 'deps/*/include',
\ 'deps/*/src',
\ 'deps/*/test',
\ 'deps/*/apps/*/include',
\ 'deps/*/apps/*/src',
\ &g:path], ',')
" typical rebar3 paths
let &l:path = join([
\ 'apps/*/include',
\ 'apps/*/src',
\ '_build/default/lib/*/src',
\ '_build/default/*/include',
\ &l:path], ',')
" typical erlang paths
let &l:path = join(['include', 'src', 'test', &l:path], ',')
set wildignore+=*/.erlang.mk/*,*.beam
endif
setlocal suffixesadd=.erl,.hrl
let &l:include = '^\s*-\%(include\|include_lib\)\s*("\zs\f*\ze")'

143
runtime/indent/erlang.vim
View File

@ -4,7 +4,7 @@
" Contributors: Edwin Fine <efine145_nospam01 at usa dot net>
" Pawel 'kTT' Salata <rockplayer.pl@gmail.com>
" Ricardo Catalinas Jiménez <jimenezrick@gmail.com>
" Last Update: 2020-Jun-11
" Last Update: 2022-Sep-06
" License: Vim license
" URL: https://github.com/vim-erlang/vim-erlang-runtime
@ -30,7 +30,9 @@ else
endif
setlocal indentexpr=ErlangIndent()
setlocal indentkeys+=0=end,0=of,0=catch,0=after,0=when,0=),0=],0=},0=>>
setlocal indentkeys+=0=end,0=of,0=catch,0=after,0=else,0=when,0=),0=],0=},0=>>
let b:undo_indent = "setl inde< indk<"
" Only define the functions once
if exists("*ErlangIndent")
@ -235,8 +237,8 @@ function! s:GetTokensFromLine(line, string_continuation, atom_continuation,
" Two-character tokens
elseif i + 1 < linelen &&
\ index(['->', '<<', '>>', '||', '==', '/=', '=<', '>=', '++', '--',
\ '::'],
\ index(['->', '<<', '>>', '||', '==', '/=', '=<', '>=', '?=', '++',
\ '--', '::'],
\ a:line[i : i + 1]) != -1
call add(indtokens, [a:line[i : i + 1], vcol, i])
let next_i = i + 2
@ -558,8 +560,8 @@ function! s:IsCatchStandalone(lnum, i)
let is_standalone = 0
elseif prev_token =~# '[a-z]'
if index(['after', 'and', 'andalso', 'band', 'begin', 'bnot', 'bor', 'bsl',
\ 'bsr', 'bxor', 'case', 'catch', 'div', 'not', 'or', 'orelse',
\ 'rem', 'try', 'xor'], prev_token) != -1
\ 'bsr', 'bxor', 'case', 'catch', 'div', 'maybe', 'not', 'or',
\ 'orelse', 'rem', 'try', 'xor'], prev_token) != -1
" If catch is after these keywords, it is standalone
let is_standalone = 1
else
@ -568,7 +570,7 @@ function! s:IsCatchStandalone(lnum, i)
"
" Keywords:
" - may precede 'catch': end
" - may not precede 'catch': fun if of receive when
" - may not precede 'catch': else fun if of receive when
" - unused: cond let query
let is_standalone = 0
endif
@ -577,7 +579,7 @@ function! s:IsCatchStandalone(lnum, i)
let is_standalone = 0
else
" This 'else' branch includes the following tokens:
" -> == /= =< < >= > =:= =/= + - * / ++ -- :: < > ; ( [ { ? = ! . |
" -> == /= =< < >= > ?= =:= =/= + - * / ++ -- :: < > ; ( [ { ? = ! . |
let is_standalone = 1
endif
@ -590,6 +592,7 @@ endfunction
" Purpose:
" This function is called when a begin-type element ('begin', 'case',
" '[', '<<', etc.) is found. It asks the caller to return if the stack
" if already empty.
" Parameters:
" stack: [token]
" token: string
@ -758,7 +761,7 @@ endfunction
function! s:SearchEndPair(lnum, curr_col)
return s:SearchPair(
\ a:lnum, a:curr_col,
\ '\C\<\%(case\|try\|begin\|receive\|if\)\>\|' .
\ '\C\<\%(case\|try\|begin\|receive\|if\|maybe\)\>\|' .
\ '\<fun\>\%(\s\|\n\|%.*$\|[A-Z_@][a-zA-Z_@]*\)*(',
\ '',
\ '\<end\>')
@ -847,6 +850,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
if ret | return res | endif
" case EXPR of BRANCHES end
" if BRANCHES end
" try EXPR catch BRANCHES end
" try EXPR after BODY end
" try EXPR catch BRANCHES after BODY end
@ -855,15 +859,17 @@ function! s:ErlangCalcIndent2(lnum, stack)
" try EXPR of BRANCHES catch BRANCHES after BODY end
" receive BRANCHES end
" receive BRANCHES after BRANCHES end
" maybe EXPR end
" maybe EXPR else BRANCHES end
" This branch is not Emacs-compatible
elseif (index(['of', 'receive', 'after', 'if'], token) != -1 ||
elseif (index(['of', 'receive', 'after', 'if', 'else'], token) != -1 ||
\ (token ==# 'catch' && !s:IsCatchStandalone(lnum, i))) &&
\ !last_token_of_line &&
\ (empty(stack) || stack ==# ['when'] || stack ==# ['->'] ||
\ stack ==# ['->', ';'])
" If we are after of/receive, but these are not the last
" If we are after of/receive/etc, but these are not the last
" tokens of the line, we want to indent like this:
"
" % stack == []
@ -889,21 +895,21 @@ function! s:ErlangCalcIndent2(lnum, stack)
" stack = ['when'] => LTI is a guard
if empty(stack) || stack == ['->', ';']
call s:Log(' LTI is in a condition after ' .
\'"of/receive/after/if/catch" -> return')
\'"of/receive/after/if/else/catch" -> return')
return stored_vcol
elseif stack == ['->']
call s:Log(' LTI is in a branch after ' .
\'"of/receive/after/if/catch" -> return')
\'"of/receive/after/if/else/catch" -> return')
return stored_vcol + shiftwidth()
elseif stack == ['when']
call s:Log(' LTI is in a guard after ' .
\'"of/receive/after/if/catch" -> return')
\'"of/receive/after/if/else/catch" -> return')
return stored_vcol + shiftwidth()
else
return s:UnexpectedToken(token, stack)
endif
elseif index(['case', 'if', 'try', 'receive'], token) != -1
elseif index(['case', 'if', 'try', 'receive', 'maybe'], token) != -1
" stack = [] => LTI is a condition
" stack = ['->'] => LTI is a branch
@ -913,45 +919,47 @@ function! s:ErlangCalcIndent2(lnum, stack)
" pass
elseif (token ==# 'case' && stack[0] ==# 'of') ||
\ (token ==# 'if') ||
\ (token ==# 'maybe' && stack[0] ==# 'else') ||
\ (token ==# 'try' && (stack[0] ==# 'of' ||
\ stack[0] ==# 'catch' ||
\ stack[0] ==# 'after')) ||
\ (token ==# 'receive')
" From the indentation point of view, the keyword
" (of/catch/after/end) before the LTI is what counts, so
" (of/catch/after/else/end) before the LTI is what counts, so
" when we reached these tokens, and the stack already had
" a catch/after/end, we didn't modify it.
" a catch/after/else/end, we didn't modify it.
"
" This way when we reach case/try/receive (i.e. now),
" there is at most one of/catch/after/end token in the
" This way when we reach case/try/receive/maybe (i.e. now),
" there is at most one of/catch/after/else/end token in the
" stack.
if token ==# 'case' || token ==# 'try' ||
\ (token ==# 'receive' && stack[0] ==# 'after')
\ (token ==# 'receive' && stack[0] ==# 'after') ||
\ (token ==# 'maybe' && stack[0] ==# 'else')
call s:Pop(stack)
endif
if empty(stack)
call s:Log(' LTI is in a condition; matching ' .
\'"case/if/try/receive" found')
\'"case/if/try/receive/maybe" found')
let stored_vcol = curr_vcol + shiftwidth()
elseif stack[0] ==# 'align_to_begin_element'
call s:Pop(stack)
let stored_vcol = curr_vcol
elseif len(stack) > 1 && stack[0] ==# '->' && stack[1] ==# ';'
call s:Log(' LTI is in a condition; matching ' .
\'"case/if/try/receive" found')
\'"case/if/try/receive/maybe" found')
call s:Pop(stack)
call s:Pop(stack)
let stored_vcol = curr_vcol + shiftwidth()
elseif stack[0] ==# '->'
call s:Log(' LTI is in a branch; matching ' .
\'"case/if/try/receive" found')
\'"case/if/try/receive/maybe" found')
call s:Pop(stack)
let stored_vcol = curr_vcol + 2 * shiftwidth()
elseif stack[0] ==# 'when'
call s:Log(' LTI is in a guard; matching ' .
\'"case/if/try/receive" found')
\'"case/if/try/receive/maybe" found')
call s:Pop(stack)
let stored_vcol = curr_vcol + 2 * shiftwidth() + 2
endif
@ -1213,7 +1221,7 @@ function! s:ErlangCalcIndent2(lnum, stack)
if empty(stack)
call s:Push(stack, ';')
elseif index([';', '->', 'when', 'end', 'after', 'catch'],
elseif index([';', '->', 'when', 'end', 'after', 'catch', 'else'],
\stack[0]) != -1
" Pass:
"
@ -1223,10 +1231,10 @@ function! s:ErlangCalcIndent2(lnum, stack)
" should keep that, because they signify the type of the
" LTI (branch, condition or guard).
" - From the indentation point of view, the keyword
" (of/catch/after/end) before the LTI is what counts, so
" if the stack already has a catch/after/end, we don't
" modify it. This way when we reach case/try/receive,
" there will be at most one of/catch/after/end token in
" (of/catch/after/else/end) before the LTI is what counts, so
" if the stack already has a catch/after/else/end, we don't
" modify it. This way when we reach case/try/receive/maybe,
" there will be at most one of/catch/after/else/end token in
" the stack.
else
return s:UnexpectedToken(token, stack)
@ -1242,7 +1250,8 @@ function! s:ErlangCalcIndent2(lnum, stack)
" stack = ['->'] -> LTI is a condition
" stack = ['->', ';'] -> LTI is a branch
call s:Push(stack, '->')
elseif index(['->', 'when', 'end', 'after', 'catch'], stack[0]) != -1
elseif index(['->', 'when', 'end', 'after', 'catch', 'else'],
\stack[0]) != -1
" Pass:
"
" - If the stack top is another '->', then one '->' is
@ -1250,10 +1259,10 @@ function! s:ErlangCalcIndent2(lnum, stack)
" - If the stack top is a 'when', then we should keep
" that, because this signifies that LTI is a in a guard.
" - From the indentation point of view, the keyword
" (of/catch/after/end) before the LTI is what counts, so
" if the stack already has a catch/after/end, we don't
" modify it. This way when we reach case/try/receive,
" there will be at most one of/catch/after/end token in
" (of/catch/after/else/end) before the LTI is what counts, so
" if the stack already has a catch/after/else/end, we don't
" modify it. This way when we reach case/try/receive/maybe,
" there will be at most one of/catch/after/else/end token in
" the stack.
else
return s:UnexpectedToken(token, stack)
@ -1283,7 +1292,8 @@ function! s:ErlangCalcIndent2(lnum, stack)
" LTI
call s:Push(stack, token)
endif
elseif index(['->', 'when', 'end', 'after', 'catch'], stack[0]) != -1
elseif index(['->', 'when', 'end', 'after', 'catch', 'else'],
\stack[0]) != -1
" Pass:
" - If the stack top is another 'when', then one 'when' is
" enough.
@ -1291,21 +1301,63 @@ function! s:ErlangCalcIndent2(lnum, stack)
" should keep that, because they signify the type of the
" LTI (branch, condition or guard).
" - From the indentation point of view, the keyword
" (of/catch/after/end) before the LTI is what counts, so
" if the stack already has a catch/after/end, we don't
" modify it. This way when we reach case/try/receive,
" there will be at most one of/catch/after/end token in
" (of/catch/after/else/end) before the LTI is what counts, so
" if the stack already has a catch/after/else/end, we don't
" modify it. This way when we reach case/try/receive/maybe,
" there will be at most one of/catch/after/else/end token in
" the stack.
else
return s:UnexpectedToken(token, stack)
endif
elseif token ==# 'of' || token ==# 'after' ||
elseif token ==# 'of' || token ==# 'after' || token ==# 'else' ||
\ (token ==# 'catch' && !s:IsCatchStandalone(lnum, i))
if token ==# 'after'
" If LTI is between an 'after' and the corresponding
" 'end', then let's return
if token ==# 'after' || token ==# 'else'
" If LTI is between an after/else and the corresponding 'end', then
" let's return because calculating the indentation based on
" after/else is enough.
"
" Example:
" receive A after
" LTI
" maybe A else
" LTI
"
" Note about Emacs compabitility {{{
"
" It would be fine to indent the examples above the following way:
"
" receive A after
" LTI
" maybe A else
" LTI
"
" We intend it the way above because that is how Emacs does it.
" Also, this is a bit faster.
"
" We are still not 100% Emacs compatible because of placing the
" 'end' after the indented blocks.
"
" Emacs example:
"
" receive A after
" LTI
" end,
" maybe A else
" LTI
" end % Yes, it's here (in OTP 25.0, might change
" % later)
"
" vim-erlang example:
"
" receive A after
" LTI
" end,
" maybe A else
" LTI
" end
" }}}
let [ret, res] = s:BeginElementFoundIfEmpty(stack, token, curr_vcol,
\stored_vcol, shiftwidth())
if ret | return res | endif
@ -1313,7 +1365,8 @@ function! s:ErlangCalcIndent2(lnum, stack)
if empty(stack) || stack[0] ==# '->' || stack[0] ==# 'when'
call s:Push(stack, token)
elseif stack[0] ==# 'catch' || stack[0] ==# 'after' || stack[0] ==# 'end'
elseif stack[0] ==# 'catch' || stack[0] ==# 'after' ||
\stack[0] ==# 'else' || stack[0] ==# 'end'
" Pass: From the indentation point of view, the keyword
" (of/catch/after/end) before the LTI is what counts, so
" if the stack already has a catch/after/end, we don't
@ -1403,7 +1456,7 @@ function! ErlangIndent()
endif
let ml = matchlist(currline,
\'^\(\s*\)\(\%(end\|of\|catch\|after\)\>\|[)\]}]\|>>\)')
\'^\(\s*\)\(\%(end\|of\|catch\|after\|else\)\>\|[)\]}]\|>>\)')
" If the line has a special beginning, but not a standalone catch
if !empty(ml) && !(ml[2] ==# 'catch' && s:IsCatchStandalone(v:lnum, 0))

2
runtime/optwin.vim
View File

@ -1,7 +1,7 @@
" These commands create the option window.
"
" Maintainer: Bram Moolenaar <Bram@vim.org>
" Last Change: 2022 Sep 11
" Last Change: 2022 Oct 02
" If there already is an option window, jump to that one.
let buf = bufnr('option-window')

17
runtime/syntax/erlang.vim
View File

@ -2,7 +2,7 @@
" Language: Erlang (http://www.erlang.org)
" Maintainer: Csaba Hoch <csaba.hoch@gmail.com>
" Contributor: Adam Rutkowski <hq@mtod.org>
" Last Update: 2020-May-26
" Last Update: 2022-Sep-06
" License: Vim license
" URL: https://github.com/vim-erlang/vim-erlang-runtime
@ -61,7 +61,8 @@ syn match erlangQuotedAtomModifier '\\\%(\o\{1,3}\|x\x\x\|x{\x\+}\|\^.\|.\)' con
syn match erlangModifier '\$\%([^\\]\|\\\%(\o\{1,3}\|x\x\x\|x{\x\+}\|\^.\|.\)\)'
" Operators, separators
syn match erlangOperator '==\|=:=\|/=\|=/=\|<\|=<\|>\|>=\|=>\|:=\|++\|--\|=\|!\|<-\|+\|-\|\*\|\/'
syn match erlangOperator '==\|=:=\|/=\|=/=\|<\|=<\|>\|>=\|=>\|:=\|?=\|++\|--\|=\|!\|<-\|+\|-\|\*\|\/'
syn match erlangEqualsBinary '=<<\%(<\)\@!'
syn keyword erlangOperator div rem or xor bor bxor bsl bsr and band not bnot andalso orelse
syn match erlangBracket '{\|}\|\[\|]\||\|||'
syn match erlangPipe '|'
@ -76,7 +77,8 @@ syn match erlangGlobalFuncCall '\<\%(\a[[:alnum:]_@]*\%(\s\|\n\|%.*\n\)*\.\%(\s\
syn match erlangGlobalFuncRef '\<\%(\a[[:alnum:]_@]*\%(\s\|\n\|%.*\n\)*\.\%(\s\|\n\|%.*\n\)*\)*\a[[:alnum:]_@]*\%(\s\|\n\|%.*\n\)*:\%(\s\|\n\|%.*\n\)*\a[[:alnum:]_@]*\>\%(\%(\s\|\n\|%.*\n\)*/\)\@=' contains=erlangComment,erlangVariable
" Variables, macros, records, maps
syn match erlangVariable '\<[A-Z_][[:alnum:]_@]*'
syn match erlangVariable '\<[A-Z][[:alnum:]_@]*'
syn match erlangAnonymousVariable '\<_[[:alnum:]_@]*'
syn match erlangMacro '??\=[[:alnum:]_@]\+'
syn match erlangMacro '\%(-define(\)\@<=[[:alnum:]_@]\+'
syn region erlangQuotedMacro start=/??\=\s*'/ end=/'/ contains=erlangQuotedAtomModifier
@ -92,7 +94,7 @@ syn match erlangBitType '\%(\/\%(\s\|\n\|%.*\n\)*\)\@<=\%(integer\|float\|binary
" Constants and Directives
syn match erlangUnknownAttribute '^\s*-\%(\s\|\n\|%.*\n\)*\l[[:alnum:]_@]*' contains=erlangComment
syn match erlangAttribute '^\s*-\%(\s\|\n\|%.*\n\)*\%(behaviou\=r\|compile\|export\(_type\)\=\|file\|import\|module\|author\|copyright\|doc\|vsn\|on_load\|optional_callbacks\)\>' contains=erlangComment
syn match erlangAttribute '^\s*-\%(\s\|\n\|%.*\n\)*\%(behaviou\=r\|compile\|export\(_type\)\=\|file\|import\|module\|author\|copyright\|doc\|vsn\|on_load\|optional_callbacks\|feature\)\>' contains=erlangComment
syn match erlangInclude '^\s*-\%(\s\|\n\|%.*\n\)*\%(include\|include_lib\)\>' contains=erlangComment
syn match erlangRecordDef '^\s*-\%(\s\|\n\|%.*\n\)*record\>' contains=erlangComment
syn match erlangDefine '^\s*-\%(\s\|\n\|%.*\n\)*\%(define\|undef\)\>' contains=erlangComment
@ -100,8 +102,8 @@ syn match erlangPreCondit '^\s*-\%(\s\|\n\|%.*\n\)*\%(ifdef\|ifndef\|else\|endif
syn match erlangType '^\s*-\%(\s\|\n\|%.*\n\)*\%(spec\|type\|opaque\|callback\)\>' contains=erlangComment
" Keywords
syn keyword erlangKeyword after begin case catch cond end fun if let of
syn keyword erlangKeyword receive when try
syn keyword erlangKeyword after begin case catch cond end fun if let of else
syn keyword erlangKeyword receive when try maybe
" Build-in-functions (BIFs)
syn keyword erlangBIF abs alive apply atom_to_binary atom_to_list contained
@ -174,6 +176,7 @@ hi def link erlangModifier Special
" Operators, separators
hi def link erlangOperator Operator
hi def link erlangEqualsBinary ErrorMsg
hi def link erlangRightArrow Operator
if s:old_style
hi def link erlangBracket Normal
@ -191,6 +194,7 @@ hi def link erlangLocalFuncRef Normal
hi def link erlangGlobalFuncCall Function
hi def link erlangGlobalFuncRef Function
hi def link erlangVariable Normal
hi def link erlangAnonymousVariable erlangVariable
hi def link erlangMacro Normal
hi def link erlangQuotedMacro Normal
hi def link erlangRecord Normal
@ -203,6 +207,7 @@ hi def link erlangLocalFuncRef Normal
hi def link erlangGlobalFuncCall Normal
hi def link erlangGlobalFuncRef Normal
hi def link erlangVariable Identifier
hi def link erlangAnonymousVariable erlangVariable
hi def link erlangMacro Macro
hi def link erlangQuotedMacro Macro
hi def link erlangRecord Structure

4
runtime/syntax/vim.vim
View File

@ -368,7 +368,7 @@ syn match vimSetMod contained "&vim\=\|[!&?<]\|all&"
" Let: {{{2
" ===
syn keyword vimLet let unl[et] skipwhite nextgroup=vimVar,vimFuncVar,vimLetHereDoc
VimFoldh syn region vimLetHereDoc matchgroup=vimLetHereDocStart start='=<<\s\+\%(trim\s\+\)\=\%(eval\s\+\)\=\z(\L\S*\)' matchgroup=vimLetHereDocStop end='^\s*\z1\s*$'
VimFoldh syn region vimLetHereDoc matchgroup=vimLetHereDocStart start='=<<\s\+\%(trim\s\+\)\=\%(eval\s\+\)\=\s*\z(\L\S*\)' matchgroup=vimLetHereDocStop end='^\s*\z1\s*$'
" Abbreviations: {{{2
" =============
@ -619,7 +619,7 @@ syn match vimCtrlChar "[- -]"
" Beginners - Patterns that involve ^ {{{2
" =========
syn match vimLineComment +^[ \t:]*".*$+ contains=@vimCommentGroup,vimCommentString,vimCommentTitle
syn match vimLineComment +^[ \t:]*"\("[^"]*"\|[^"]\)*$+ contains=@vimCommentGroup,vimCommentString,vimCommentTitle
syn match vim9LineComment +^[ \t:]\+#.*$+ contains=@vimCommentGroup,vimCommentString,vimCommentTitle
syn match vimCommentTitle '"\s*\%([sS]:\|\h\w*#\)\=\u\w*\(\s\+\u\w*\)*:'hs=s+1 contained contains=vimCommentTitleLeader,vimTodo,@vimCommentGroup
syn match vimContinue "^\s*\\"