Vim syntax for python call and keyword arguments: issues with built-in keyword

Question

I am trying to come up with a Vim syntax for python function call, e.g.:

foo(notarg==0, arg2, kwarg='a', kwarg2='b')
dict(a=1, b=2, c=3)

where we want to highlight

• (i) function name foo, dict
• (ii) keyword parameters, e.g. kwarg, kwarg2

I know there is a great answer on a similar question. To repeat:

syn region FCall matchgroup=FName start='[[:alpha:]_]\i*\s*(' end=')' contains=FCall,FCallKeyword
syn match FCallKeyword /\i*\ze\s*=[^=]/ contained

Or, alternatively, in my own vim syntax file for python, I could manage to achieve a similar behavior:

syn match   pythonCall   /\<\h\i*\ze\s*(/    contains=pythonBuiltin,pythonBuiltinFunc,pythonBuiltinType
                                           \ nextgroup=pythonCallRegion skipwhite keepend
syn region  pythonCallRegion        contained matchgroup=pythonParamsDelim start=/(/  end=/)/ keepend extend
                                      \ contains=pythonCallComma,pythonCall,@pythonCallArgument,pythonCallArgKeyword
syn match   pythonCallArgKeyword    contained /\h\i*\ze\s*==\@!/

However, the problem is that when a previously existing syntax group (e.g. pythonBuiltinType) matches function name, the entire highlight for keyword arguments would not work:

For example:

dict(a=1, b=2)

where we have the following highlighting rule somewhere (e.g. python-mode)

syn keyword pythonBuiltinType dict ....

Given this, dict matches pythonBuiltinType, but not matches pythonCall. This happens for the both ways I just described. A screenshot:

What did I wrong here? Vim syntax is quite difficult, so your help would be greatly appreciated.

Answer 1

The snippet link posted by @user938271 is broken after many years, so let me post a solution I ended up having here.

The problem is that the highlight group for built-in keywords (defined in python-mode) do not have the 'contained' property:

pythonBuiltinType xxx match /\C\<\%(list\|object\|str\| ... set\|bytearray\)\>/

so it cannot be contained in other syntax group (e.g. pythonCall).

We monkey-patch the syntax rule to have these highlight group have the contained property:

function! s:convert_syntax_keyword_containedin(syntaxGroup, syntaxCallGroup)
    " https://vi.stackexchange.com/questions/18408/ (courtesy of @user938271)
    let l:rule = execute(printf('syn list %s', a:syntaxGroup))
    let l:rule = matchstr(l:rule, 'xxx\zs.*')
    " if <xxx match> then, it is not 'syntax keyword' anymore. we should stop here
    if (l:rule =~ '^\s*match')
        return
    endif

    " convert it to regex rule
    let l:rule = substitute(l:rule, 'links\s\+to\s\+.*', '', '')
    let l:rule = join(split(l:rule), '\|')

    exe 'syn clear ' . a:syntaxGroup
    exe 'syn match ' . a:syntaxGroup     . ' /\C\<\%(' . l:rule . '\)\>/'
    exe 'syn match ' . a:syntaxCallGroup . ' /\C\<\%(' . l:rule . '\)\>/ contained'
endfunction

call s:convert_syntax_keyword_containedin('pythonBuiltinType', 'pythonCallBuiltinType')
call s:convert_syntax_keyword_containedin('pythonBuiltinFunc', 'pythonCallBuiltinFunc')

Now finally we can do like

syn match   pythonCall   /\<\h\i*\ze\s*(/    contains=pythonCallBuiltinType,pythonCallBuiltinFunc
                                           \ nextgroup=pythonCallRegion skipwhite keepend

See this commit 1dbf843 for the fully working changeset.