Re-design semantic token type assigned to keywords in function calls

[ZeroRin]

Related to my question earlier
consider the following example

def foo(bar,**kwargs):
    return foo(bar=bar, bad=kwargs['bad'])

with default dark+ color theme it looks like:

if we add {"parameter": "#569CD6","parameter.declaration": "#4FC1FF"} to colorization rules, it becomes:

As can see, parameter.declaration affects all variables in function definition, and parameter affects (except those being overrideen by parameter.declaration) all variables in function body that has been defined in function definition and all keywords in a function call that has been defined in function definition

The problems are:

1. Known keywords in function calls always share the same color with other parameters, which make it harder to distinguish keyword and value in a function call.
2. Unknown keyword in function calls is not assigned to any semantic token at all.

I came up with several solutions:

1. Assign a different token to all keywords in function calls and add modifier to distinguish between known and unknown keywords. this allows us to set color for all keywords in function calls and assign another color to unknown on top of that. But as there seems to be no existing token suitable, it may introduce new token type.
2. assign a modifier to known keywords. this allow us to set color for known keywords, and unknowns can be configured with textmate rules separately. This requires new token modifier, but maybe parameter.declaration can be reused here.
3. do not assign any token to keywords, this allows us to set color for all keywords using textmate rules at once (but cannot distinguish between known and unknown)

[ZeroRin]

When semantic highlighting is disabled, almost all themes provide a different color to keyword arguments and its values (dark+ as an example):

passing arguments with the same name to subsequent function calls is pretty common in codes and painting them as the same color makes them harder to read.
The only potential pro I can come up with is that it enables us to distinguish between known and unknown keywords, but this is totally meaning less as pylance actually does not recognize unexpected arguments:

dark blue indicates parameter here, I expect the first bar to be underlined as an error and the second be painted as other known keywords, but both are untouched by pylance and shows the default color as variable

Also, as a reference, PyCharm handles it with a separate config for keyword arguments.