Support for more than two arguments for `vimtex_syntax_custom_cmds_with_concealed_delims`

[keikun555]

Big fan of this plugin!

Is your feature request related to a problem? Please describe it.
I would like to conceal custom commands that have more than two arguments

\newcommand{\hoare}[3]{\ensuremath{\left\{ #1 \right\} #2 \left\{ #3 \right\}}}

In other words, I would like to conceal

$\hoare{a}{b}{c}$

to

{a}b{c}

I was looking at #2634 and g:vimtex_syntax_custom_cmds_with_concealed_delims seems to only support up to two arguments.

Describe the solution you'd like
Ideally g:vimtex_syntax_custom_cmds_with_concealed_delims can support 3 or more arguments, and have different middle conceal characters.

let g:vimtex_syntax_custom_cmds_with_concealed_delims = \[
  \ {'name': 'hoare',
  \  'nargs': 3,
  \  'mathmode': 1,
  \  'cchar_open': '{',
  \  'cchar_mid': ['}', '{'],
  \  'cchar_close': '}'},
  \]

Describe alternatives you've considered
I tried the above configuration just with cchar_mid = '|', and was able to produce {a|b}{c}.

[keikun555]

I'm not sure how hard of a problem this is.
If it turns out that supporting arrays for cchar_mid is hard, I'm also be ok with {a|b|c} and reuse the same cchar_mid.

[lervag]

I don't see a way to easily do this for n number of arguments. I could relatively easily support the {a|b|c} variant with nargs = 3, but then someone might ask for n = 4. I'm curious where I should stop...

If you really want this level of conceal customization, I wonder if it might be equally good to write some custom rules on top yourself. It is not so hard, and I could help you write the rules for this particular case, if you want.

[keikun555]

Sounds good, are there pointers to get started?

I see

vimtex/autoload/vimtex/syntax/core.vim

Lines 792 to 794 in bcb14eb

	for l:item in g:vimtex_syntax_custom_cmds_with_concealed_delims
	call vimtex#syntax#core#new_cmd_with_concealed_delims(l:item)
	endfor

which calls

vimtex/autoload/vimtex/syntax/core.vim

Lines 1160 to 1249 in bcb14eb

	function! vimtex#syntax#core#new_cmd_with_concealed_delims(cfg) abort " {{{1
	if empty(get(a:cfg, 'name')) | return | endif
	" Parse options/config
	let l:cfg = extend({
	\ 'mathmode': v:false,
	\ 'argstyle': '',
	\ 'argspell': v:true,
	\ 'nargs': 1,
	\ 'cchar_open': '',
	\ 'cchar_mid': '',
	\ 'cchar_close': '',
	\ 'hlgroup': '',
	\}, a:cfg)
	let l:pre = l:cfg.mathmode ? 'texMath' : 'tex'
	let l:name = 'C' . toupper(l:cfg.name[0]) . l:cfg.name[1:]
	let l:group_cmd = l:pre . 'Cmd' . l:name
	let l:group_arg1 = l:pre . l:name . 'Arg'
	let l:group_arg2 = l:pre . l:name . 'Arg2'
	let l:group_delims = l:pre . l:name . 'ConcealedDelim'
	if l:cfg.mathmode
	let l:contains = '@texClusterMath'
	execute 'syntax cluster texClusterMath add=' . l:group_cmd
	elseif !l:cfg.argspell
	let l:contains = 'TOP,@Spell'
	else
	let l:contains = 'TOP,@NoSpell'
	endif
	execute 'syntax match' l:group_cmd
	\ '"\v\\' . get(l:cfg, 'cmdre', l:cfg.name . '>') . '"'
	\ l:cfg.mathmode ? 'contained' : ''
	\ empty(l:cfg.cchar_open)
	\ ? 'conceal'
	\ : 'conceal cchar=' . l:cfg.cchar_open
	\ 'skipwhite nextgroup=' . l:group_arg1
	if l:cfg.nargs == 1
	execute 'syntax region' l:group_arg1
	\ 'matchgroup=' . l:group_delims
	\ empty(l:cfg.cchar_close)
	\ ? 'concealends'
	\ : 'concealends cchar=' . l:cfg.cchar_close
	\ 'start="{" skip="\%#=1\\[\\\}]" end="}"'
	\ 'contained contains=' . l:contains
	else
	execute 'syntax region' l:group_arg1
	\ 'matchgroup=' . l:group_delims
	\ empty(l:cfg.cchar_mid)
	\ ? 'concealends'
	\ : 'concealends cchar=' . l:cfg.cchar_mid
	\ 'start="{" skip="\%#=1\\[\\\}]" end="}"'
	\ 'contained contains=' . l:contains
	\ 'skipwhite nextgroup=' . l:group_arg2
	execute 'syntax region' l:group_arg2
	\ 'matchgroup=' . l:group_delims
	\ empty(l:cfg.cchar_close)
	\ ? 'concealends'
	\ : 'concealends cchar=' . l:cfg.cchar_close
	\ 'start="{" skip="\%#=1\\[\\\}]" end="}"'
	\ 'contained contains=' . l:contains
	endif
	" Define default highlight rule
	execute 'highlight def link' l:group_cmd
	\ !empty(l:cfg.hlgroup)
	\ ? l:cfg.hlgroup
	\ : l:pre . 'Cmd'
	execute 'highlight def link' l:group_delims 'texRefConcealedDelim'
	let l:style = get({
	\ 'bold': 'texStyleBold',
	\ 'ital': 'texStyleItal',
	\ 'under': 'texStyleUnder',
	\ 'boldital': 'texStyleBoth',
	\ 'boldunder': 'texStyleBoldUnder',
	\ 'italunder': 'texStyleItalUnder',
	\ 'bolditalunder': 'texStyleBoldItalUnder',
	\}, l:cfg.argstyle,
	\ l:cfg.mathmode ? 'texMathArg' : '')
	if !empty(l:style)
	execute 'highlight def link' l:group_arg1 l:style
	if l:cfg.nargs > 1
	execute 'highlight def link' l:group_arg2 l:style
	endif
	endif
	endfunction

By custom rules do you mean creating custom syntax match commands that the new_cmd_with_concealed_delims calls? If so, I would put them in $HOME/.vim/after/syntax/tex.vim?

I wonder if there is a way to view examples of the conceal commands generated with new_cmd_with_concealed_delims.

I am new to vim scripting, and I was wondering if we can call this part in a loop

vimtex/autoload/vimtex/syntax/core.vim

Lines 1208 to 1215 in bcb14eb

	execute 'syntax region' l:group_arg1
	\ 'matchgroup=' . l:group_delims
	\ empty(l:cfg.cchar_mid)
	\ ? 'concealends'
	\ : 'concealends cchar=' . l:cfg.cchar_mid
	\ 'start="{" skip="\%#=1\\[\\\}]" end="}"'
	\ 'contained contains=' . l:contains
	\ 'skipwhite nextgroup=' . l:group_arg2

I assume the hard part would be to generalizing the current stack allocated Arg1 and Arg2 into a list of strings. Does vim scripting have lists?

vimtex/autoload/vimtex/syntax/core.vim

Lines 1178 to 1179 in bcb14eb

	let l:group_arg1 = l:pre . l:name . 'Arg'
	let l:group_arg2 = l:pre . l:name . 'Arg2'

[lervag]

By custom rules do you mean creating custom syntax match commands that the new_cmd_with_concealed_delims calls? If so, I would put them in $HOME/.vim/after/syntax/tex.vim?

Yes, precisely. So, for this specific case, you could add that file with the following content:

syntax match texMathCmdHoare
        \ "\v\\hoare>"
        \ contained
        \ conceal cchar={
        \ skipwhite nextgroup=texMathHoareArg1

syntax cluster texClusterMath add=texMathCmdHoare

syntax region texMathHoareArg1
      \ matchgroup=texMathHoareConcealedDelim
      \ concealends cchar=|
      \ start="{" skip="\%#=1\\[\\\}]" end="}"
      \ contained contains=@texClusterMath
      \ skipwhite nextgroup=texMathHoareArg2

syntax region texMathHoareArg2
      \ matchgroup=texMathHoareConcealedDelim
      \ concealends cchar=|
      \ start="{" skip="\%#=1\\[\\\}]" end="}"
      \ contained contains=@texClusterMath
      \ skipwhite nextgroup=texMathHoareArg3

syntax region texMathHoareArg3
      \ matchgroup=texMathHoareConcealedDelim
      \ concealends cchar=}
      \ start="{" skip="\%#=1\\[\\\}]" end="}"
      \ contained contains=@texClusterMath

highlight def link texMathCmdHoare texMathCmd
highlight def link texMathHoareConcealedDelim texRefConcealedDelim

I believe this would make the necessary rules for the \hoare{a}{b}{c} → {a|b|c}.

I am new to vim scripting, and I was wondering if we can call this part in a loop …

I was thinking likewise, but I realized that we need to repeat the initial args and it looked a little bit hard. I guess it could be done...

[lervag]

I've pushed an update that should allow nargs > 2 now, such that

let g:vimtex_syntax_custom_cmds_with_concealed_delims = \[
  \ {'name': 'hoare',
  \  'nargs': 3,
  \  'mathmode': 1,
  \  'cchar_open': '{',
  \  'cchar_mid': '|',
  \  'cchar_close': '}'},
  \]

will work as expected. I don't see any simple way to get this more powerful, so I'll leave it at that. Let me know if it works as expected for you.

[keikun555]

This works! Thank you so much for the quick turnaround :)

[lervag]

Glad to hear it!