Mercurial > vim

comparison src/testdir/test_vim9_expr.vim @ 23072:4b398a229b0b v8.2.2082

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
patch 8.2.2082: Vim9: can still use the depricated #{} dict syntax Commit: https://github.com/vim/vim/commit/e0de171ecd2ff7acd56deda2cf81f0d13a69c803 Author: Bram Moolenaar <Bram@vim.org> Date: Wed Dec 2 17:36:54 2020 +0100 patch 8.2.2082: Vim9: can still use the depricated #{} dict syntax Problem: Vim9: can still use the depricated #{} dict syntax. Solution: Remove support for #{} in Vim9 script. (closes https://github.com/vim/vim/issues/7406, closes https://github.com/vim/vim/issues/7405)
author Bram Moolenaar <Bram@vim.org>
date Wed, 02 Dec 2020 17:45:05 +0100
parents 6a70803f4cbe
children 285cde4b8d0e
comparison
equal deleted inserted replaced
23071:20dac5998fa6 23072:4b398a229b0b
25 assert_equal('one', !!'x' 25 assert_equal('one', !!'x'
26 ? 'one' 26 ? 'one'
27 : 'two') 27 : 'two')
28 assert_equal('one', !!0z1234 ? 'one' : 'two') 28 assert_equal('one', !!0z1234 ? 'one' : 'two')
29 assert_equal('one', !![0] ? 'one' : 'two') 29 assert_equal('one', !![0] ? 'one' : 'two')
30 assert_equal('one', !!#{x: 0} ? 'one' : 'two') 30 assert_equal('one', !!{x: 0} ? 'one' : 'two')
31 var name = 1 31 var name = 1
32 assert_equal('one', name ? 'one' : 'two') 32 assert_equal('one', name ? 'one' : 'two')
33 33
34 assert_equal('two', false ? 'one' : 'two') 34 assert_equal('two', false ? 'one' : 'two')
35 assert_equal('two', 0 ? 'one' : 'two') 35 assert_equal('two', 0 ? 'one' : 'two')
204 var lines =<< trim END 204 var lines =<< trim END
205 assert_equal(v:true, v:true ?? 456) 205 assert_equal(v:true, v:true ?? 456)
206 assert_equal(123, 123 ?? 456) 206 assert_equal(123, 123 ?? 456)
207 assert_equal('yes', 'yes' ?? 456) 207 assert_equal('yes', 'yes' ?? 456)
208 assert_equal([1], [1] ?? 456) 208 assert_equal([1], [1] ?? 456)
209 assert_equal(#{one: 1}, #{one: 1} ?? 456) 209 assert_equal({one: 1}, {one: 1} ?? 456)
210 if has('float') 210 if has('float')
211 assert_equal(0.1, 0.1 ?? 456) 211 assert_equal(0.1, 0.1 ?? 456)
212 endif 212 endif
213 213
214 assert_equal(456, v:false ?? 456) 214 assert_equal(456, v:false ?? 456)
551 assert_equal(true, [2, 3, 4] == g:alist) 551 assert_equal(true, [2, 3, 4] == g:alist)
552 assert_equal(false, g:alist == [2, 3, 1]) 552 assert_equal(false, g:alist == [2, 3, 1])
553 assert_equal(false, [1, 2, 3] == []) 553 assert_equal(false, [1, 2, 3] == [])
554 assert_equal(false, [1, 2, 3] == ['1', '2', '3']) 554 assert_equal(false, [1, 2, 3] == ['1', '2', '3'])
555 555
556 assert_equal(true, #{one: 1, two: 2} == #{one: 1, two: 2}) 556 assert_equal(true, {one: 1, two: 2} == {one: 1, two: 2})
557 assert_equal(false, #{one: 1, two: 2} == #{one: 2, two: 2}) 557 assert_equal(false, {one: 1, two: 2} == {one: 2, two: 2})
558 assert_equal(false, #{one: 1, two: 2} == #{two: 2}) 558 assert_equal(false, {one: 1, two: 2} == {two: 2})
559 assert_equal(false, #{one: 1, two: 2} == #{}) 559 assert_equal(false, {one: 1, two: 2} == {})
560 assert_equal(true, g:adict == #{bbb: 8, aaa: 2}) 560 assert_equal(true, g:adict == {bbb: 8, aaa: 2})
561 assert_equal(false, #{ccc: 9, aaa: 2} == g:adict) 561 assert_equal(false, {ccc: 9, aaa: 2} == g:adict)
562 562
563 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal')) 563 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal'))
564 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is')) 564 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is'))
565 565
566 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123])) 566 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123]))
648 assert_equal(false, [2, 3, 4] != g:alist) 648 assert_equal(false, [2, 3, 4] != g:alist)
649 assert_equal(true, g:alist != [2, 3, 1]) 649 assert_equal(true, g:alist != [2, 3, 1])
650 assert_equal(true, [1, 2, 3] != []) 650 assert_equal(true, [1, 2, 3] != [])
651 assert_equal(true, [1, 2, 3] != ['1', '2', '3']) 651 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
652 652
653 assert_equal(false, #{one: 1, two: 2} != #{one: 1, two: 2}) 653 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
654 assert_equal(true, #{one: 1, two: 2} != #{one: 2, two: 2}) 654 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
655 assert_equal(true, #{one: 1, two: 2} != #{two: 2}) 655 assert_equal(true, {one: 1, two: 2} != {two: 2})
656 assert_equal(true, #{one: 1, two: 2} != #{}) 656 assert_equal(true, {one: 1, two: 2} != {})
657 assert_equal(false, g:adict != #{bbb: 8, aaa: 2}) 657 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
658 assert_equal(true, #{ccc: 9, aaa: 2} != g:adict) 658 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
659 659
660 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal')) 660 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
661 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is')) 661 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
662 662
663 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123])) 663 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
1195 echo 'a' .. [1] 1195 echo 'a' .. [1]
1196 END 1196 END
1197 CheckScriptFailure(lines, 'E730:', 2) 1197 CheckScriptFailure(lines, 'E730:', 2)
1198 lines =<< trim END 1198 lines =<< trim END
1199 vim9script 1199 vim9script
1200 echo 'a' .. #{a: 1} 1200 echo 'a' .. {a: 1}
1201 END 1201 END
1202 CheckScriptFailure(lines, 'E731:', 2) 1202 CheckScriptFailure(lines, 'E731:', 2)
1203 lines =<< trim END 1203 lines =<< trim END
1204 vim9script 1204 vim9script
1205 echo 'a' .. test_void() 1205 echo 'a' .. test_void()
1285 call CheckDefFailure(["var x = [3] + 0z1122"], 'E1051:', 1) 1285 call CheckDefFailure(["var x = [3] + 0z1122"], 'E1051:', 1)
1286 call CheckDefFailure(["var x = 'asdf' + 0z1122"], 'E1051:', 1) 1286 call CheckDefFailure(["var x = 'asdf' + 0z1122"], 'E1051:', 1)
1287 call CheckDefFailure(["var x = 6 + xxx"], 'E1001:', 1) 1287 call CheckDefFailure(["var x = 6 + xxx"], 'E1001:', 1)
1288 1288
1289 call CheckDefFailure(["var x = 'a' .. [1]"], 'E1105:', 1) 1289 call CheckDefFailure(["var x = 'a' .. [1]"], 'E1105:', 1)
1290 call CheckDefFailure(["var x = 'a' .. #{a: 1}"], 'E1105:', 1) 1290 call CheckDefFailure(["var x = 'a' .. {a: 1}"], 'E1105:', 1)
1291 call CheckDefFailure(["var x = 'a' .. test_void()"], 'E1105:', 1) 1291 call CheckDefFailure(["var x = 'a' .. test_void()"], 'E1105:', 1)
1292 call CheckDefFailure(["var x = 'a' .. 0z32"], 'E1105:', 1) 1292 call CheckDefFailure(["var x = 'a' .. 0z32"], 'E1105:', 1)
1293 call CheckDefFailure(["var x = 'a' .. function('len')"], 'E1105:', 1) 1293 call CheckDefFailure(["var x = 'a' .. function('len')"], 'E1105:', 1)
1294 call CheckDefFailure(["var x = 'a' .. function('len', ['a'])"], 'E1105:', 1) 1294 call CheckDefFailure(["var x = 'a' .. function('len', ['a'])"], 'E1105:', 1)
1295 1295
1467 1467
1468 call CheckDefFailure(["var x = [1] * [2]"], 'E1036:', 1) 1468 call CheckDefFailure(["var x = [1] * [2]"], 'E1036:', 1)
1469 call CheckDefFailure(["var x = [1] / [2]"], 'E1036:', 1) 1469 call CheckDefFailure(["var x = [1] / [2]"], 'E1036:', 1)
1470 call CheckDefFailure(["var x = [1] % [2]"], 'E1035:', 1) 1470 call CheckDefFailure(["var x = [1] % [2]"], 'E1035:', 1)
1471 1471
1472 call CheckDefFailure(["var x = #{one: 1} * #{two: 2}"], 'E1036:', 1) 1472 call CheckDefFailure(["var x = {one: 1} * {two: 2}"], 'E1036:', 1)
1473 call CheckDefFailure(["var x = #{one: 1} / #{two: 2}"], 'E1036:', 1) 1473 call CheckDefFailure(["var x = {one: 1} / {two: 2}"], 'E1036:', 1)
1474 call CheckDefFailure(["var x = #{one: 1} % #{two: 2}"], 'E1035:', 1) 1474 call CheckDefFailure(["var x = {one: 1} % {two: 2}"], 'E1035:', 1)
1475 1475
1476 call CheckDefFailure(["var x = 0xff[1]"], 'E1107:', 1) 1476 call CheckDefFailure(["var x = 0xff[1]"], 'E1107:', 1)
1477 if has('float') 1477 if has('float')
1478 call CheckDefFailure(["var x = 0.7[1]"], 'E1107:', 1) 1478 call CheckDefFailure(["var x = 0.7[1]"], 'E1107:', 1)
1479 endif 1479 endif
1794 assert_equal([1, 3, 5], [1, 2, 3]->map({key, val -> key + val})) 1794 assert_equal([1, 3, 5], [1, 2, 3]->map({key, val -> key + val}))
1795 1795
1796 # line continuation inside lambda with "cond ? expr : expr" works 1796 # line continuation inside lambda with "cond ? expr : expr" works
1797 var ll = range(3) 1797 var ll = range(3)
1798 map(ll, {k, v -> v % 2 ? { 1798 map(ll, {k, v -> v % 2 ? {
1799 '111': 111 } : {} 1799 ['111']: 111 } : {}
1800 }) 1800 })
1801 assert_equal([{}, {'111': 111}, {}], ll) 1801 assert_equal([{}, {111: 111}, {}], ll)
1802 1802
1803 ll = range(3) 1803 ll = range(3)
1804 map(ll, {k, v -> v == 8 || v 1804 map(ll, {k, v -> v == 8 || v
1805 == 9 1805 == 9
1806 || v % 2 ? 111 : 222 1806 || v % 2 ? 111 : 222
1812 != 9 1812 != 9
1813 && v % 2 == 0 ? 111 : 222 1813 && v % 2 == 0 ? 111 : 222
1814 }) 1814 })
1815 assert_equal([111, 222, 111], ll) 1815 assert_equal([111, 222, 111], ll)
1816 1816
1817 var dl = [{'key': 0}, {'key': 22}]->filter({ _, v -> v['key'] }) 1817 var dl = [{key: 0}, {key: 22}]->filter({ _, v -> v['key'] })
1818 assert_equal([{'key': 22}], dl) 1818 assert_equal([{key: 22}], dl)
1819 1819
1820 dl = [{'key': 12}, {'foo': 34}] 1820 dl = [{key: 12}, {['foo']: 34}]
1821 assert_equal([{'key': 12}], filter(dl, 1821 assert_equal([{key: 12}], filter(dl,
1822 {_, v -> has_key(v, 'key') ? v['key'] == 12 : 0})) 1822 {_, v -> has_key(v, 'key') ? v['key'] == 12 : 0}))
1823 1823
1824 assert_equal(false, LambdaWithComments()(0)) 1824 assert_equal(false, LambdaWithComments()(0))
1825 assert_equal(true, LambdaWithComments()(1)) 1825 assert_equal(true, LambdaWithComments()(1))
1826 assert_equal(true, LambdaWithComments()(2)) 1826 assert_equal(true, LambdaWithComments()(2))
1844 'E1106: One argument too many') 1844 'E1106: One argument too many')
1845 CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x', 'y')"], 1845 CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x', 'y')"],
1846 'E1106: 2 arguments too many') 1846 'E1106: 2 arguments too many')
1847 CheckDefFailure(["echo 'asdf'->{a -> a}(x)"], 'E1001:', 1) 1847 CheckDefFailure(["echo 'asdf'->{a -> a}(x)"], 'E1001:', 1)
1848 1848
1849 CheckDefSuccess(['var Fx = {a -> #{k1: 0,', ' k2: 1}}']) 1849 CheckDefSuccess(['var Fx = {a -> {k1: 0,', ' k2: 1}}'])
1850 CheckDefFailure(['var Fx = {a -> #{k1: 0', ' k2: 1}}'], 'E722:', 2) 1850 CheckDefFailure(['var Fx = {a -> {k1: 0', ' k2: 1}}'], 'E722:', 2)
1851 CheckDefFailure(['var Fx = {a -> #{k1: 0,', ' k2 1}}'], 'E720:', 2) 1851 CheckDefFailure(['var Fx = {a -> {k1: 0,', ' k2 1}}'], 'E720:', 2)
1852 1852
1853 CheckDefSuccess(['var Fx = {a -> [0,', ' 1]}']) 1853 CheckDefSuccess(['var Fx = {a -> [0,', ' 1]}'])
1854 CheckDefFailure(['var Fx = {a -> [0', ' 1]}'], 'E696:', 2) 1854 CheckDefFailure(['var Fx = {a -> [0', ' 1]}'], 'E696:', 2)
1855 enddef 1855 enddef
1856 1856
1892 def Test_expr7_dict() 1892 def Test_expr7_dict()
1893 # dictionary 1893 # dictionary
1894 var lines =<< trim END 1894 var lines =<< trim END
1895 assert_equal(g:dict_empty, {}) 1895 assert_equal(g:dict_empty, {})
1896 assert_equal(g:dict_empty, { }) 1896 assert_equal(g:dict_empty, { })
1897 assert_equal(g:dict_one, {'one': 1}) 1897 assert_equal(g:dict_one, {['one']: 1})
1898 var key = 'one' 1898 var key = 'one'
1899 var val = 1 1899 var val = 1
1900 assert_equal(g:dict_one, {[key]: val}) 1900 assert_equal(g:dict_one, {[key]: val})
1901 1901
1902 var numbers: dict<number> = {a: 1, b: 2, c: 3} 1902 var numbers: dict<number> = {a: 1, b: 2, c: 3}
1903 numbers = #{a: 1} 1903 numbers = {a: 1}
1904 numbers = #{} 1904 numbers = {}
1905 1905
1906 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'} 1906 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
1907 strings = #{a: 'x'} 1907 strings = {a: 'x'}
1908 strings = #{} 1908 strings = {}
1909
1910 var dash = {xx-x: 8}
1911 assert_equal({['xx-x']: 8}, dash)
1912
1913 var dnr = {8: 8}
1914 assert_equal({['8']: 8}, dnr)
1909 1915
1910 var mixed: dict<any> = {a: 'a', b: 42} 1916 var mixed: dict<any> = {a: 'a', b: 42}
1911 mixed = #{a: 'x'} 1917 mixed = {a: 'x'}
1912 mixed = #{a: 234} 1918 mixed = {a: 234}
1913 mixed = #{} 1919 mixed = {}
1914 1920
1915 var dictlist: dict<list<string>> = #{absent: [], present: ['hi']} 1921 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
1916 dictlist = #{absent: ['hi'], present: []} 1922 dictlist = {absent: ['hi'], present: []}
1917 dictlist = #{absent: [], present: []} 1923 dictlist = {absent: [], present: []}
1918 1924
1919 var dictdict: dict<dict<string>> = #{one: #{a: 'text'}, two: #{}} 1925 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
1920 dictdict = #{one: #{}, two: #{a: 'text'}} 1926 dictdict = {one: {}, two: {a: 'text'}}
1921 dictdict = #{one: #{}, two: #{}} 1927 dictdict = {one: {}, two: {}}
1922 1928
1923 assert_equal({'': 0}, {matchstr('string', 'wont match'): 0}) 1929 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
1924 1930
1925 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'}) 1931 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
1926 assert_equal(g:test_hash_dict, {one: 1, two: 2}) 1932 assert_equal(g:test_hash_dict, {one: 1, two: 2})
1927 END 1933 END
1928 CheckDefAndScriptSuccess(lines) 1934 CheckDefAndScriptSuccess(lines)
1929 1935
1930 CheckDefFailure(["var x = #{a:8}"], 'E1069:', 1) 1936 # legacy syntax doesn't work
1931 CheckDefFailure(["var x = #{a : 8}"], 'E1068:', 1) 1937 CheckDefFailure(["var x = #{key: 8}"], 'E1097:', 2)
1932 CheckDefFailure(["var x = #{a :8}"], 'E1068:', 1) 1938 CheckDefFailure(["var x = {'key': 8}"], 'E1014:', 1)
1933 CheckDefFailure(["var x = #{a: 8 , b: 9}"], 'E1068:', 1) 1939 CheckDefFailure(["var x = 'a' .. #{a: 1}"], 'E1097:', 2)
1934 CheckDefFailure(["var x = #{a: 1,b: 2}"], 'E1069:', 1) 1940
1935 1941 CheckDefFailure(["var x = {a:8}"], 'E1069:', 1)
1936 CheckDefFailure(["var x = #{8: 8}"], 'E1014:', 1) 1942 CheckDefFailure(["var x = {a : 8}"], 'E1059:', 1)
1937 CheckDefFailure(["var x = #{xxx}"], 'E720:', 1) 1943 CheckDefFailure(["var x = {a :8}"], 'E1059:', 1)
1938 CheckDefFailure(["var x = #{xxx: 1", "var y = 2"], 'E722:', 2) 1944 CheckDefFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
1939 CheckDefFailure(["var x = #{xxx: 1,"], 'E723:', 2) 1945 CheckDefFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
1940 CheckDefFailure(["var x = {'a': xxx}"], 'E1001:', 1) 1946
1941 CheckDefFailure(["var x = {xx-x: 8}"], 'E1001:', 1) 1947 CheckDefFailure(["var x = {xxx}"], 'E720:', 1)
1942 CheckDefFailure(["var x = #{a: 1, a: 2}"], 'E721:', 1) 1948 CheckDefFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
1949 CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
1950 CheckDefFailure(["var x = {['a']: xxx}"], 'E1001:', 1)
1951 CheckDefFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
1943 CheckDefExecFailure(["var x = g:anint.member"], 'E715:', 1) 1952 CheckDefExecFailure(["var x = g:anint.member"], 'E715:', 1)
1944 CheckDefExecFailure(["var x = g:dict_empty.member"], 'E716:', 1) 1953 CheckDefExecFailure(["var x = g:dict_empty.member"], 'E716:', 1)
1945 1954
1946 CheckDefExecFailure(['var x: dict<number> = #{a: 234, b: "1"}'], 'E1012:', 1) 1955 CheckDefExecFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
1947 CheckDefExecFailure(['var x: dict<number> = #{a: "x", b: 134}'], 'E1012:', 1) 1956 CheckDefExecFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
1948 CheckDefExecFailure(['var x: dict<string> = #{a: 234, b: "1"}'], 'E1012:', 1) 1957 CheckDefExecFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
1949 CheckDefExecFailure(['var x: dict<string> = #{a: "x", b: 134}'], 'E1012:', 1) 1958 CheckDefExecFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
1950 1959
1951 CheckDefFailure(['var x = ({'], 'E723:', 2) 1960 CheckDefFailure(['var x = ({'], 'E723:', 2)
1952 CheckDefExecFailure(['{}[getftype("")]'], 'E716: Key not present in Dictionary: ""', 1) 1961 CheckDefExecFailure(['{}[getftype("")]'], 'E716: Key not present in Dictionary: ""', 1)
1953 enddef 1962 enddef
1954 1963
1955 def Test_expr7_dict_vim9script() 1964 def Test_expr7_dict_vim9script()
1956 var lines =<< trim END 1965 var lines =<< trim END
1957 vim9script 1966 vim9script
1958 var d = { 1967 var d = {
1959 'one': 1968 ['one']:
1960 1, 1969 1,
1961 'two': 2, 1970 ['two']: 2,
1962 } 1971 }
1963 assert_equal({'one': 1, 'two': 2}, d) 1972 assert_equal({one: 1, two: 2}, d)
1964 1973
1965 d = { # comment 1974 d = { # comment
1966 'one': 1975 ['one']:
1967 # comment 1976 # comment
1968 1977
1969 1, 1978 1,
1970 # comment 1979 # comment
1971 # comment 1980 # comment
1972 'two': 2, 1981 ['two']: 2,
1973 } 1982 }
1974 assert_equal({'one': 1, 'two': 2}, d) 1983 assert_equal({one: 1, two: 2}, d)
1975 END 1984 END
1976 CheckScriptSuccess(lines) 1985 CheckScriptSuccess(lines)
1977 1986
1978 lines =<< trim END 1987 lines =<< trim END
1979 vim9script 1988 vim9script
1980 var d = { "one": "one", "two": "two", } 1989 var d = { ["one"]: "one", ["two"]: "two", }
1981 assert_equal({'one': 'one', 'two': 'two'}, d) 1990 assert_equal({one: 'one', two: 'two'}, d)
1982 END 1991 END
1983 CheckScriptSuccess(lines) 1992 CheckScriptSuccess(lines)
1984 1993
1985 lines =<< trim END 1994 lines =<< trim END
1986 vim9script 1995 vim9script
1987 var d = #{one: 1, 1996 var d = {one: 1,
1988 two: 2, 1997 two: 2,
1989 } 1998 }
1990 assert_equal({'one': 1, 'two': 2}, d) 1999 assert_equal({one: 1, two: 2}, d)
1991 END 2000 END
1992 CheckScriptSuccess(lines) 2001 CheckScriptSuccess(lines)
1993 2002
1994 lines =<< trim END 2003 lines =<< trim END
1995 vim9script 2004 vim9script
1996 var d = #{one:1, two: 2} 2005 var d = {one:1, two: 2}
1997 END 2006 END
1998 CheckScriptFailure(lines, 'E1069:', 2) 2007 CheckScriptFailure(lines, 'E1069:', 2)
1999 2008
2000 lines =<< trim END 2009 lines =<< trim END
2001 vim9script 2010 vim9script
2002 var d = #{one: 1,two: 2} 2011 var d = {one: 1,two: 2}
2003 END 2012 END
2004 CheckScriptFailure(lines, 'E1069:', 2) 2013 CheckScriptFailure(lines, 'E1069:', 2)
2005 2014
2006 lines =<< trim END 2015 lines =<< trim END
2007 vim9script 2016 vim9script
2008 var d = #{one : 1} 2017 var d = {one : 1}
2018 END
2019 CheckScriptFailure(lines, 'E1059:', 2)
2020
2021 lines =<< trim END
2022 vim9script
2023 var d = {one:1}
2024 END
2025 CheckScriptFailure(lines, 'E1069:', 2)
2026
2027 lines =<< trim END
2028 vim9script
2029 var d = {one: 1 , two: 2}
2009 END 2030 END
2010 CheckScriptFailure(lines, 'E1068:', 2) 2031 CheckScriptFailure(lines, 'E1068:', 2)
2011 2032
2012 lines =<< trim END 2033 lines =<< trim END
2013 vim9script
2014 var d = #{one:1}
2015 END
2016 CheckScriptFailure(lines, 'E1069:', 2)
2017
2018 lines =<< trim END
2019 vim9script
2020 var d = #{one: 1 , two: 2}
2021 END
2022 CheckScriptFailure(lines, 'E1068:', 2)
2023
2024 lines =<< trim END
2025 vim9script 2034 vim9script
2026 var l: dict<number> = #{a: 234, b: 'x'} 2035 var l: dict<number> = {a: 234, b: 'x'}
2027 END 2036 END
2028 CheckScriptFailure(lines, 'E1012:', 2) 2037 CheckScriptFailure(lines, 'E1012:', 2)
2029 lines =<< trim END 2038 lines =<< trim END
2030 vim9script 2039 vim9script
2031 var l: dict<number> = #{a: 'x', b: 234} 2040 var l: dict<number> = {a: 'x', b: 234}
2032 END 2041 END
2033 CheckScriptFailure(lines, 'E1012:', 2) 2042 CheckScriptFailure(lines, 'E1012:', 2)
2034 lines =<< trim END 2043 lines =<< trim END
2035 vim9script 2044 vim9script
2036 var l: dict<string> = #{a: 'x', b: 234} 2045 var l: dict<string> = {a: 'x', b: 234}
2037 END 2046 END
2038 CheckScriptFailure(lines, 'E1012:', 2) 2047 CheckScriptFailure(lines, 'E1012:', 2)
2039 lines =<< trim END 2048 lines =<< trim END
2040 vim9script 2049 vim9script
2041 var l: dict<string> = #{a: 234, b: 'x'} 2050 var l: dict<string> = {a: 234, b: 'x'}
2042 END 2051 END
2043 CheckScriptFailure(lines, 'E1012:', 2) 2052 CheckScriptFailure(lines, 'E1012:', 2)
2044 2053
2045 lines =<< trim END 2054 lines =<< trim END
2046 vim9script 2055 vim9script
2047 def Failing() 2056 def Failing()
2048 job_stop() 2057 job_stop()
2049 enddef 2058 enddef
2050 var dict = #{name: Failing} 2059 var dict = {name: Failing}
2051 END 2060 END
2052 if has('channel') 2061 if has('channel')
2053 CheckScriptFailure(lines, 'E119:', 1) 2062 CheckScriptFailure(lines, 'E119:', 1)
2054 else 2063 else
2055 CheckScriptFailure(lines, 'E117:', 1) 2064 CheckScriptFailure(lines, 'E117:', 1)
2065 assert_equal(1, d[ 2074 assert_equal(1, d[
2066 'one' 2075 'one'
2067 ]) 2076 ])
2068 assert_equal(1, d 2077 assert_equal(1, d
2069 .one) 2078 .one)
2070 d = {'1': 1, '_': 2} 2079 d = {1: 1, _: 2}
2071 assert_equal(1, d 2080 assert_equal(1, d
2072 .1) 2081 .1)
2073 assert_equal(2, d 2082 assert_equal(2, d
2074 ._) 2083 ._)
2075 2084
2076 # getting the one member should clear the dict after getting the item 2085 # getting the one member should clear the dict after getting the item
2077 assert_equal('one', #{one: 'one'}.one) 2086 assert_equal('one', {one: 'one'}.one)
2078 assert_equal('one', #{one: 'one'}[g:oneString]) 2087 assert_equal('one', {one: 'one'}[g:oneString])
2079 2088
2080 CheckDefFailure(["var x = g:dict_one.#$!"], 'E1002:', 1) 2089 CheckDefFailure(["var x = g:dict_one.#$!"], 'E1002:', 1)
2081 CheckDefExecFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2) 2090 CheckDefExecFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2082 CheckDefExecFailure(["var d: dict<number>", "d = g:list_empty"], 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2) 2091 CheckDefExecFailure(["var d: dict<number>", "d = g:list_empty"], 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2)
2083 enddef 2092 enddef
2139 assert_equal([1, 2, 3], g:testlist[1:-1]) 2148 assert_equal([1, 2, 3], g:testlist[1:-1])
2140 assert_equal([1], g:testlist[1:-3]) 2149 assert_equal([1], g:testlist[1:-3])
2141 assert_equal([], g:testlist[1:-4]) 2150 assert_equal([], g:testlist[1:-4])
2142 assert_equal([], g:testlist[1:-9]) 2151 assert_equal([], g:testlist[1:-9])
2143 2152
2144 g:testdict = #{a: 1, b: 2} 2153 g:testdict = {a: 1, b: 2}
2145 assert_equal(1, g:testdict['a']) 2154 assert_equal(1, g:testdict['a'])
2146 assert_equal(2, g:testdict['b']) 2155 assert_equal(2, g:testdict['b'])
2147 END 2156 END
2148 2157
2149 CheckDefSuccess(lines) 2158 CheckDefSuccess(lines)
2170 enddef 2179 enddef
2171 2180
2172 def Test_expr_member_vim9script() 2181 def Test_expr_member_vim9script()
2173 var lines =<< trim END 2182 var lines =<< trim END
2174 vim9script 2183 vim9script
2175 var d = #{one: 2184 var d = {one:
2176 'one', 2185 'one',
2177 two: 'two', 2186 two: 'two',
2178 1: 1, 2187 1: 1,
2179 _: 2} 2188 _: 2}
2180 assert_equal('one', d.one) 2189 assert_equal('one', d.one)
2404 assert_equal(true, !test_null_partial()) 2413 assert_equal(true, !test_null_partial())
2405 assert_equal(false, !{-> 'yes'}) 2414 assert_equal(false, !{-> 'yes'})
2406 2415
2407 assert_equal(true, !test_null_dict()) 2416 assert_equal(true, !test_null_dict())
2408 assert_equal(true, !{}) 2417 assert_equal(true, !{})
2409 assert_equal(false, !{'yes': 'no'}) 2418 assert_equal(false, !{yes: 'no'})
2410 2419
2411 if has('channel') 2420 if has('channel')
2412 assert_equal(true, !test_null_job()) 2421 assert_equal(true, !test_null_job())
2413 assert_equal(true, !test_null_channel()) 2422 assert_equal(true, !test_null_channel())
2414 endif 2423 endif
2431 2440
2432 call CheckDefFailure(["var x = -'xx'"], "E1030:", 1) 2441 call CheckDefFailure(["var x = -'xx'"], "E1030:", 1)
2433 call CheckDefFailure(["var x = +'xx'"], "E1030:", 1) 2442 call CheckDefFailure(["var x = +'xx'"], "E1030:", 1)
2434 call CheckDefFailure(["var x = -0z12"], "E974:", 1) 2443 call CheckDefFailure(["var x = -0z12"], "E974:", 1)
2435 call CheckDefExecFailure(["var x = -[8]"], "E39:", 1) 2444 call CheckDefExecFailure(["var x = -[8]"], "E39:", 1)
2436 call CheckDefExecFailure(["var x = -{'a': 1}"], "E39:", 1) 2445 call CheckDefExecFailure(["var x = -{a: 1}"], "E39:", 1)
2437 2446
2438 call CheckDefFailure(["var x = @"], "E1002:", 1) 2447 call CheckDefFailure(["var x = @"], "E1002:", 1)
2439 call CheckDefFailure(["var x = @<"], "E354:", 1) 2448 call CheckDefFailure(["var x = @<"], "E354:", 1)
2440 2449
2441 call CheckDefFailure(["var x = [1, 2"], "E697:", 2) 2450 call CheckDefFailure(["var x = [1, 2"], "E697:", 2)
2462 call CheckDefFailure(["var x = ''", "var y = x.memb"], 'E715:', 2) 2471 call CheckDefFailure(["var x = ''", "var y = x.memb"], 'E715:', 2)
2463 2472
2464 call CheckDefFailure(["'yes'->", "Echo()"], 'E488: Trailing characters: ->', 1) 2473 call CheckDefFailure(["'yes'->", "Echo()"], 'E488: Trailing characters: ->', 1)
2465 2474
2466 call CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2) 2475 call CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
2467 call CheckDefExecFailure(["#{a: 1->len()"], 'E722:', 1) 2476 call CheckDefExecFailure(["{a: 1->len()"], 'E451:', 1)
2468 call CheckDefExecFailure(["{'a': 1->len()"], 'E723:', 2) 2477 call CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
2469 endfunc 2478 endfunc
2470 2479
2471 let g:Funcrefs = [function('add')] 2480 let g:Funcrefs = [function('add')]
2472 2481
2473 func CallMe(arg) 2482 func CallMe(arg)
2505 l = [2, 5] 2514 l = [2, 5]
2506 l->{l -> add(l, 8)}() 2515 l->{l -> add(l, 8)}()
2507 assert_equal([2, 5, 8], l) 2516 assert_equal([2, 5, 8], l)
2508 2517
2509 # dict member 2518 # dict member
2510 var d = #{key: 123} 2519 var d = {key: 123}
2511 assert_equal(123, d.key) 2520 assert_equal(123, d.key)
2512 enddef 2521 enddef
2513 2522
2514 def Test_expr7_string_subscript() 2523 def Test_expr7_string_subscript()
2515 var lines =<< trim END 2524 var lines =<< trim END
2592 enddef 2601 enddef
2593 2602
2594 def Test_expr7_dict_subscript() 2603 def Test_expr7_dict_subscript()
2595 var lines =<< trim END 2604 var lines =<< trim END
2596 vim9script 2605 vim9script
2597 var l = [#{lnum: 2}, #{lnum: 1}] 2606 var l = [{lnum: 2}, {lnum: 1}]
2598 var res = l[0].lnum > l[1].lnum 2607 var res = l[0].lnum > l[1].lnum
2599 assert_true(res) 2608 assert_true(res)
2600 END 2609 END
2601 CheckScriptSuccess(lines) 2610 CheckScriptSuccess(lines)
2602 enddef 2611 enddef
2627 assert_equal(['0', '1', '2'], l) 2636 assert_equal(['0', '1', '2'], l)
2628 2637
2629 assert_equal('1', l[ 2638 assert_equal('1', l[
2630 1]) 2639 1])
2631 2640
2632 var d = #{one: 33} 2641 var d = {one: 33}
2633 assert_equal(33, d. 2642 assert_equal(33, d.
2634 one) 2643 one)
2635 enddef 2644 enddef
2636 2645
2637 def Test_expr7_method_call() 2646 def Test_expr7_method_call()
2641 "third"->append(2) 2650 "third"->append(2)
2642 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$')) 2651 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
2643 bwipe! 2652 bwipe!
2644 2653
2645 var bufnr = bufnr() 2654 var bufnr = bufnr()
2646 var loclist = [#{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}] 2655 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
2647 loclist->setloclist(0) 2656 loclist->setloclist(0)
2648 assert_equal([#{bufnr: bufnr, 2657 assert_equal([{bufnr: bufnr,
2649 lnum: 42, 2658 lnum: 42,
2650 col: 17, 2659 col: 17,
2651 text: 'wrong', 2660 text: 'wrong',
2652 pattern: '', 2661 pattern: '',
2653 valid: 1, 2662 valid: 1,
2655 nr: 0, 2664 nr: 0,
2656 type: '', 2665 type: '',
2657 module: ''} 2666 module: ''}
2658 ], getloclist(0)) 2667 ], getloclist(0))
2659 2668
2660 var result: bool = get(#{n: 0}, 'n', 0) 2669 var result: bool = get({n: 0}, 'n', 0)
2661 assert_equal(false, result) 2670 assert_equal(false, result)
2662 enddef 2671 enddef
2663 2672
2664 func Test_expr7_trailing_fails() 2673 func Test_expr7_trailing_fails()
2665 call CheckDefFailure(['var l = [2]', 'l->{l -> add(l, 8)}'], 'E107:', 2) 2674 call CheckDefFailure(['var l = [2]', 'l->{l -> add(l, 8)}'], 'E107:', 2)