runtime(vim): Update base-syntax, match tuples

Tuples were introduced in commit 9cb865e.  See PR #16776.

fixes: #16965
closes: #16935

Signed-off-by: Doug Kearns <dougkearns@gmail.com>
Signed-off-by: Christian Brabandt <cb@256bit.org>

runtime/syntax/testdir/input/vim9_lambda.vim

@@ -1,4 +1,7 @@
 vim9script
+# VIM_TEST_SETUP hi link vim9LambdaOperator Todo
+# VIM_TEST_SETUP hi link vim9LambdaParen Todo
+
 
 # Vim 9 lambda expressions
 
@@ -6,6 +9,7 @@ var Foo: func
 var expr = 0
 
 # without return type
+
 Foo = () => expr
 Foo = (_) => expr
 Foo = (x) => expr
@@ -26,6 +30,7 @@ Foo = (x: number, ...y: list<number>) => expr
 Foo = (x: number, y: number) => expr
 
 # with return type
+
 Foo = (): number => expr
 Foo = (_): number => expr
 Foo = (x): number => expr
@@ -45,6 +50,27 @@ Foo = (x: number, ...y: list<number>): number => expr
 
 Foo = (x: number, y: number): number => expr
 
+# with compound return type
+
+Foo = (): list<number> => expr
+Foo = (_): list<number> => expr
+Foo = (x): list<number> => expr
+
+Foo = (...y): list<number> => expr
+Foo = (_, ...y): list<number> => expr
+Foo = (x, ...y): list<number> => expr
+
+Foo = (x, y): list<number> => expr
+
+Foo = (_: number): list<number> => expr
+Foo = (x: number): list<number> => expr
+
+Foo = (...y: list<number>): list<number> => expr
+Foo = (_: number, ...y: list<number>): list<number> => expr
+Foo = (x: number, ...y: list<number>): list<number> => expr
+
+Foo = (x: number, y: number): list<number> => expr
+
 
 # post operator comments
 
@@ -62,15 +88,29 @@ Foo = () =>
 
 # line continuations
 
+Foo = (x: string,
+      \ y: number,
+      \ z: bool) => expr
+
+Foo = (x: string,
+      \ y: number,
+      \ z: bool)
+      \ => expr
+
 Foo = (x: string,
       \ y: number,
       \ z: bool): number => expr
-# FIXME
+
 Foo = (x: string,
       \ y: number,
       \ z: bool): number
       \ => expr
 
+Foo = (x: string,
+      \ y: number,
+      \ z: bool): 
+      \ number => expr
+
 
 # funcref call
 
@@ -114,3 +154,9 @@ def Op(): func(func(number, number): number): func(number, Digit): number
 	(x: number, y: Digit): number => F(x, y.value)
 enddef ####################### ^ vimCommand?
 
+
+# Issue #16965 (vim syntax: wrong highlight with lambda, autoload, and false keyword)
+
+autocmd BufRead * timer_start(0, (_) => f#a(false, false))
+autocmd
+

runtime/syntax/testdir/input/vim9_tuple.vim

@@ -0,0 +1,26 @@
+vim9script
+
+# Vim9 tuples
+
+
+# https://github.com/vim/vim/pull/16935#issuecomment-2738310273
+
+function LegacyMakeEntry(key, value) abort
+    return (a:key, a:value)
+endfunction
+
+def MakeEntry(key: string, value: any): tuple<string, any>
+    return (key, value)
+enddef
+
+function LegacyMakeLazyList(e1, e2) abort
+    return ({e1_, e2_ -> {-> [e1_, e2_]}}(a:e1, a:e2))
+endfunction
+
+def MakeLazyList(e1: any, e2: any): func(): list<any>
+    return (((e1_: any, e2_: any) => () => [e1_, e2_])(e1, e2))
+enddef
+
+echo MakeEntry('key', 'value') == list2tuple(MakeLazyList('key', 'value')())
+echo LegacyMakeEntry('key', 'value') == list2tuple(LegacyMakeLazyList('key', 'value')())
+

runtime/syntax/testdir/input/vim9_variables.vim

@@ -47,6 +47,24 @@ var foo =<< eval trim END
 ...
 END
 
+# Typed declarations
+
+var foo: tuple<any> = expr
+var foo: tuple<number> = expr
+var foo: tuple<number, string, bool> = expr
+var foo: tuple<...list<any>> = expr
+var foo: tuple<...list<number>> = expr
+var foo: tuple<number, ...list<string>> = expr
+
+var foo: tuple<
+      #\ comment
+      \number, 
+      #\ comment
+      \string, 
+      #\ comment
+      \bool
+      \>
+
 # Assignments
 
 foo = expr

runtime/syntax/testdir/input/vim_expr.vim

@@ -173,6 +173,21 @@ echo #{
 " match as keys not scope dictionaries
 echo #{ b: 42, w: 42, t: 42, g: 42, l: 42, s: 42, a: 42, v: 42  }
 
+" Tuple
+
+echo ()
+echo (42,)
+echo ((11, 12), (21, 22), (31, 32))
+echo (1,
+      \ 2,
+      \ 3,
+      \ 4
+      \)
+echo (1, 'two', 1 + 2, "fo" .. "ur")
+
+echo foo + (42, 87)
+echo (42, 87) + foo
+
 " Register
 
 echo @" 

runtime/syntax/testdir/input/vim_lambda.vim

@@ -1,4 +1,7 @@
 " Vim lambda expressions
+" VIM_TEST_SETUP hi link vimLambdaOperator Todo
+" VIM_TEST_SETUP hi link vimLambdaBrace    Todo
+" VIM_TEST_SETUP hi link vimFuncParam	   Identifier
 
 
 let expr = 42
@@ -56,12 +59,17 @@ let Foo = {x,
       \ z -> expr}
 
 let Foo = {
+      "\ comment
       \ x,
+      "\ comment
       \ y,
+      "\ comment
       \ z
+      "\ comment
       \ ->
       "\ comment
       \ expr
+      "\ comment
       \ }
 
 let Foo = {-> [
@@ -94,6 +102,7 @@ let Foo = {-> {-> #{
       \ b: 83
       \}}}
 
+
 " :help lambda
 
 :let F = {arg1, arg2 -> arg1 - arg2}