Update runtime files.
diff --git a/runtime/autoload/dist/vimindent.vim b/runtime/autoload/dist/vimindent.vim
index 898f22f..8d86543 100644
--- a/runtime/autoload/dist/vimindent.vim
+++ b/runtime/autoload/dist/vimindent.vim
@@ -2,12 +2,12 @@
# Language: Vim script
# Maintainer: github user lacygoill
-# Last Change: 2023 Jan 03
+# Last Change: 2023 Feb 01
# NOTE: Whenever you change the code, make sure the tests are still passing:
#
# $ cd runtime/indent/
-# $ make clean; make test || vimdiff testdir/vim.{fail,ok}
+# $ make clean; make test || vimdiff testdir/vim.{ok,fail}
# Config {{{1
@@ -112,6 +112,10 @@
.. '\)'
.. ':\%(\s\|$\)'
+# NOT_A_DICT_KEY {{{3
+
+const NOT_A_DICT_KEY: string = ':\@!'
+
# END_OF_COMMAND {{{3
const END_OF_COMMAND: string = $'\s*\%($\|||\@!\|{INLINE_COMMENT}\)'
@@ -144,19 +148,43 @@
#
# But sometimes, it can be too costly and cause `E363` to be given.
const PATTERN_DELIMITER: string = '[-+*/%]\%(=\s\)\@!'
-
-# QUOTE {{{3
-
-const QUOTE: string = '["'']'
# }}}2
# Syntaxes {{{2
-# ASSIGNS_HEREDOC {{{3
+# BLOCKS {{{3
-const ASSIGNS_HEREDOC: string = $'^\%({COMMENT}\)\@!.*\%({HEREDOC_OPERATOR}\)\s\+\zs[A-Z]\+{END_OF_LINE}'
+const BLOCKS: list<list<string>> = [
+ ['if', 'el\%[se]', 'elseif\=', 'en\%[dif]'],
+ ['for', 'endfor\='],
+ ['wh\%[ile]', 'endw\%[hile]'],
+ ['try', 'cat\%[ch]', 'fina\|finally\=', 'endt\%[ry]'],
+ ['def', 'enddef'],
+ ['fu\%[nction](\@!', 'endf\%[unction]'],
+ ['class', 'endclass'],
+ ['interface', 'endinterface'],
+ ['enum', 'endenum'],
+ ['aug\%[roup]\%(\s\+[eE][nN][dD]\)\@!\s\+\S\+', 'aug\%[roup]\s\+[eE][nN][dD]'],
+]
-# CD_COMMAND {{{3
+# MODIFIERS {{{3
-const CD_COMMAND: string = $'\<[lt]\=cd!\=\s\+-{END_OF_COMMAND}'
+# some keywords can be prefixed by modifiers (e.g. `def` can be prefixed by `export`)
+const MODIFIERS: dict<string> = {
+ def: ['export', 'static'],
+ class: ['export', 'abstract', 'export abstract'],
+ interface: ['export'],
+}
+# ...
+# class: ['export', 'abstract', 'export abstract'],
+# ...
+# →
+# ...
+# class: '\%(export\|abstract\|export\s\+abstract\)\s\+',
+# ...
+->map((_, mods: list<string>): string =>
+ '\%(' .. mods
+ ->join('\|')
+ ->substitute('\s\+', '\\s\\+', 'g')
+ .. '\)' .. '\s\+')
# HIGHER_ORDER_COMMAND {{{3
@@ -174,58 +202,102 @@
g\%[lobal]!\={PATTERN_DELIMITER}.*
v\%[global]!\={PATTERN_DELIMITER}.*
END
-const HIGHER_ORDER_COMMAND: string = $'\%(^\|{BAR_SEPARATION}\)\s*\<\%(' .. patterns->join('\|') .. '\):\@!'
-# MAPPING_COMMAND {{{3
+const HIGHER_ORDER_COMMAND: string = $'\%(^\|{BAR_SEPARATION}\)\s*\<\%({patterns->join('\|')}\){NOT_A_DICT_KEY}'
-const MAPPING_COMMAND: string = '\%(\<sil\%[ent]!\=\s\+\)\=\<[nvxsoilct]\=\%(nore\|un\)map!\=\s'
+# START_MIDDLE_END {{{3
-# NORMAL_COMMAND {{{3
+# Let's derive this constant from `BLOCKS`:
+#
+# [['if', 'el\%[se]', 'elseif\=', 'en\%[dif]'],
+# ['for', 'endfor\='],
+# ...,
+# [...]]
+# →
+# {
+# 'for': ['for', '', 'endfor\='],
+# 'endfor': ['for', '', 'endfor\='],
+# 'if': ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
+# 'else': ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
+# 'elseif': ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
+# 'endif': ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
+# ...
+# }
+var START_MIDDLE_END: dict<list<string>>
-const NORMAL_COMMAND: string = '\<norm\%[al]!\=\s*\S\+$'
+def Unshorten(kwd: string): string
+ return BlockStartKeyword(kwd)
+enddef
-# PLUS_MINUS_COMMAND {{{3
+def BlockStartKeyword(line: string): string
+ var kwd: string = line->matchstr('\l\+')
+ return fullcommand(kwd, false)
+enddef
-# In legacy, the `:+` and `:-` commands are not required to be preceded by a colon.
-# As a result, when `+` or `-` is alone on a line, there is ambiguity.
-# It might be an operator or a command.
-# To not break the indentation in legacy scripts, we might need to consider such
-# lines as commands.
-const PLUS_MINUS_COMMAND: string = '^\s*[+-]\s*$'
+{
+ for kwds: list<string> in BLOCKS
+ var [start: string, middle: string, end: string] = [kwds[0], '', kwds[-1]]
+ if MODIFIERS->has_key(start->Unshorten())
+ start = $'\%({MODIFIERS[start]}\)\={start}'
+ endif
+ if kwds->len() > 2
+ middle = kwds[1 : -2]->join('\|')
+ endif
+ for kwd: string in kwds
+ START_MIDDLE_END->extend({[kwd->Unshorten()]: [start, middle, end]})
+ endfor
+ endfor
+}
+
+START_MIDDLE_END = START_MIDDLE_END
+ ->map((_, kwds: list<string>) =>
+ kwds->map((_, kwd: string) => kwd == ''
+ ? ''
+ : $'\%(^\|{BAR_SEPARATION}\|\<sil\%[ent]\|{HIGHER_ORDER_COMMAND}\)\s*'
+ .. $'\<\%({kwd}\)\>\%(\s*{OPERATOR}\)\@!'))
+
+lockvar! START_MIDDLE_END
# ENDS_BLOCK {{{3
const ENDS_BLOCK: string = '^\s*\%('
- .. 'en\%[dif]'
- .. '\|' .. 'endfor\='
- .. '\|' .. 'endw\%[hile]'
- .. '\|' .. 'endt\%[ry]'
- .. '\|' .. 'enddef'
- .. '\|' .. 'endclass'
- .. '\|' .. 'endf\%[unction]'
- .. '\|' .. 'aug\%[roup]\s\+[eE][nN][dD]'
+ .. BLOCKS
+ ->copy()
+ ->map((_, kwds: list<string>): string => kwds[-1])
+ ->join('\|')
.. '\|' .. CLOSING_BRACKET
.. $'\){END_OF_COMMAND}'
# ENDS_BLOCK_OR_CLAUSE {{{3
-patterns =<< trim END
- en\%[dif]
- el\%[se]
- endfor\=
- endclass
- endw\%[hile]
- endt\%[ry]
- fina\|finally\=
- enddef
- endf\%[unction]
- aug\%[roup]\s\+[eE][nN][dD]
-END
+patterns = BLOCKS
+ ->copy()
+ ->map((_, kwds: list<string>) => kwds[1 :])
+ ->flattennew()
+ # `catch` and `elseif` need to be handled as special cases
+ ->filter((_, pat: string): bool => pat->Unshorten() !~ '^\%(catch\|elseif\)\>')
const ENDS_BLOCK_OR_CLAUSE: string = '^\s*\%(' .. patterns->join('\|') .. $'\){END_OF_COMMAND}'
.. $'\|^\s*cat\%[ch]\%(\s\+\({PATTERN_DELIMITER}\).*\1\)\={END_OF_COMMAND}'
.. $'\|^\s*elseif\=\>\%({OPERATOR}\)\@!'
+# STARTS_NAMED_BLOCK {{{3
+
+patterns = []
+{
+ for kwds: list<string> in BLOCKS
+ for kwd: string in kwds[0 : -2]
+ if MODIFIERS->has_key(kwd->Unshorten())
+ patterns += [$'\%({MODIFIERS[kwd]}\)\={kwd}']
+ else
+ patterns += [kwd]
+ endif
+ endfor
+ endfor
+}
+
+const STARTS_NAMED_BLOCK: string = $'^\s*\%(sil\%[ent]\s\+\)\=\%({patterns->join('\|')}\)\>{NOT_A_DICT_KEY}'
+
# STARTS_CURLY_BLOCK {{{3
# TODO: `{` alone on a line is not necessarily the start of a block.
@@ -238,73 +310,57 @@
.. '\|' .. $'^\%(\s*\|.*{BAR_SEPARATION}\s*\)\%(com\%[mand]\|au\%[tocmd]\).*\zs\s{{'
.. '\)' .. END_OF_COMMAND
-# STARTS_NAMED_BLOCK {{{3
-
-# All of these will be used at the start of a line (or after a bar).
-# NOTE: Don't replace `\%x28` with `(`.{{{
-#
-# Otherwise, the paren would be unbalanced which might cause syntax highlighting
-# issues much later in the code of the current script (sometimes, the syntax
-# highlighting plugin fails to correctly recognize a heredoc which is far away
-# and/or not displayed because inside a fold).
-# }}}
-patterns =<< trim END
- if
- el\%[se]
- elseif\=
- for
- class
- wh\%[ile]
- try
- cat\%[ch]
- fina\|finally\=
- fu\%[nction]\%x28\@!
- \%(export\s\+\)\=def
- aug\%[roup]\%(\s\+[eE][nN][dD]\)\@!\s\+\S\+
-END
-const STARTS_NAMED_BLOCK: string = '^\s*\%(sil\%[ent]\s\+\)\=\%(' .. patterns->join('\|') .. '\)\>:\@!'
-
# STARTS_FUNCTION {{{3
-const STARTS_FUNCTION: string = '^\s*\%(export\s\+\)\=def\>:\@!'
+const STARTS_FUNCTION: string = $'^\s*\%({MODIFIERS.def}\)\=def\>{NOT_A_DICT_KEY}'
# ENDS_FUNCTION {{{3
-const ENDS_FUNCTION: string = $'^\s*enddef\>:\@!{END_OF_COMMAND}'
+const ENDS_FUNCTION: string = $'^\s*enddef\>{END_OF_COMMAND}'
-# START_MIDDLE_END {{{3
+# ASSIGNS_HEREDOC {{{3
-const START_MIDDLE_END: dict<list<string>> = {
- if: ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
- else: ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
- elseif: ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
- endif: ['if', 'el\%[se]\|elseif\=', 'en\%[dif]'],
- for: ['for', '', 'endfor\='],
- endfor: ['for', '', 'endfor\='],
- class: ['class', '', 'endclass'],
- endclass: ['class', '', 'endclass'],
- while: ['wh\%[ile]', '', 'endw\%[hile]'],
- endwhile: ['wh\%[ile]', '', 'endw\%[hile]'],
- try: ['try', 'cat\%[ch]\|fina\|finally\=', 'endt\%[ry]'],
- catch: ['try', 'cat\%[ch]\|fina\|finally\=', 'endt\%[ry]'],
- finally: ['try', 'cat\%[ch]\|fina\|finally\=', 'endt\%[ry]'],
- endtry: ['try', 'cat\%[ch]\|fina\|finally\=', 'endt\%[ry]'],
- def: ['\%(export\s\+\)\=def', '', 'enddef'],
- enddef: ['\%(export\s\+\)\=def', '', 'enddef'],
- function: ['fu\%[nction]', '', 'endf\%[unction]'],
- endfunction: ['fu\%[nction]', '', 'endf\%[unction]'],
- augroup: ['aug\%[roup]\%(\s\+[eE][nN][dD]\)\@!\s\+\S\+', '', 'aug\%[roup]\s\+[eE][nN][dD]'],
-}->map((_, kwds: list<string>) =>
- kwds->map((_, kwd: string) => kwd == ''
- ? ''
- : $'\%(^\|{BAR_SEPARATION}\|\<sil\%[ent]\|{HIGHER_ORDER_COMMAND}\)\s*'
- .. $'\%({printf('\C\<\%%(%s\)\>:\@!\%%(\s*%s\)\@!', kwd, OPERATOR)}\)'))
+const ASSIGNS_HEREDOC: string = $'^\%({COMMENT}\)\@!.*\%({HEREDOC_OPERATOR}\)\s\+\zs[A-Z]\+{END_OF_LINE}'
+
+# PLUS_MINUS_COMMAND {{{3
+
+# In legacy, the `:+` and `:-` commands are not required to be preceded by a colon.
+# As a result, when `+` or `-` is alone on a line, there is ambiguity.
+# It might be an operator or a command.
+# To not break the indentation in legacy scripts, we might need to consider such
+# lines as commands.
+const PLUS_MINUS_COMMAND: string = '^\s*[+-]\s*$'
+
+# TRICKY_COMMANDS {{{3
+
+# Some commands are tricky because they accept an argument which can be
+# conflated with an operator. Examples:
+#
+# argdelete *
+# cd -
+# normal! ==
+# nunmap <buffer> (
+#
+# TODO: Other commands might accept operators as argument. Handle them too.
+patterns =<< trim eval END
+ {'\'}<argd\%[elete]\s\+\*\s*$
+ \<[lt]\=cd!\=\s\+-\s*$
+ \<norm\%[al]!\=\s*\S\+$
+ \%(\<sil\%[ent]!\=\s\+\)\=\<[nvxsoilct]\=\%(nore\|un\)map!\=\s
+ {PLUS_MINUS_COMMAND}
+END
+
+const TRICKY_COMMANDS: string = patterns->join('\|')
# }}}2
# EOL {{{2
# OPENING_BRACKET_AT_EOL {{{3
const OPENING_BRACKET_AT_EOL: string = OPENING_BRACKET .. END_OF_VIM9_LINE
+# CLOSING_BRACKET_AT_EOL {{{3
+
+const CLOSING_BRACKET_AT_EOL: string = CLOSING_BRACKET .. END_OF_VIM9_LINE
+
# COMMA_AT_EOL {{{3
const COMMA_AT_EOL: string = $',{END_OF_VIM9_LINE}'
@@ -392,6 +448,7 @@
endif
if line_A->AtStartOf('FuncHeader')
+ && !IsInInterface()
line_A.lnum->CacheFuncHeader()
elseif line_A.lnum->IsInside('FuncHeader')
return b:vimindent.startindent + 2 * shiftwidth()
@@ -430,6 +487,7 @@
if line_A.text->ContinuesBelowBracketBlock(line_B, past_bracket_block)
&& line_A.text !~ CLOSING_BRACKET_AT_SOL
return past_bracket_block.startindent
+ + (past_bracket_block.startline =~ STARTS_NAMED_BLOCK ? 2 * shiftwidth() : 0)
endif
# Problem: If we press `==` on the line right below the start of a multiline
@@ -438,6 +496,18 @@
if line_B->EndsWithLambdaArrow()
return Indent(line_B.lnum) + shiftwidth() + IndentMoreInBracketBlock()
endif
+ # FIXME: Similar issue here:
+ #
+ # var x = []
+ # ->filter((_, _) =>
+ # true)
+ # ->items()
+ #
+ # Press `==` on last line.
+ # Expected: The `->items()` line is indented like `->filter(...)`.
+ # Actual: It's indented like `true)`.
+ # Is it worth fixing? `=ip` gives the correct indentation, because then the
+ # cache is used.
# Don't move this block before the heredoc one.{{{
#
@@ -536,8 +606,13 @@
line_B: dict<any>,
): number
+ if line_B->AtStartOf('FuncHeader')
+ && IsInInterface()
+ return 0
+
# increase indentation inside a block
- if line_B.text =~ STARTS_NAMED_BLOCK || line_B->EndsWithCurlyBlock()
+ elseif line_B.text =~ STARTS_NAMED_BLOCK
+ || line_B->EndsWithCurlyBlock()
# But don't indent if the line starting the block also closes it.
if line_B->AlsoClosesBlock()
return 0
@@ -807,11 +882,6 @@
return indent(lnum)
enddef
-def BlockStartKeyword(line: string): string # {{{3
- var kwd: string = line->matchstr('\l\+')
- return fullcommand(kwd, false)
-enddef
-
def MatchingOpenBracket(line: dict<any>): number # {{{3
var end: string = line.text->matchstr(CLOSING_BRACKET)
var start: string = {']': '[', '}': '{', ')': '('}[end]
@@ -908,7 +978,8 @@
if end == '[' || end == ']'
e = e->escape('[]')
endif
- return searchpair(s, middle, e, flags, (): bool => InCommentOrString(), stopline, TIMEOUT)
+ return searchpair('\C' .. s, (middle == '' ? '' : '\C' .. middle), '\C' .. e,
+ flags, (): bool => InCommentOrString(), stopline, TIMEOUT)
enddef
def SearchPairStart( # {{{3
@@ -1016,6 +1087,10 @@
return line_A.lnum <= end
enddef
+def IsInInterface(): bool # {{{3
+ return SearchPair('interface', '', 'endinterface', 'nW') > 0
+enddef
+
def IsFirstLineOfCommand(line_1: dict<any>, line_2: dict<any>): bool # {{{3
if line_1.text->Is_IN_KeywordForLoop(line_2.text)
return false
@@ -1096,6 +1171,10 @@
return NonCommentedMatch(line, OPENING_BRACKET_AT_EOL)
enddef
+def EndsWithClosingBracket(line: dict<any>): bool # {{{3
+ return NonCommentedMatch(line, CLOSING_BRACKET_AT_EOL)
+enddef
+
def NonCommentedMatch(line: dict<any>, pat: string): bool # {{{3
# Could happen if there is no code above us, and we're not on the 1st line.
# In that case, `PrevCodeLine()` returns `{lnum: 0, line: ''}`.
@@ -1103,16 +1182,6 @@
return false
endif
- if line.text =~ PLUS_MINUS_COMMAND
- return false
- endif
-
- # In `argdelete *`, `*` is not a multiplication operator.
- # TODO: Other commands can accept `*` as an argument. Handle them too.
- if line.text =~ '\<argd\%[elete]\s\+\*\s*$'
- return false
- endif
-
# Technically, that's wrong. A line might start with a range and end with a
# line continuation symbol. But it's unlikely. And it's useful to assume the
# opposite because it prevents us from conflating a mark with an operator or
@@ -1179,24 +1248,7 @@
return false
endif
- # `:help cd-`
- if line.text =~ CD_COMMAND
- return false
- endif
-
- # At the end of a mapping, any character might appear; e.g. a paren:
- #
- # nunmap <buffer> (
- #
- # Don't conflate this with a line continuation symbol.
- if line.text =~ MAPPING_COMMAND
- return false
- endif
-
- # not a comparison operator
- # vv
- # normal! ==
- if line.text =~ NORMAL_COMMAND
+ if line.text =~ TRICKY_COMMANDS
return false
endif