Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1 | " Test Vim9 assignments |
| 2 | |
| 3 | source check.vim |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 4 | import './vim9.vim' as v9 |
Bram Moolenaar | c653e4a | 2022-01-05 10:16:30 +0000 | [diff] [blame] | 5 | source term_util.vim |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 6 | |
| 7 | let s:appendToMe = 'xxx' |
| 8 | let s:addToMe = 111 |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 9 | let s:newVar = '' |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 10 | let g:existing = 'yes' |
| 11 | let g:inc_counter = 1 |
| 12 | let $SOME_ENV_VAR = 'some' |
| 13 | let g:alist = [7] |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 14 | let g:adict = #{a: 1} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 15 | let g:astring = 'text' |
| 16 | |
| 17 | def Test_assignment_bool() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 18 | var bool1: bool = true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 19 | assert_equal(v:true, bool1) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 20 | var bool2: bool = false |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 21 | assert_equal(v:false, bool2) |
| 22 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 23 | var bool3: bool = 0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 24 | assert_equal(false, bool3) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 25 | var bool4: bool = 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 26 | assert_equal(true, bool4) |
| 27 | |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 28 | var bool5: bool = 1 && true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 29 | assert_equal(true, bool5) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 30 | var bool6: bool = 0 && 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 31 | assert_equal(false, bool6) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 32 | var bool7: bool = 0 || 1 && true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 33 | assert_equal(true, bool7) |
| 34 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 35 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 36 | vim9script |
| 37 | def GetFlag(): bool |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 38 | var flag: bool = 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 39 | return flag |
| 40 | enddef |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 41 | var flag: bool = GetFlag() |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 42 | assert_equal(true, flag) |
| 43 | flag = 0 |
| 44 | assert_equal(false, flag) |
| 45 | flag = 1 |
| 46 | assert_equal(true, flag) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 47 | flag = 1 || true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 48 | assert_equal(true, flag) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 49 | flag = 1 && false |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 50 | assert_equal(false, flag) |
Bram Moolenaar | dd1f426 | 2020-12-31 17:41:01 +0100 | [diff] [blame] | 51 | |
| 52 | var cp: bool = &cp |
| 53 | var fen: bool = &l:fen |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 54 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 55 | v9.CheckScriptSuccess(lines) |
| 56 | v9.CheckDefAndScriptFailure(['var x: bool = 2'], 'E1012:') |
| 57 | v9.CheckDefAndScriptFailure(['var x: bool = -1'], 'E1012:') |
| 58 | v9.CheckDefAndScriptFailure(['var x: bool = [1]'], 'E1012:') |
| 59 | v9.CheckDefAndScriptFailure(['var x: bool = {}'], 'E1012:') |
| 60 | v9.CheckDefAndScriptFailure(['var x: bool = "x"'], 'E1012:') |
Bram Moolenaar | 9a562c1 | 2021-01-23 13:39:14 +0100 | [diff] [blame] | 61 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 62 | v9.CheckDefAndScriptFailure(['var x: bool = "x"', '', 'eval 0'], 'E1012:', 1) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 63 | enddef |
| 64 | |
| 65 | def Test_syntax() |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 66 | var name = 234 |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 67 | var other: list<string> = ['asdf'] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 68 | enddef |
| 69 | |
| 70 | def Test_assignment() |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 71 | v9.CheckDefFailure(['var x:string'], 'E1069:') |
| 72 | v9.CheckDefFailure(['var x:string = "x"'], 'E1069:') |
| 73 | v9.CheckDefFailure(['var a:string = "x"'], 'E1069:') |
| 74 | v9.CheckDefFailure(['var lambda = () => "lambda"'], 'E704:') |
| 75 | v9.CheckScriptFailure(['var x = "x"'], 'E1124:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 76 | |
Bram Moolenaar | 3f32788 | 2021-03-17 20:56:38 +0100 | [diff] [blame] | 77 | # lower case name is OK for a list |
| 78 | var lambdaLines =<< trim END |
Bram Moolenaar | 848fadd | 2022-01-30 15:28:30 +0000 | [diff] [blame] | 79 | var lambdaList: list<func> = [g:Test_syntax] |
Bram Moolenaar | 3f32788 | 2021-03-17 20:56:38 +0100 | [diff] [blame] | 80 | lambdaList[0] = () => "lambda" |
| 81 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 82 | v9.CheckDefAndScriptSuccess(lambdaLines) |
Bram Moolenaar | 3f32788 | 2021-03-17 20:56:38 +0100 | [diff] [blame] | 83 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 84 | var nr: number = 1234 |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 85 | v9.CheckDefFailure(['var nr: number = "asdf"'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 86 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 87 | var a: number = 6 #comment |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 88 | assert_equal(6, a) |
| 89 | |
| 90 | if has('channel') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 91 | var chan1: channel |
Bram Moolenaar | 218450a | 2020-10-17 18:51:52 +0200 | [diff] [blame] | 92 | assert_equal('fail', ch_status(chan1)) |
| 93 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 94 | var job1: job |
Bram Moolenaar | 218450a | 2020-10-17 18:51:52 +0200 | [diff] [blame] | 95 | assert_equal('fail', job_status(job1)) |
| 96 | |
Bram Moolenaar | fc8aa6d | 2020-10-12 20:31:26 +0200 | [diff] [blame] | 97 | # calling job_start() is in test_vim9_fails.vim, it causes leak reports |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 98 | endif |
| 99 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 100 | var float1: float = 3.4 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 101 | endif |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 102 | var Funky1: func |
| 103 | var Funky2: func = function('len') |
| 104 | var Party2: func = funcref('g:Test_syntax') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 105 | |
| 106 | g:newvar = 'new' #comment |
| 107 | assert_equal('new', g:newvar) |
| 108 | |
| 109 | assert_equal('yes', g:existing) |
| 110 | g:existing = 'no' |
| 111 | assert_equal('no', g:existing) |
| 112 | |
| 113 | v:char = 'abc' |
| 114 | assert_equal('abc', v:char) |
| 115 | |
| 116 | $ENVVAR = 'foobar' |
| 117 | assert_equal('foobar', $ENVVAR) |
| 118 | $ENVVAR = '' |
| 119 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 120 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 121 | vim9script |
| 122 | $ENVVAR = 'barfoo' |
| 123 | assert_equal('barfoo', $ENVVAR) |
| 124 | $ENVVAR = '' |
| 125 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 126 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 127 | |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 128 | appendToMe ..= 'yyy' |
| 129 | assert_equal('xxxyyy', appendToMe) |
| 130 | addToMe += 222 |
| 131 | assert_equal(333, addToMe) |
| 132 | newVar = 'new' |
| 133 | assert_equal('new', newVar) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 134 | |
| 135 | set ts=7 |
Bram Moolenaar | dd1f426 | 2020-12-31 17:41:01 +0100 | [diff] [blame] | 136 | var ts: number = &ts |
| 137 | assert_equal(7, ts) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 138 | &ts += 1 |
| 139 | assert_equal(8, &ts) |
| 140 | &ts -= 3 |
| 141 | assert_equal(5, &ts) |
| 142 | &ts *= 2 |
| 143 | assert_equal(10, &ts) |
| 144 | &ts /= 3 |
| 145 | assert_equal(3, &ts) |
| 146 | set ts=10 |
| 147 | &ts %= 4 |
| 148 | assert_equal(2, &ts) |
| 149 | |
| 150 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 151 | var f100: float = 100.0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 152 | f100 /= 5 |
| 153 | assert_equal(20.0, f100) |
| 154 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 155 | var f200: float = 200.0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 156 | f200 /= 5.0 |
| 157 | assert_equal(40.0, f200) |
| 158 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 159 | v9.CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 160 | endif |
| 161 | |
| 162 | lines =<< trim END |
| 163 | &ts = 6 |
| 164 | &ts += 3 |
| 165 | assert_equal(9, &ts) |
| 166 | |
| 167 | &l:ts = 6 |
| 168 | assert_equal(6, &ts) |
| 169 | &l:ts += 2 |
| 170 | assert_equal(8, &ts) |
| 171 | |
| 172 | &g:ts = 6 |
| 173 | assert_equal(6, &g:ts) |
| 174 | &g:ts += 2 |
| 175 | assert_equal(8, &g:ts) |
Bram Moolenaar | 0ea0440 | 2021-01-04 13:37:54 +0100 | [diff] [blame] | 176 | |
| 177 | &number = true |
| 178 | assert_equal(true, &number) |
| 179 | &number = 0 |
| 180 | assert_equal(false, &number) |
| 181 | &number = 1 |
| 182 | assert_equal(true, &number) |
| 183 | &number = false |
| 184 | assert_equal(false, &number) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 185 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 186 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 187 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 188 | v9.CheckDefFailure(['¬ex += 3'], 'E113:') |
| 189 | v9.CheckDefFailure(['&ts ..= "xxx"'], 'E1019:') |
| 190 | v9.CheckDefFailure(['&ts = [7]'], 'E1012:') |
| 191 | v9.CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>') |
| 192 | v9.CheckDefFailure(['&ts = "xx"'], 'E1012:') |
| 193 | v9.CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string') |
| 194 | v9.CheckDefFailure(['&path += 3'], 'E1012:') |
| 195 | v9.CheckDefExecFailure(['&bs = "asdf"'], 'E474:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 196 | # test freeing ISN_STOREOPT |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 197 | v9.CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 198 | &ts = 8 |
| 199 | |
| 200 | lines =<< trim END |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 201 | var save_TI = &t_TI |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 202 | &t_TI = '' |
| 203 | assert_equal('', &t_TI) |
| 204 | &t_TI = 'xxx' |
| 205 | assert_equal('xxx', &t_TI) |
| 206 | &t_TI = save_TI |
| 207 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 208 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 209 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 210 | v9.CheckDefFailure(['&t_TI = 123'], 'E1012:') |
| 211 | v9.CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 212 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 213 | v9.CheckDefFailure(['var s:var = 123'], 'E1101:') |
| 214 | v9.CheckDefFailure(['var s:var: number'], 'E1101:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 215 | |
| 216 | lines =<< trim END |
| 217 | vim9script |
| 218 | def SomeFunc() |
| 219 | s:var = 123 |
| 220 | enddef |
| 221 | defcompile |
| 222 | END |
Bram Moolenaar | afa048f | 2022-02-22 20:43:36 +0000 | [diff] [blame] | 223 | v9.CheckScriptFailure(lines, 'E1268:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 224 | |
| 225 | g:inc_counter += 1 |
| 226 | assert_equal(2, g:inc_counter) |
| 227 | |
Bram Moolenaar | 7bf9a07 | 2021-08-02 21:55:15 +0200 | [diff] [blame] | 228 | if has('float') |
| 229 | var f: float |
| 230 | f += 1 |
| 231 | assert_equal(1.0, f) |
| 232 | endif |
| 233 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 234 | $SOME_ENV_VAR ..= 'more' |
| 235 | assert_equal('somemore', $SOME_ENV_VAR) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 236 | v9.CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:') |
| 237 | v9.CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 238 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 239 | v:errmsg = 'none' |
| 240 | v:errmsg ..= 'again' |
| 241 | assert_equal('noneagain', v:errmsg) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 242 | v9.CheckDefFailure(['v:errmsg += "more"'], 'E1051:') |
| 243 | v9.CheckDefFailure(['v:errmsg += 123'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 244 | |
Bram Moolenaar | fc8aa6d | 2020-10-12 20:31:26 +0200 | [diff] [blame] | 245 | var text =<< trim END |
| 246 | some text |
| 247 | END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 248 | enddef |
| 249 | |
Bram Moolenaar | af647e7 | 2021-08-05 19:01:17 +0200 | [diff] [blame] | 250 | def Test_float_and_number() |
| 251 | if !has('float') |
| 252 | MissingFeature float |
| 253 | else |
| 254 | var lines =<< trim END |
| 255 | var f: float |
| 256 | f += 2 |
| 257 | f -= 1 |
| 258 | assert_equal(1.0, f) |
| 259 | ++f |
| 260 | --f |
| 261 | assert_equal(1.0, f) |
| 262 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 263 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | af647e7 | 2021-08-05 19:01:17 +0200 | [diff] [blame] | 264 | endif |
| 265 | enddef |
| 266 | |
Bram Moolenaar | f5d52c9 | 2021-07-31 22:51:10 +0200 | [diff] [blame] | 267 | let g:someNumber = 43 |
| 268 | |
| 269 | def Test_assign_concat() |
| 270 | var lines =<< trim END |
| 271 | var s = '-' |
| 272 | s ..= 99 |
| 273 | s ..= true |
| 274 | s ..= '-' |
| 275 | s ..= v:null |
| 276 | s ..= g:someNumber |
| 277 | assert_equal('-99true-null43', s) |
| 278 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 279 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | f5d52c9 | 2021-07-31 22:51:10 +0200 | [diff] [blame] | 280 | |
| 281 | lines =<< trim END |
| 282 | var s = '-' |
| 283 | s ..= [1, 2] |
| 284 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 285 | v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert list to string', 'E734: Wrong variable type for .='], 2) |
Bram Moolenaar | f5d52c9 | 2021-07-31 22:51:10 +0200 | [diff] [blame] | 286 | lines =<< trim END |
| 287 | var s = '-' |
| 288 | s ..= {a: 2} |
| 289 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 290 | v9.CheckDefAndScriptFailure(lines, ['E1105: Cannot convert dict to string', 'E734: Wrong variable type for .='], 2) |
Bram Moolenaar | f5d52c9 | 2021-07-31 22:51:10 +0200 | [diff] [blame] | 291 | enddef |
| 292 | |
Bram Moolenaar | 13e45d1 | 2021-06-26 13:28:35 +0200 | [diff] [blame] | 293 | def Test_assign_register() |
| 294 | var lines =<< trim END |
| 295 | @c = 'areg' |
| 296 | @c ..= 'add' |
| 297 | assert_equal('aregadd', @c) |
| 298 | |
| 299 | @@ = 'some text' |
| 300 | assert_equal('some text', getreg('"')) |
| 301 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 302 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 13e45d1 | 2021-06-26 13:28:35 +0200 | [diff] [blame] | 303 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 304 | v9.CheckDefFailure(['@a += "more"'], 'E1051:') |
| 305 | v9.CheckDefFailure(['@a += 123'], 'E1012:') |
Bram Moolenaar | 13e45d1 | 2021-06-26 13:28:35 +0200 | [diff] [blame] | 306 | enddef |
| 307 | |
Bram Moolenaar | d0edaf9 | 2021-05-28 21:06:08 +0200 | [diff] [blame] | 308 | def Test_reserved_name() |
Bram Moolenaar | 8acb9cc | 2022-03-08 13:18:55 +0000 | [diff] [blame] | 309 | var more_names = ['null_job', 'null_channel'] |
| 310 | if !has('job') |
| 311 | more_names = [] |
| 312 | endif |
| 313 | |
| 314 | for name in ['true', |
| 315 | 'false', |
| 316 | 'null', |
| 317 | 'null_blob', |
| 318 | 'null_dict', |
| 319 | 'null_function', |
| 320 | 'null_list', |
| 321 | 'null_partial', |
| 322 | 'null_string', |
| 323 | ] + more_names |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 324 | v9.CheckDefExecAndScriptFailure(['var ' .. name .. ' = 0'], 'E1034:') |
| 325 | v9.CheckDefExecAndScriptFailure(['var ' .. name .. ': bool'], 'E1034:') |
Bram Moolenaar | d0edaf9 | 2021-05-28 21:06:08 +0200 | [diff] [blame] | 326 | endfor |
| 327 | enddef |
| 328 | |
Bram Moolenaar | 8acb9cc | 2022-03-08 13:18:55 +0000 | [diff] [blame] | 329 | def Test_null_values() |
| 330 | var lines =<< trim END |
| 331 | var b: blob = null_blob |
| 332 | var dn: dict<number> = null_dict |
| 333 | var ds: dict<string> = null_dict |
| 334 | var ln: list<number> = null_list |
| 335 | var ls: list<string> = null_list |
| 336 | var Ff: func(string): string = null_function |
| 337 | var Fp: func(number): number = null_partial |
| 338 | var s: string = null_string |
| 339 | if has('job') |
| 340 | var j: job = null_job |
| 341 | var c: channel = null_channel |
| 342 | endif |
Bram Moolenaar | 56b84b1 | 2022-03-09 19:46:48 +0000 | [diff] [blame] | 343 | |
| 344 | var d: dict<func> = {a: function('tr'), b: null_function} |
Bram Moolenaar | badf04f | 2022-03-12 21:28:22 +0000 | [diff] [blame] | 345 | |
| 346 | var bl: list<blob> = [0z12, null_blob] |
| 347 | var dnl: list<dict<number>> = [{a: 1}, null_dict] |
| 348 | var dsl: list<dict<string>> = [{a: 'x'}, null_dict] |
| 349 | var lnl: list<list<number>> = [[1], null_list] |
| 350 | var lsl: list<list<string>> = [['x'], null_list] |
| 351 | def Len(v: string): number |
| 352 | return len(v) |
| 353 | enddef |
| 354 | var Ffl: list<func(string): number> = [Len, null_function] |
| 355 | var Fpl: list<func(string): number> = [Len, null_partial] |
| 356 | var sl: list<string> = ['x', null_string] |
| 357 | if has('job') |
| 358 | var jl: list<job> = [null_job] |
| 359 | var cl: list<channel> = [null_channel] |
| 360 | endif |
Bram Moolenaar | 8acb9cc | 2022-03-08 13:18:55 +0000 | [diff] [blame] | 361 | END |
| 362 | v9.CheckDefAndScriptSuccess(lines) |
| 363 | enddef |
| 364 | |
Bram Moolenaar | 56b84b1 | 2022-03-09 19:46:48 +0000 | [diff] [blame] | 365 | def Test_keep_type_after_assigning_null() |
| 366 | var lines =<< trim END |
| 367 | var b: blob |
| 368 | b = null_blob |
| 369 | b = 'text' |
| 370 | END |
| 371 | v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected blob but got string') |
| 372 | |
| 373 | lines =<< trim END |
| 374 | var l: list<number> |
| 375 | l = null_list |
| 376 | l = ['text'] |
| 377 | END |
| 378 | v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>') |
| 379 | |
| 380 | lines =<< trim END |
| 381 | var d: dict<string> |
| 382 | d = null_dict |
| 383 | d = {a: 1, b: 2} |
| 384 | END |
| 385 | v9.CheckDefExecAndScriptFailure(lines, 'E1012: Type mismatch; expected dict<string> but got dict<number>') |
| 386 | enddef |
| 387 | |
Bram Moolenaar | aa1959b | 2021-04-15 22:13:39 +0200 | [diff] [blame] | 388 | def Test_skipped_assignment() |
| 389 | var lines =<< trim END |
| 390 | for x in [] |
| 391 | var i: number = 1 |
| 392 | while false |
| 393 | i += 1 |
| 394 | endwhile |
| 395 | endfor |
| 396 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 397 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | aa1959b | 2021-04-15 22:13:39 +0200 | [diff] [blame] | 398 | enddef |
| 399 | |
Bram Moolenaar | 7824fc8 | 2021-11-26 17:36:51 +0000 | [diff] [blame] | 400 | def Test_assign_keep_type() |
| 401 | var lines =<< trim END |
| 402 | vim9script |
| 403 | var l: list<number> = [123] |
| 404 | l = [123] |
| 405 | l->add('string') |
| 406 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 407 | v9.CheckScriptFailure(lines, 'E1012:', 4) |
Bram Moolenaar | 7824fc8 | 2021-11-26 17:36:51 +0000 | [diff] [blame] | 408 | enddef |
| 409 | |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 410 | def Test_assign_unpack() |
| 411 | var lines =<< trim END |
| 412 | var v1: number |
| 413 | var v2: number |
| 414 | [v1, v2] = [1, 2] |
| 415 | assert_equal(1, v1) |
| 416 | assert_equal(2, v2) |
Bram Moolenaar | f93bbd0 | 2021-04-10 22:35:43 +0200 | [diff] [blame] | 417 | |
| 418 | [v1, _, v2, _] = [1, 99, 2, 77] |
| 419 | assert_equal(1, v1) |
| 420 | assert_equal(2, v2) |
| 421 | |
| 422 | [v1, v2; _] = [1, 2, 3, 4, 5] |
| 423 | assert_equal(1, v1) |
| 424 | assert_equal(2, v2) |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 425 | |
Bram Moolenaar | bc51006 | 2022-02-14 21:19:04 +0000 | [diff] [blame] | 426 | var _x: number |
| 427 | [_x, v2] = [6, 7] |
| 428 | assert_equal(6, _x) |
| 429 | assert_equal(7, v2) |
| 430 | |
Bram Moolenaar | 4d5dfe2 | 2021-06-26 13:59:29 +0200 | [diff] [blame] | 431 | var reslist = [] |
| 432 | for text in ['aaa {bbb} ccc', 'ddd {eee} fff'] |
| 433 | var before: string |
| 434 | var middle: string |
| 435 | var after: string |
| 436 | [_, before, middle, after; _] = text->matchlist('\(.\{-\}\){\(.\{-\}\)}\(.*\)') |
| 437 | reslist->add(before)->add(middle)->add(after) |
| 438 | endfor |
| 439 | assert_equal(['aaa ', 'bbb', ' ccc', 'ddd ', 'eee', ' fff'], reslist) |
| 440 | |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 441 | var a = 1 |
| 442 | var b = 3 |
| 443 | [a, b] += [2, 4] |
| 444 | assert_equal(3, a) |
| 445 | assert_equal(7, b) |
| 446 | |
| 447 | [a, b] -= [1, 2] |
| 448 | assert_equal(2, a) |
| 449 | assert_equal(5, b) |
| 450 | |
| 451 | [a, b] *= [3, 2] |
| 452 | assert_equal(6, a) |
| 453 | assert_equal(10, b) |
| 454 | |
| 455 | [a, b] /= [2, 4] |
| 456 | assert_equal(3, a) |
| 457 | assert_equal(2, b) |
| 458 | |
| 459 | [a, b] = [17, 15] |
| 460 | [a, b] %= [5, 3] |
| 461 | assert_equal(2, a) |
| 462 | assert_equal(0, b) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 463 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 464 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 465 | |
| 466 | lines =<< trim END |
| 467 | var v1: number |
| 468 | var v2: number |
Bram Moolenaar | db9ff9a | 2021-12-01 17:38:01 +0000 | [diff] [blame] | 469 | [v1, v2] = [1, 2, 3] |
| 470 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 471 | v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 3', 3) |
Bram Moolenaar | db9ff9a | 2021-12-01 17:38:01 +0000 | [diff] [blame] | 472 | |
| 473 | lines =<< trim END |
| 474 | var v1: number |
| 475 | var v2: number |
| 476 | [v1, v2] = [1] |
| 477 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 478 | v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3) |
Bram Moolenaar | db9ff9a | 2021-12-01 17:38:01 +0000 | [diff] [blame] | 479 | |
| 480 | lines =<< trim END |
| 481 | var v1: number |
| 482 | var v2: number |
| 483 | [v1, v2; _] = [1] |
| 484 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 485 | v9.CheckDefFailure(lines, 'E1093: Expected 2 items but got 1', 3) |
Bram Moolenaar | db9ff9a | 2021-12-01 17:38:01 +0000 | [diff] [blame] | 486 | |
| 487 | lines =<< trim END |
| 488 | var v1: number |
| 489 | var v2: number |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 490 | [v1, v2] = |
| 491 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 492 | v9.CheckDefFailure(lines, 'E1097:', 5) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 493 | |
| 494 | lines =<< trim END |
| 495 | var v1: number |
| 496 | var v2: number |
| 497 | [v1, v2] = xxx |
| 498 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 499 | v9.CheckDefFailure(lines, 'E1001:', 3) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 500 | |
| 501 | lines =<< trim END |
| 502 | var v1: number |
| 503 | var v2: number |
| 504 | [v1, v2] = popup_clear() |
| 505 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 506 | v9.CheckDefFailure(lines, 'E1031:', 3) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 507 | |
| 508 | lines =<< trim END |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 509 | [v1, v2] = [1, 2] |
| 510 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 511 | v9.CheckDefFailure(lines, 'E1089', 1) |
| 512 | v9.CheckScriptFailure(['vim9script'] + lines, 'E1089', 2) |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 513 | |
| 514 | lines =<< trim END |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 515 | var v1: number |
| 516 | var v2: number |
| 517 | [v1, v2] = '' |
| 518 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 519 | v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3) |
Bram Moolenaar | f785aa1 | 2021-02-11 21:19:34 +0100 | [diff] [blame] | 520 | |
| 521 | lines =<< trim END |
| 522 | g:values = [false, 0] |
| 523 | var x: bool |
| 524 | var y: string |
| 525 | [x, y] = g:values |
| 526 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 527 | v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 2: type mismatch, expected string but got number') |
Bram Moolenaar | 4270d8b | 2021-08-07 16:30:42 +0200 | [diff] [blame] | 528 | |
| 529 | lines =<< trim END |
| 530 | var x: number |
| 531 | var y: number |
| 532 | var z: string |
| 533 | [x, y, z] = [1, 2, 3] |
| 534 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 535 | v9.CheckDefAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number') |
Bram Moolenaar | 4270d8b | 2021-08-07 16:30:42 +0200 | [diff] [blame] | 536 | |
| 537 | lines =<< trim END |
| 538 | var x: number |
| 539 | var y: string |
| 540 | var z: string |
| 541 | [x, y, z] = [1, '2', 3] |
| 542 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 543 | v9.CheckDefExecAndScriptFailure(lines, 'E1163: Variable 3: type mismatch, expected string but got number') |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 544 | enddef |
| 545 | |
Bram Moolenaar | 7f76494 | 2020-12-02 15:11:18 +0100 | [diff] [blame] | 546 | def Test_assign_linebreak() |
| 547 | var nr: number |
| 548 | nr = |
| 549 | 123 |
| 550 | assert_equal(123, nr) |
| 551 | |
| 552 | var n2: number |
| 553 | [nr, n2] = |
| 554 | [12, 34] |
| 555 | assert_equal(12, nr) |
| 556 | assert_equal(34, n2) |
| 557 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 558 | v9.CheckDefFailure(["var x = #"], 'E1097:', 3) |
Bram Moolenaar | 77709b1 | 2021-04-03 21:01:01 +0200 | [diff] [blame] | 559 | |
| 560 | var lines =<< trim END |
| 561 | var x: list<string> = ['a'] |
| 562 | var y: list<number> = x |
| 563 | ->copy() |
| 564 | ->copy() |
| 565 | END |
Bram Moolenaar | 381692b | 2022-02-02 20:01:27 +0000 | [diff] [blame] | 566 | v9.CheckDefExecFailure(lines, 'E1012:', 4) |
Bram Moolenaar | 6977dba | 2021-07-04 22:48:12 +0200 | [diff] [blame] | 567 | |
| 568 | lines =<< trim END |
| 569 | var x: any |
| 570 | x.key = 1 |
| 571 | + 2 |
| 572 | + 3 |
| 573 | + 4 |
| 574 | + 5 |
| 575 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 576 | v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203:'], 2) |
Bram Moolenaar | 7f76494 | 2020-12-02 15:11:18 +0100 | [diff] [blame] | 577 | enddef |
| 578 | |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 579 | def Test_assign_index() |
| 580 | # list of list |
| 581 | var l1: list<number> |
| 582 | l1[0] = 123 |
| 583 | assert_equal([123], l1) |
| 584 | |
| 585 | var l2: list<list<number>> |
| 586 | l2[0] = [] |
| 587 | l2[0][0] = 123 |
| 588 | assert_equal([[123]], l2) |
| 589 | |
| 590 | var l3: list<list<list<number>>> |
| 591 | l3[0] = [] |
| 592 | l3[0][0] = [] |
| 593 | l3[0][0][0] = 123 |
| 594 | assert_equal([[[123]]], l3) |
| 595 | |
| 596 | var lines =<< trim END |
| 597 | var l3: list<list<number>> |
| 598 | l3[0] = [] |
| 599 | l3[0][0] = [] |
| 600 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 601 | v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<unknown>', 3) |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 602 | |
| 603 | # dict of dict |
| 604 | var d1: dict<number> |
| 605 | d1.one = 1 |
| 606 | assert_equal({one: 1}, d1) |
| 607 | |
| 608 | var d2: dict<dict<number>> |
| 609 | d2.one = {} |
| 610 | d2.one.two = 123 |
| 611 | assert_equal({one: {two: 123}}, d2) |
| 612 | |
| 613 | var d3: dict<dict<dict<number>>> |
| 614 | d3.one = {} |
| 615 | d3.one.two = {} |
| 616 | d3.one.two.three = 123 |
| 617 | assert_equal({one: {two: {three: 123}}}, d3) |
| 618 | |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 619 | # blob |
| 620 | var bl: blob = 0z11223344 |
| 621 | bl[0] = 0x77 |
| 622 | assert_equal(0z77223344, bl) |
| 623 | bl[-2] = 0x66 |
| 624 | assert_equal(0z77226644, bl) |
| 625 | |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 626 | lines =<< trim END |
| 627 | g:val = '22' |
| 628 | var bl = 0z11 |
| 629 | bl[1] = g:val |
| 630 | END |
| 631 | v9.CheckDefExecAndScriptFailure(lines, 'E1030: Using a String as a Number: "22"') |
| 632 | |
Bram Moolenaar | e97976b | 2021-08-01 13:17:17 +0200 | [diff] [blame] | 633 | # should not read the next line when generating "a.b" |
| 634 | var a = {} |
| 635 | a.b = {} |
| 636 | a.b.c = {} |
| 637 | ->copy() |
| 638 | |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 639 | lines =<< trim END |
| 640 | var d3: dict<dict<number>> |
| 641 | d3.one = {} |
| 642 | d3.one.two = {} |
| 643 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 644 | v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<unknown>', 3) |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 645 | |
Bram Moolenaar | acbae18 | 2020-12-13 18:44:43 +0100 | [diff] [blame] | 646 | lines =<< trim END |
| 647 | var lines: list<string> |
| 648 | lines['a'] = 'asdf' |
| 649 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 650 | v9.CheckDefFailure(lines, 'E1012:', 2) |
Bram Moolenaar | acbae18 | 2020-12-13 18:44:43 +0100 | [diff] [blame] | 651 | |
| 652 | lines =<< trim END |
| 653 | var lines: string |
| 654 | lines[9] = 'asdf' |
| 655 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 656 | v9.CheckDefFailure(lines, 'E1141:', 2) |
Bram Moolenaar | acbae18 | 2020-12-13 18:44:43 +0100 | [diff] [blame] | 657 | |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 658 | # list of dict |
| 659 | var ld: list<dict<number>> |
| 660 | ld[0] = {} |
| 661 | ld[0].one = 123 |
| 662 | assert_equal([{one: 123}], ld) |
| 663 | |
| 664 | lines =<< trim END |
| 665 | var ld: list<dict<number>> |
| 666 | ld[0] = [] |
| 667 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 668 | v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2) |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 669 | |
| 670 | # dict of list |
| 671 | var dl: dict<list<number>> |
| 672 | dl.one = [] |
| 673 | dl.one[0] = 123 |
| 674 | assert_equal({one: [123]}, dl) |
| 675 | |
| 676 | lines =<< trim END |
| 677 | var dl: dict<list<number>> |
| 678 | dl.one = {} |
| 679 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 680 | v9.CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<unknown>', 2) |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 681 | |
| 682 | lines =<< trim END |
| 683 | g:l = [1, 2] |
| 684 | g:l['x'] = 3 |
| 685 | END |
| 686 | v9.CheckDefExecAndScriptFailure(lines, ['E39:', 'E1030:'], 2) |
| 687 | |
| 688 | lines =<< trim END |
| 689 | var bl: blob = test_null_blob() |
| 690 | bl[1] = 8 |
| 691 | END |
| 692 | v9.CheckDefExecAndScriptFailure(lines, ['E1184:', 'E979:'], 2) |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 693 | |
| 694 | lines =<< trim END |
| 695 | g:bl = 'not a blob' |
| 696 | g:bl[1 : 2] = 8 |
| 697 | END |
| 698 | v9.CheckDefExecAndScriptFailure(lines, ['E897:', 'E689:'], 2) |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 699 | enddef |
| 700 | |
Bram Moolenaar | 38ecd97 | 2022-01-15 21:44:44 +0000 | [diff] [blame] | 701 | def Test_init_in_for_loop() |
| 702 | var lines =<< trim END |
| 703 | var l: list<number> = [] |
| 704 | for i in [3, 4] |
| 705 | var n: number |
| 706 | add(l, n) |
| 707 | n = 123 |
| 708 | endfor |
| 709 | assert_equal([0, 0], l) |
| 710 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 711 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 38ecd97 | 2022-01-15 21:44:44 +0000 | [diff] [blame] | 712 | |
| 713 | lines =<< trim END |
| 714 | var l: list<number> = [] |
| 715 | for i in [3, 4] |
| 716 | var n: number = 0 |
| 717 | add(l, n) |
| 718 | n = 123 |
| 719 | endfor |
| 720 | assert_equal([0, 0], l) |
| 721 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 722 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 38ecd97 | 2022-01-15 21:44:44 +0000 | [diff] [blame] | 723 | |
| 724 | lines =<< trim END |
| 725 | var l: list<number> = [] |
| 726 | for i in [3, 4] |
| 727 | var n: number = 3 |
| 728 | add(l, n) |
| 729 | n = 123 |
| 730 | endfor |
| 731 | assert_equal([3, 3], l) |
| 732 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 733 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 38ecd97 | 2022-01-15 21:44:44 +0000 | [diff] [blame] | 734 | enddef |
| 735 | |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 736 | def Test_extend_list() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 737 | var lines =<< trim END |
Bram Moolenaar | 0780204 | 2021-09-09 23:01:14 +0200 | [diff] [blame] | 738 | var l1: list<number> |
| 739 | var l2 = l1 |
| 740 | assert_true(l1 is l2) |
| 741 | l1 += [123] |
| 742 | assert_equal([123], l1) |
| 743 | assert_true(l1 is l2) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 744 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 745 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 746 | |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 747 | lines =<< trim END |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 748 | var list: list<string> |
| 749 | extend(list, ['x']) |
| 750 | assert_equal(['x'], list) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 751 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 752 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 1a73923 | 2020-10-10 15:37:58 +0200 | [diff] [blame] | 753 | |
| 754 | # appending to NULL list from a function |
| 755 | lines =<< trim END |
| 756 | vim9script |
| 757 | var list: list<string> |
| 758 | def Func() |
| 759 | list += ['a', 'b'] |
| 760 | enddef |
| 761 | Func() |
| 762 | assert_equal(['a', 'b'], list) |
| 763 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 764 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 3beaf9c | 2020-12-18 17:23:14 +0100 | [diff] [blame] | 765 | lines =<< trim END |
| 766 | vim9script |
| 767 | var list: list<string> |
| 768 | def Func() |
| 769 | extend(list, ['x', 'b']) |
| 770 | enddef |
| 771 | Func() |
| 772 | assert_equal(['x', 'b'], list) |
| 773 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 774 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 775 | |
| 776 | lines =<< trim END |
| 777 | vim9script |
| 778 | var l: list<string> = test_null_list() |
| 779 | extend(l, ['x']) |
| 780 | assert_equal(['x'], l) |
| 781 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 782 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 783 | |
| 784 | lines =<< trim END |
| 785 | vim9script |
| 786 | extend(test_null_list(), ['x']) |
| 787 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 788 | v9.CheckScriptFailure(lines, 'E1134:', 2) |
Bram Moolenaar | 078a461 | 2022-01-04 15:17:03 +0000 | [diff] [blame] | 789 | |
| 790 | # using global var has no declared type |
| 791 | g:myList = [] |
| 792 | g:myList->extend([1]) |
| 793 | g:myList->extend(['x']) |
| 794 | assert_equal([1, 'x'], g:myList) |
| 795 | unlet g:myList |
| 796 | |
| 797 | # using declared list gives an error |
| 798 | lines =<< trim END |
| 799 | var l: list<number> |
| 800 | g:myList = l |
| 801 | g:myList->extend([1]) |
| 802 | g:myList->extend(['x']) |
| 803 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 804 | v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected list<number> but got list<string>', 4) |
Bram Moolenaar | 078a461 | 2022-01-04 15:17:03 +0000 | [diff] [blame] | 805 | unlet g:myList |
Bram Moolenaar | 160afdb | 2022-02-06 17:17:02 +0000 | [diff] [blame] | 806 | |
| 807 | lines =<< trim END |
| 808 | vim9script |
| 809 | var lds = [1, 2, 3] |
| 810 | def Func() |
| 811 | echo lds->extend(['x']) |
| 812 | enddef |
| 813 | defcompile |
| 814 | END |
| 815 | v9.CheckScriptFailure(lines, 'E1013:') |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 816 | enddef |
| 817 | |
| 818 | def Test_extend_dict() |
| 819 | var lines =<< trim END |
| 820 | vim9script |
| 821 | var d: dict<number> |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 822 | extend(d, {a: 1}) |
| 823 | assert_equal({a: 1}, d) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 824 | |
| 825 | var d2: dict<number> |
| 826 | d2['one'] = 1 |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 827 | assert_equal({one: 1}, d2) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 828 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 829 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 830 | |
| 831 | lines =<< trim END |
| 832 | vim9script |
| 833 | var d: dict<string> = test_null_dict() |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 834 | extend(d, {a: 'x'}) |
| 835 | assert_equal({a: 'x'}, d) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 836 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 837 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 838 | |
| 839 | lines =<< trim END |
| 840 | vim9script |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 841 | extend(test_null_dict(), {a: 'x'}) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 842 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 843 | v9.CheckScriptFailure(lines, 'E1133:', 2) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 844 | enddef |
| 845 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 846 | def Test_single_letter_vars() |
| 847 | # single letter variables |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 848 | var a: number = 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 849 | a = 123 |
| 850 | assert_equal(123, a) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 851 | var b: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 852 | b = 123 |
| 853 | assert_equal(123, b) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 854 | var g: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 855 | g = 123 |
| 856 | assert_equal(123, g) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 857 | var s: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 858 | s = 123 |
| 859 | assert_equal(123, s) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 860 | var t: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 861 | t = 123 |
| 862 | assert_equal(123, t) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 863 | var v: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 864 | v = 123 |
| 865 | assert_equal(123, v) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 866 | var w: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 867 | w = 123 |
| 868 | assert_equal(123, w) |
| 869 | enddef |
| 870 | |
| 871 | def Test_vim9_single_char_vars() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 872 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 873 | vim9script |
| 874 | |
| 875 | # single character variable declarations work |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 876 | var a: string |
| 877 | var b: number |
| 878 | var l: list<any> |
| 879 | var s: string |
| 880 | var t: number |
| 881 | var v: number |
| 882 | var w: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 883 | |
| 884 | # script-local variables can be used without s: prefix |
| 885 | a = 'script-a' |
| 886 | b = 111 |
| 887 | l = [1, 2, 3] |
| 888 | s = 'script-s' |
| 889 | t = 222 |
| 890 | v = 333 |
| 891 | w = 444 |
| 892 | |
| 893 | assert_equal('script-a', a) |
| 894 | assert_equal(111, b) |
| 895 | assert_equal([1, 2, 3], l) |
| 896 | assert_equal('script-s', s) |
| 897 | assert_equal(222, t) |
| 898 | assert_equal(333, v) |
| 899 | assert_equal(444, w) |
| 900 | END |
| 901 | writefile(lines, 'Xsinglechar') |
| 902 | source Xsinglechar |
| 903 | delete('Xsinglechar') |
| 904 | enddef |
| 905 | |
| 906 | def Test_assignment_list() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 907 | var list1: list<bool> = [false, true, false] |
| 908 | var list2: list<number> = [1, 2, 3] |
| 909 | var list3: list<string> = ['sdf', 'asdf'] |
| 910 | var list4: list<any> = ['yes', true, 1234] |
| 911 | var list5: list<blob> = [0z01, 0z02] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 912 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 913 | var listS: list<string> = [] |
| 914 | var listN: list<number> = [] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 915 | |
| 916 | assert_equal([1, 2, 3], list2) |
| 917 | list2[-1] = 99 |
| 918 | assert_equal([1, 2, 99], list2) |
| 919 | list2[-2] = 88 |
| 920 | assert_equal([1, 88, 99], list2) |
| 921 | list2[-3] = 77 |
| 922 | assert_equal([77, 88, 99], list2) |
| 923 | list2 += [100] |
| 924 | assert_equal([77, 88, 99, 100], list2) |
| 925 | |
| 926 | list3 += ['end'] |
| 927 | assert_equal(['sdf', 'asdf', 'end'], list3) |
| 928 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 929 | v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:') |
Bram Moolenaar | 6296d1e | 2022-02-17 16:30:11 +0000 | [diff] [blame] | 930 | v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[8 : 9]'], 'E684:') |
| 931 | v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[1 : -9]'], 'E684:') |
| 932 | v9.CheckDefExecFailure(['var ll = [1, 2, 3]', 'unlet ll[2 : 1]'], 'E684:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 933 | |
| 934 | # type becomes list<any> |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 935 | var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c'] |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 936 | |
Bram Moolenaar | 114dbda | 2022-01-03 12:28:03 +0000 | [diff] [blame] | 937 | # type is list<any> even though initializer is list<number> |
| 938 | var anyList: list<any> = [0] |
| 939 | assert_equal([0, 'x'], extend(anyList, ['x'])) |
| 940 | |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 941 | var lines =<< trim END |
| 942 | var d = {dd: test_null_list()} |
| 943 | d.dd[0] = 0 |
| 944 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 945 | v9.CheckDefExecFailure(lines, 'E1147:', 2) |
Bram Moolenaar | 7a40ff0 | 2021-07-04 15:54:08 +0200 | [diff] [blame] | 946 | |
| 947 | lines =<< trim END |
| 948 | def OneArg(x: bool) |
| 949 | enddef |
| 950 | def TwoArgs(x: bool, y: bool) |
| 951 | enddef |
| 952 | var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs] |
| 953 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 954 | v9.CheckDefExecAndScriptFailure(lines, 'E1012:', 5) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 955 | enddef |
| 956 | |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 957 | def Test_list_declaration() |
| 958 | var [v1, v2] = [1, 2] |
| 959 | v1 += 3 |
| 960 | assert_equal(4, v1) |
| 961 | v2 *= 3 |
| 962 | assert_equal(6, v2) |
| 963 | |
| 964 | var lines =<< trim END |
| 965 | var [v1, v2] = [1] |
| 966 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 967 | v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 968 | lines =<< trim END |
| 969 | var testlist = [1] |
| 970 | var [v1, v2] = testlist |
| 971 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 972 | v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 1', 'E688:']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 973 | lines =<< trim END |
| 974 | var [v1, v2] = [1, 2, 3] |
| 975 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 976 | v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 977 | lines =<< trim END |
| 978 | var testlist = [1, 2, 3] |
| 979 | var [v1, v2] = testlist |
| 980 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 981 | v9.CheckDefExecAndScriptFailure(lines, ['E1093: Expected 2 items but got 3', 'E687:']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 982 | |
| 983 | var [vnr, vstr] = [123, 'text'] |
| 984 | vnr += 3 |
| 985 | assert_equal(126, vnr) |
| 986 | vstr ..= 'end' |
| 987 | assert_equal('textend', vstr) |
| 988 | |
| 989 | var [vnr2: number, vstr2: string] = [123, 'text'] |
| 990 | vnr2 += 3 |
| 991 | assert_equal(126, vnr2) |
| 992 | vstr2 ..= 'end' |
| 993 | assert_equal('textend', vstr2) |
| 994 | |
| 995 | var [vnr3: number; vlist: list<string>] = [123, 'foo', 'bar'] |
| 996 | vnr3 += 5 |
| 997 | assert_equal(128, vnr3) |
| 998 | assert_equal(['foo', 'bar'], vlist) |
| 999 | |
| 1000 | lines =<< trim END |
| 1001 | var [vnr2: number, vstr2: number] = [123, 'text'] |
| 1002 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1003 | v9.CheckDefExecAndScriptFailure(lines, ['E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 1004 | lines =<< trim END |
| 1005 | var testlist = [234, 'text'] |
| 1006 | var [vnr2: number, vstr2: number] = testlist |
| 1007 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1008 | v9.CheckDefExecAndScriptFailure(lines, ['E1163: Variable 2: type mismatch, expected number but got string', 'E1012: Type mismatch; expected number but got string']) |
Bram Moolenaar | ab36e6a | 2021-11-30 16:14:49 +0000 | [diff] [blame] | 1009 | enddef |
| 1010 | |
Bram Moolenaar | 97f227d | 2021-07-04 20:20:52 +0200 | [diff] [blame] | 1011 | def PartFuncBool(b: bool): string |
Bram Moolenaar | b7480cd | 2021-07-04 18:28:15 +0200 | [diff] [blame] | 1012 | return 'done' |
| 1013 | enddef |
| 1014 | |
| 1015 | def Test_assignment_partial() |
Bram Moolenaar | 97f227d | 2021-07-04 20:20:52 +0200 | [diff] [blame] | 1016 | var lines =<< trim END |
Bram Moolenaar | 848fadd | 2022-01-30 15:28:30 +0000 | [diff] [blame] | 1017 | var Partial: func(): string = function(g:PartFuncBool, [true]) |
Bram Moolenaar | 97f227d | 2021-07-04 20:20:52 +0200 | [diff] [blame] | 1018 | assert_equal('done', Partial()) |
| 1019 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1020 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 22f85d0 | 2021-07-04 23:29:30 +0200 | [diff] [blame] | 1021 | |
| 1022 | lines =<< trim END |
| 1023 | vim9script |
| 1024 | def Func(b: bool) |
| 1025 | enddef |
| 1026 | var Ref: func = function(Func, [true]) |
| 1027 | assert_equal('func()', typename(Ref)) |
| 1028 | Ref() |
| 1029 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1030 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 13789bf | 2021-12-30 13:29:00 +0000 | [diff] [blame] | 1031 | |
| 1032 | lines =<< trim END |
| 1033 | vim9script |
| 1034 | |
| 1035 | var nres: any |
| 1036 | var sres: any |
Bram Moolenaar | 9a01511 | 2021-12-31 14:06:45 +0000 | [diff] [blame] | 1037 | def Func(nr: number, s = '') |
| 1038 | nres = nr |
Bram Moolenaar | 13789bf | 2021-12-30 13:29:00 +0000 | [diff] [blame] | 1039 | sres = s |
| 1040 | enddef |
| 1041 | |
| 1042 | var n: number |
| 1043 | var Ref = function(Func, [n]) |
| 1044 | Ref('x') |
| 1045 | assert_equal(0, nres) |
| 1046 | assert_equal('x', sres) |
| 1047 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1048 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 13789bf | 2021-12-30 13:29:00 +0000 | [diff] [blame] | 1049 | |
| 1050 | lines =<< trim END |
| 1051 | vim9script |
| 1052 | |
Bram Moolenaar | 9a01511 | 2021-12-31 14:06:45 +0000 | [diff] [blame] | 1053 | def Func(nr: number, s = '') |
Bram Moolenaar | 13789bf | 2021-12-30 13:29:00 +0000 | [diff] [blame] | 1054 | enddef |
| 1055 | |
| 1056 | var n: number |
| 1057 | var Ref = function(Func, [n]) |
| 1058 | Ref(0) |
| 1059 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1060 | v9.CheckScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected string but got number') |
Bram Moolenaar | b7480cd | 2021-07-04 18:28:15 +0200 | [diff] [blame] | 1061 | enddef |
| 1062 | |
Bram Moolenaar | f30a14d | 2021-01-17 21:51:24 +0100 | [diff] [blame] | 1063 | def Test_assignment_list_any_index() |
| 1064 | var l: list<number> = [1, 2] |
| 1065 | for [x, y, _] |
| 1066 | in [[0, 1, ''], [1, 3, '']] |
| 1067 | l[x] = l[x] + y |
| 1068 | endfor |
| 1069 | assert_equal([2, 5], l) |
| 1070 | enddef |
| 1071 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1072 | def Test_assignment_list_vim9script() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1073 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1074 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1075 | var v1: number |
| 1076 | var v2: number |
| 1077 | var v3: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1078 | [v1, v2, v3] = [1, 2, 3] |
| 1079 | assert_equal([1, 2, 3], [v1, v2, v3]) |
| 1080 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1081 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1082 | enddef |
| 1083 | |
| 1084 | def Test_assignment_dict() |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1085 | var dict1: dict<bool> = {one: false, two: true} |
| 1086 | var dict2: dict<number> = {one: 1, two: 2} |
| 1087 | var dict3: dict<string> = {key: 'value'} |
| 1088 | var dict4: dict<any> = {one: 1, two: '2'} |
| 1089 | var dict5: dict<blob> = {one: 0z01, two: 0z02} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1090 | |
| 1091 | # overwrite |
| 1092 | dict3['key'] = 'another' |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1093 | assert_equal(dict3, {key: 'another'}) |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 1094 | dict3.key = 'yet another' |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1095 | assert_equal(dict3, {key: 'yet another'}) |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 1096 | |
Bram Moolenaar | d24602f | 2020-12-20 15:20:56 +0100 | [diff] [blame] | 1097 | # member "any" can also be a dict and assigned to |
| 1098 | var anydict: dict<any> = {nest: {}, nr: 0} |
| 1099 | anydict.nest['this'] = 123 |
| 1100 | anydict.nest.that = 456 |
| 1101 | assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict) |
| 1102 | |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 1103 | var lines =<< trim END |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 1104 | var dd = {} |
| 1105 | dd.two = 2 |
| 1106 | assert_equal({two: 2}, dd) |
| 1107 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1108 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 1109 | |
| 1110 | lines =<< trim END |
| 1111 | var d = {dd: {}} |
| 1112 | d.dd[0] = 2 |
| 1113 | d.dd['x'] = 3 |
| 1114 | d.dd.y = 4 |
| 1115 | assert_equal({dd: {0: 2, x: 3, y: 4}}, d) |
| 1116 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1117 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 1118 | |
| 1119 | lines =<< trim END |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1120 | var dd = {one: 1} |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 1121 | dd.one) = 2 |
| 1122 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1123 | v9.CheckDefFailure(lines, 'E488:', 2) |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 1124 | |
| 1125 | lines =<< trim END |
| 1126 | var dd = {one: 1} |
| 1127 | var dd.one = 2 |
| 1128 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1129 | v9.CheckDefAndScriptFailure(lines, 'E1017:', 2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1130 | |
| 1131 | # empty key can be used |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1132 | var dd = {} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1133 | dd[""] = 6 |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1134 | assert_equal({['']: 6}, dd) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1135 | |
| 1136 | # type becomes dict<any> |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1137 | var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1138 | |
Bram Moolenaar | 114dbda | 2022-01-03 12:28:03 +0000 | [diff] [blame] | 1139 | # type is dict<any> even though initializer is dict<number> |
| 1140 | var anyDict: dict<any> = {a: 0} |
| 1141 | assert_equal({a: 0, b: 'x'}, extend(anyDict, {b: 'x'})) |
| 1142 | |
Bram Moolenaar | 078a461 | 2022-01-04 15:17:03 +0000 | [diff] [blame] | 1143 | # using global var, which has no declared type |
| 1144 | g:myDict = {} |
| 1145 | g:myDict->extend({a: 1}) |
| 1146 | g:myDict->extend({b: 'x'}) |
| 1147 | assert_equal({a: 1, b: 'x'}, g:myDict) |
| 1148 | unlet g:myDict |
| 1149 | |
| 1150 | # using list with declared type gives an error |
| 1151 | lines =<< trim END |
| 1152 | var d: dict<number> |
| 1153 | g:myDict = d |
| 1154 | g:myDict->extend({a: 1}) |
| 1155 | g:myDict->extend({b: 'x'}) |
| 1156 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1157 | v9.CheckDefExecAndScriptFailure(lines, 'E1013: Argument 2: type mismatch, expected dict<number> but got dict<string>', 4) |
Bram Moolenaar | 078a461 | 2022-01-04 15:17:03 +0000 | [diff] [blame] | 1158 | unlet g:myDict |
| 1159 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1160 | # assignment to script-local dict |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 1161 | lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1162 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1163 | var test: dict<any> = {} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1164 | def FillDict(): dict<any> |
| 1165 | test['a'] = 43 |
| 1166 | return test |
| 1167 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1168 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1169 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1170 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1171 | |
| 1172 | lines =<< trim END |
| 1173 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1174 | var test: dict<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1175 | def FillDict(): dict<any> |
| 1176 | test['a'] = 43 |
| 1177 | return test |
| 1178 | enddef |
| 1179 | FillDict() |
Bram Moolenaar | 3beaf9c | 2020-12-18 17:23:14 +0100 | [diff] [blame] | 1180 | assert_equal({a: 43}, test) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1181 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1182 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1183 | |
| 1184 | # assignment to global dict |
| 1185 | lines =<< trim END |
| 1186 | vim9script |
| 1187 | g:test = {} |
| 1188 | def FillDict(): dict<any> |
| 1189 | g:test['a'] = 43 |
| 1190 | return g:test |
| 1191 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1192 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1193 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1194 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1195 | |
| 1196 | # assignment to buffer dict |
| 1197 | lines =<< trim END |
| 1198 | vim9script |
| 1199 | b:test = {} |
| 1200 | def FillDict(): dict<any> |
| 1201 | b:test['a'] = 43 |
| 1202 | return b:test |
| 1203 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1204 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1205 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1206 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 1207 | |
| 1208 | lines =<< trim END |
| 1209 | var d = {dd: test_null_dict()} |
| 1210 | d.dd[0] = 0 |
| 1211 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1212 | v9.CheckDefExecFailure(lines, 'E1103:', 2) |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 1213 | |
| 1214 | lines =<< trim END |
| 1215 | var d = {dd: 'string'} |
| 1216 | d.dd[0] = 0 |
| 1217 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1218 | v9.CheckDefExecFailure(lines, 'E1148:', 2) |
Bram Moolenaar | 3a3b10e | 2021-06-26 15:00:59 +0200 | [diff] [blame] | 1219 | |
| 1220 | lines =<< trim END |
| 1221 | var n: any |
| 1222 | n.key = 5 |
| 1223 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1224 | v9.CheckDefExecAndScriptFailure(lines, ['E1148:', 'E1203: Dot can only be used on a dictionary: n.key = 5'], 2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1225 | enddef |
| 1226 | |
| 1227 | def Test_assignment_local() |
| 1228 | # Test in a separated file in order not to the current buffer/window/tab is |
| 1229 | # changed. |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1230 | var script_lines: list<string> =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1231 | let b:existing = 'yes' |
| 1232 | let w:existing = 'yes' |
| 1233 | let t:existing = 'yes' |
| 1234 | |
| 1235 | def Test_assignment_local_internal() |
| 1236 | b:newvar = 'new' |
| 1237 | assert_equal('new', b:newvar) |
| 1238 | assert_equal('yes', b:existing) |
| 1239 | b:existing = 'no' |
| 1240 | assert_equal('no', b:existing) |
| 1241 | b:existing ..= 'NO' |
| 1242 | assert_equal('noNO', b:existing) |
| 1243 | |
| 1244 | w:newvar = 'new' |
| 1245 | assert_equal('new', w:newvar) |
| 1246 | assert_equal('yes', w:existing) |
| 1247 | w:existing = 'no' |
| 1248 | assert_equal('no', w:existing) |
| 1249 | w:existing ..= 'NO' |
| 1250 | assert_equal('noNO', w:existing) |
| 1251 | |
| 1252 | t:newvar = 'new' |
| 1253 | assert_equal('new', t:newvar) |
| 1254 | assert_equal('yes', t:existing) |
| 1255 | t:existing = 'no' |
| 1256 | assert_equal('no', t:existing) |
| 1257 | t:existing ..= 'NO' |
| 1258 | assert_equal('noNO', t:existing) |
| 1259 | enddef |
| 1260 | call Test_assignment_local_internal() |
| 1261 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1262 | v9.CheckScriptSuccess(script_lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1263 | enddef |
| 1264 | |
| 1265 | def Test_assignment_default() |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1266 | # Test default values. |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1267 | var thebool: bool |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1268 | assert_equal(v:false, thebool) |
| 1269 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1270 | var thenumber: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1271 | assert_equal(0, thenumber) |
| 1272 | |
| 1273 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1274 | var thefloat: float |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1275 | assert_equal(0.0, thefloat) |
| 1276 | endif |
| 1277 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1278 | var thestring: string |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1279 | assert_equal('', thestring) |
| 1280 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1281 | var theblob: blob |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1282 | assert_equal(0z, theblob) |
| 1283 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1284 | var Thefunc: func |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1285 | assert_equal(test_null_function(), Thefunc) |
| 1286 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1287 | var thelist: list<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1288 | assert_equal([], thelist) |
| 1289 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1290 | var thedict: dict<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1291 | assert_equal({}, thedict) |
| 1292 | |
| 1293 | if has('channel') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1294 | var thejob: job |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1295 | assert_equal(test_null_job(), thejob) |
| 1296 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1297 | var thechannel: channel |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1298 | assert_equal(test_null_channel(), thechannel) |
| 1299 | |
| 1300 | if has('unix') && executable('cat') |
| 1301 | # check with non-null job and channel, types must match |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1302 | thejob = job_start("cat ", {}) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1303 | thechannel = job_getchannel(thejob) |
| 1304 | job_stop(thejob, 'kill') |
| 1305 | endif |
| 1306 | endif |
| 1307 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1308 | var nr = 1234 | nr = 5678 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1309 | assert_equal(5678, nr) |
| 1310 | enddef |
| 1311 | |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1312 | def Test_script_var_default() |
| 1313 | var lines =<< trim END |
| 1314 | vim9script |
| 1315 | var l: list<number> |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1316 | var li = [1, 2] |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1317 | var bl: blob |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1318 | var bli = 0z12 |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1319 | var d: dict<number> |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1320 | var di = {'a': 1, 'b': 2} |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1321 | def Echo() |
| 1322 | assert_equal([], l) |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1323 | assert_equal([1, 2], li) |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1324 | assert_equal(0z, bl) |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1325 | assert_equal(0z12, bli) |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1326 | assert_equal({}, d) |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1327 | assert_equal({'a': 1, 'b': 2}, di) |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1328 | enddef |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 1329 | Echo() |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 1330 | END |
| 1331 | v9.CheckScriptSuccess(lines) |
| 1332 | enddef |
| 1333 | |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1334 | let s:scriptvar = 'init' |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1335 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1336 | def Test_assignment_var_list() |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1337 | var lines =<< trim END |
| 1338 | var v1: string |
| 1339 | var v2: string |
| 1340 | var vrem: list<string> |
| 1341 | [v1] = ['aaa'] |
| 1342 | assert_equal('aaa', v1) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1343 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1344 | [v1, v2] = ['one', 'two'] |
| 1345 | assert_equal('one', v1) |
| 1346 | assert_equal('two', v2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1347 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1348 | [v1, v2; vrem] = ['one', 'two'] |
| 1349 | assert_equal('one', v1) |
| 1350 | assert_equal('two', v2) |
| 1351 | assert_equal([], vrem) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1352 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1353 | [v1, v2; vrem] = ['one', 'two', 'three'] |
| 1354 | assert_equal('one', v1) |
| 1355 | assert_equal('two', v2) |
| 1356 | assert_equal(['three'], vrem) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1357 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1358 | [&ts, &sw] = [3, 4] |
| 1359 | assert_equal(3, &ts) |
| 1360 | assert_equal(4, &sw) |
| 1361 | set ts=8 sw=4 |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 1362 | |
| 1363 | [@a, @z] = ['aa', 'zz'] |
| 1364 | assert_equal('aa', @a) |
| 1365 | assert_equal('zz', @z) |
| 1366 | |
| 1367 | [$SOME_VAR, $OTHER_VAR] = ['some', 'other'] |
| 1368 | assert_equal('some', $SOME_VAR) |
| 1369 | assert_equal('other', $OTHER_VAR) |
| 1370 | |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1371 | [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] = |
| 1372 | ['global', 'buf', 'win', 'tab', 'error'] |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 1373 | assert_equal('global', g:globalvar) |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 1374 | assert_equal('buf', b:bufvar) |
| 1375 | assert_equal('win', w:winvar) |
| 1376 | assert_equal('tab', t:tabvar) |
| 1377 | assert_equal('error', v:errmsg) |
| 1378 | unlet g:globalvar |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 1379 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1380 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1381 | |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1382 | [g:globalvar, scriptvar, b:bufvar] = ['global', 'script', 'buf'] |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1383 | assert_equal('global', g:globalvar) |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1384 | assert_equal('script', scriptvar) |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1385 | assert_equal('buf', b:bufvar) |
| 1386 | |
| 1387 | lines =<< trim END |
| 1388 | vim9script |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1389 | var scriptvar = 'init' |
| 1390 | [g:globalvar, scriptvar, w:winvar] = ['global', 'script', 'win'] |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1391 | assert_equal('global', g:globalvar) |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1392 | assert_equal('script', scriptvar) |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1393 | assert_equal('win', w:winvar) |
| 1394 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1395 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1396 | enddef |
| 1397 | |
Bram Moolenaar | 2d3ac2e | 2022-02-03 12:34:05 +0000 | [diff] [blame] | 1398 | def Test_assignment_empty_list() |
| 1399 | var lines =<< trim END |
| 1400 | var l2: list<any> = [] |
| 1401 | var l: list<string> |
| 1402 | l = l2 |
| 1403 | END |
| 1404 | v9.CheckDefAndScriptSuccess(lines) |
| 1405 | enddef |
| 1406 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1407 | def Test_assignment_vim9script() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1408 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1409 | vim9script |
| 1410 | def Func(): list<number> |
| 1411 | return [1, 2] |
| 1412 | enddef |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1413 | var name1: number |
| 1414 | var name2: number |
| 1415 | [name1, name2] = |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1416 | Func() |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1417 | assert_equal(1, name1) |
| 1418 | assert_equal(2, name2) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1419 | var ll = |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1420 | Func() |
| 1421 | assert_equal([1, 2], ll) |
| 1422 | |
| 1423 | @/ = 'text' |
| 1424 | assert_equal('text', @/) |
| 1425 | @0 = 'zero' |
| 1426 | assert_equal('zero', @0) |
| 1427 | @1 = 'one' |
| 1428 | assert_equal('one', @1) |
| 1429 | @9 = 'nine' |
| 1430 | assert_equal('nine', @9) |
| 1431 | @- = 'minus' |
| 1432 | assert_equal('minus', @-) |
| 1433 | if has('clipboard_working') |
| 1434 | @* = 'star' |
| 1435 | assert_equal('star', @*) |
| 1436 | @+ = 'plus' |
| 1437 | assert_equal('plus', @+) |
| 1438 | endif |
| 1439 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1440 | var a: number = 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1441 | assert_equal(123, a) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1442 | var s: string = 'yes' |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1443 | assert_equal('yes', s) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1444 | var b: number = 42 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1445 | assert_equal(42, b) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1446 | var w: number = 43 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1447 | assert_equal(43, w) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1448 | var t: number = 44 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1449 | assert_equal(44, t) |
Bram Moolenaar | 7a66a17 | 2020-10-16 19:56:12 +0200 | [diff] [blame] | 1450 | |
| 1451 | var to_var = 0 |
| 1452 | to_var = 3 |
| 1453 | assert_equal(3, to_var) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1454 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1455 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 06f9c69 | 2020-09-27 21:27:40 +0200 | [diff] [blame] | 1456 | |
| 1457 | lines =<< trim END |
| 1458 | vim9script |
| 1459 | var n: number |
| 1460 | def Func() |
| 1461 | n = 'string' |
| 1462 | enddef |
| 1463 | defcompile |
| 1464 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1465 | v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1466 | enddef |
| 1467 | |
| 1468 | def Mess(): string |
| 1469 | v:foldstart = 123 |
| 1470 | return 'xxx' |
| 1471 | enddef |
| 1472 | |
| 1473 | def Test_assignment_failure() |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1474 | v9.CheckDefFailure(['var name=234'], 'E1004:') |
| 1475 | v9.CheckDefFailure(['var name =234'], 'E1004:') |
| 1476 | v9.CheckDefFailure(['var name= 234'], 'E1004:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1477 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1478 | v9.CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:') |
| 1479 | v9.CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='") |
| 1480 | v9.CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:') |
| 1481 | v9.CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:') |
| 1482 | v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:') |
| 1483 | v9.CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='") |
| 1484 | v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:') |
| 1485 | v9.CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='") |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1486 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1487 | v9.CheckDefFailure(['var true = 1'], 'E1034:') |
| 1488 | v9.CheckDefFailure(['var false = 1'], 'E1034:') |
| 1489 | v9.CheckDefFailure(['var null = 1'], 'E1034:') |
| 1490 | v9.CheckDefFailure(['var this = 1'], 'E1034:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1491 | |
Bram Moolenaar | 8b716f5 | 2022-02-15 21:17:56 +0000 | [diff] [blame] | 1492 | v9.CheckDefFailure(['[a; b; c] = g:list'], 'E1001:') |
| 1493 | v9.CheckDefFailure(['var [a; b; c] = g:list'], 'E1080:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1494 | v9.CheckDefExecFailure(['var a: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1495 | '[a] = test_null_list()'], 'E1093:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1496 | v9.CheckDefExecFailure(['var a: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1497 | '[a] = []'], 'E1093:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1498 | v9.CheckDefExecFailure(['var x: number', |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1499 | 'var y: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1500 | '[x, y] = [1]'], 'E1093:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1501 | v9.CheckDefExecFailure(['var x: string', |
Bram Moolenaar | 352134b | 2020-10-17 22:04:08 +0200 | [diff] [blame] | 1502 | 'var y: string', |
| 1503 | '[x, y] = ["x"]'], 'E1093:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1504 | v9.CheckDefExecFailure(['var x: number', |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1505 | 'var y: number', |
| 1506 | 'var z: list<number>', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1507 | '[x, y; z] = [1]'], 'E1093:') |
| 1508 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1509 | v9.CheckDefFailure(['var somevar'], "E1022:") |
| 1510 | v9.CheckDefFailure(['var &tabstop = 4'], 'E1052:') |
| 1511 | v9.CheckDefFailure(['&g:option = 5'], 'E113:') |
| 1512 | v9.CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1513 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1514 | v9.CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:') |
| 1515 | v9.CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1516 | |
| 1517 | if has('dnd') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1518 | v9.CheckDefFailure(['var @~ = 5'], 'E1066:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1519 | else |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1520 | v9.CheckDefFailure(['var @~ = 5'], 'E354:') |
| 1521 | v9.CheckDefFailure(['@~ = 5'], 'E354:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1522 | endif |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1523 | v9.CheckDefFailure(['var @a = 5'], 'E1066:') |
| 1524 | v9.CheckDefFailure(['var @/ = "x"'], 'E1066:') |
| 1525 | v9.CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1526 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1527 | v9.CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:') |
| 1528 | v9.CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:') |
| 1529 | v9.CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:') |
| 1530 | v9.CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1531 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1532 | v9.CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:') |
| 1533 | v9.CheckDefFailure(['var xnr += 4'], 'E1020:', 1) |
| 1534 | v9.CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:') |
| 1535 | v9.CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1) |
| 1536 | v9.CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1537 | |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1538 | v9.CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = notfound', 'enddef', 'defcompile'], 'E1001:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1539 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1540 | v9.CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>') |
| 1541 | v9.CheckDefFailure(['var name: list<number> = ["xx"]'], 'expected list<number> but got list<string>') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1542 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1543 | v9.CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>') |
| 1544 | v9.CheckDefFailure(['var name: dict<number> = {key: "xx"}'], 'expected dict<number> but got dict<string>') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1545 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1546 | v9.CheckDefFailure(['var name = feedkeys("0")'], 'E1031:') |
| 1547 | v9.CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1548 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1549 | v9.CheckDefFailure(['var name: dict <number>'], 'E1068:') |
| 1550 | v9.CheckDefFailure(['var name: dict<number'], 'E1009:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1551 | |
Bram Moolenaar | 848fadd | 2022-01-30 15:28:30 +0000 | [diff] [blame] | 1552 | assert_fails('s/^/\=g:Mess()/n', 'E794:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1553 | v9.CheckDefFailure(['var name: dict<number'], 'E1009:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1554 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1555 | v9.CheckDefFailure(['w:foo: number = 10'], |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1556 | 'E488: Trailing characters: : number = 1') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1557 | v9.CheckDefFailure(['t:foo: bool = true'], |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1558 | 'E488: Trailing characters: : bool = true') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1559 | v9.CheckDefFailure(['b:foo: string = "x"'], |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1560 | 'E488: Trailing characters: : string = "x"') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1561 | v9.CheckDefFailure(['g:foo: number = 123'], |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1562 | 'E488: Trailing characters: : number = 123') |
| 1563 | enddef |
| 1564 | |
| 1565 | def Test_assign_list() |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1566 | var lines =<< trim END |
| 1567 | var l: list<string> = [] |
| 1568 | l[0] = 'value' |
| 1569 | assert_equal('value', l[0]) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1570 | |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1571 | l[1] = 'asdf' |
| 1572 | assert_equal('value', l[0]) |
| 1573 | assert_equal('asdf', l[1]) |
| 1574 | assert_equal('asdf', l[-1]) |
| 1575 | assert_equal('value', l[-2]) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1576 | |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1577 | var nrl: list<number> = [] |
| 1578 | for i in range(5) |
| 1579 | nrl[i] = i |
| 1580 | endfor |
| 1581 | assert_equal([0, 1, 2, 3, 4], nrl) |
| 1582 | |
| 1583 | var ul: list<any> |
| 1584 | ul[0] = 1 |
| 1585 | ul[1] = 2 |
| 1586 | ul[2] = 3 |
| 1587 | assert_equal([1, 2, 3], ul) |
| 1588 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1589 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 334a8b4 | 2020-10-19 16:07:42 +0200 | [diff] [blame] | 1590 | |
Bram Moolenaar | 1983f1a | 2022-02-28 20:55:02 +0000 | [diff] [blame] | 1591 | lines =<< trim END |
| 1592 | var l = [1, 2] |
| 1593 | g:idx = 'x' |
| 1594 | l[g:idx : 1] = [0] |
| 1595 | echo l |
| 1596 | END |
| 1597 | v9.CheckDefExecAndScriptFailure(lines, 'E1030: Using a String as a Number: "x"') |
| 1598 | |
| 1599 | lines =<< trim END |
| 1600 | var l = [1, 2] |
| 1601 | g:idx = 3 |
| 1602 | l[g:idx : 1] = [0] |
| 1603 | echo l |
| 1604 | END |
| 1605 | v9.CheckDefExecAndScriptFailure(lines, 'E684: list index out of range: 3') |
| 1606 | |
| 1607 | lines =<< trim END |
| 1608 | var l = [1, 2] |
| 1609 | g:idx = 'y' |
| 1610 | l[1 : g:idx] = [0] |
| 1611 | echo l |
| 1612 | END |
| 1613 | v9.CheckDefExecAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "y"']) |
| 1614 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1615 | v9.CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1) |
| 1616 | v9.CheckDefFailure(["var l: list<list<number>> = [['', true]]"], 'E1012: Type mismatch; expected list<list<number>> but got list<list<any>>', 1) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1617 | enddef |
| 1618 | |
| 1619 | def Test_assign_dict() |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1620 | var lines =<< trim END |
| 1621 | var d: dict<string> = {} |
| 1622 | d['key'] = 'value' |
| 1623 | assert_equal('value', d['key']) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1624 | |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1625 | d[123] = 'qwerty' |
| 1626 | assert_equal('qwerty', d[123]) |
| 1627 | assert_equal('qwerty', d['123']) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1628 | |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1629 | var nrd: dict<number> = {} |
| 1630 | for i in range(3) |
| 1631 | nrd[i] = i |
| 1632 | endfor |
| 1633 | assert_equal({0: 0, 1: 1, 2: 2}, nrd) |
| 1634 | |
| 1635 | d.somekey = 'someval' |
| 1636 | assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d) |
Bram Moolenaar | 23e2e11 | 2021-08-03 21:16:18 +0200 | [diff] [blame] | 1637 | unlet d.somekey |
| 1638 | assert_equal({key: 'value', '123': 'qwerty'}, d) |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1639 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1640 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1641 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1642 | v9.CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1) |
| 1643 | v9.CheckDefFailure(["var d: dict<dict<number>> = {x: {a: '', b: true}}"], 'E1012: Type mismatch; expected dict<dict<number>> but got dict<dict<any>>', 1) |
Bram Moolenaar | bc51006 | 2022-02-14 21:19:04 +0000 | [diff] [blame] | 1644 | v9.CheckDefFailure(["var d = {x: 1}", "d[1 : 2] = {y: 2}"], 'E1165: Cannot use a range with an assignment: d[1 : 2] =', 2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1645 | enddef |
| 1646 | |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1647 | def Test_assign_dict_unknown_type() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1648 | var lines =<< trim END |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1649 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1650 | var mylist = [] |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1651 | mylist += [{one: 'one'}] |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1652 | def Func() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1653 | var dd = mylist[0] |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1654 | assert_equal('one', dd.one) |
| 1655 | enddef |
| 1656 | Func() |
| 1657 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1658 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1659 | |
Bram Moolenaar | ce2c544 | 2020-11-28 21:21:17 +0100 | [diff] [blame] | 1660 | lines =<< trim END |
| 1661 | vim9script |
| 1662 | var mylist = [[]] |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1663 | mylist[0] += [{one: 'one'}] |
Bram Moolenaar | ce2c544 | 2020-11-28 21:21:17 +0100 | [diff] [blame] | 1664 | def Func() |
| 1665 | var dd = mylist[0][0] |
| 1666 | assert_equal('one', dd.one) |
| 1667 | enddef |
| 1668 | Func() |
| 1669 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1670 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1671 | enddef |
| 1672 | |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1673 | def Test_assign_dict_with_op() |
| 1674 | var lines =<< trim END |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1675 | var ds: dict<string> = {a: 'x'} |
| 1676 | ds['a'] ..= 'y' |
| 1677 | ds.a ..= 'z' |
| 1678 | assert_equal('xyz', ds.a) |
| 1679 | |
| 1680 | var dn: dict<number> = {a: 9} |
| 1681 | dn['a'] += 2 |
| 1682 | assert_equal(11, dn.a) |
| 1683 | dn.a += 2 |
| 1684 | assert_equal(13, dn.a) |
| 1685 | |
| 1686 | dn['a'] -= 3 |
| 1687 | assert_equal(10, dn.a) |
| 1688 | dn.a -= 2 |
| 1689 | assert_equal(8, dn.a) |
| 1690 | |
| 1691 | dn['a'] *= 2 |
| 1692 | assert_equal(16, dn.a) |
| 1693 | dn.a *= 2 |
| 1694 | assert_equal(32, dn.a) |
| 1695 | |
| 1696 | dn['a'] /= 3 |
| 1697 | assert_equal(10, dn.a) |
| 1698 | dn.a /= 2 |
| 1699 | assert_equal(5, dn.a) |
| 1700 | |
| 1701 | dn['a'] %= 3 |
| 1702 | assert_equal(2, dn.a) |
| 1703 | dn.a %= 6 |
| 1704 | assert_equal(2, dn.a) |
Bram Moolenaar | b9c0cd8 | 2021-04-05 20:51:00 +0200 | [diff] [blame] | 1705 | |
| 1706 | var dd: dict<dict<list<any>>> |
| 1707 | dd.a = {} |
| 1708 | dd.a.b = [0] |
| 1709 | dd.a.b += [1] |
| 1710 | assert_equal({a: {b: [0, 1]}}, dd) |
Bram Moolenaar | 0d351a0 | 2021-04-05 21:05:26 +0200 | [diff] [blame] | 1711 | |
| 1712 | var dab = {a: ['b']} |
| 1713 | dab.a[0] ..= 'c' |
| 1714 | assert_equal({a: ['bc']}, dab) |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1715 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1716 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | e42939a | 2021-04-05 17:11:17 +0200 | [diff] [blame] | 1717 | enddef |
| 1718 | |
| 1719 | def Test_assign_list_with_op() |
| 1720 | var lines =<< trim END |
| 1721 | var ls: list<string> = ['x'] |
| 1722 | ls[0] ..= 'y' |
| 1723 | assert_equal('xy', ls[0]) |
| 1724 | |
| 1725 | var ln: list<number> = [9] |
| 1726 | ln[0] += 2 |
| 1727 | assert_equal(11, ln[0]) |
| 1728 | |
| 1729 | ln[0] -= 3 |
| 1730 | assert_equal(8, ln[0]) |
| 1731 | |
| 1732 | ln[0] *= 2 |
| 1733 | assert_equal(16, ln[0]) |
| 1734 | |
| 1735 | ln[0] /= 3 |
| 1736 | assert_equal(5, ln[0]) |
| 1737 | |
| 1738 | ln[0] %= 3 |
| 1739 | assert_equal(2, ln[0]) |
| 1740 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1741 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | e42939a | 2021-04-05 17:11:17 +0200 | [diff] [blame] | 1742 | enddef |
| 1743 | |
| 1744 | def Test_assign_with_op_fails() |
| 1745 | var lines =<< trim END |
| 1746 | var s = 'abc' |
| 1747 | s[1] += 'x' |
| 1748 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1749 | v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2) |
Bram Moolenaar | e42939a | 2021-04-05 17:11:17 +0200 | [diff] [blame] | 1750 | |
| 1751 | lines =<< trim END |
| 1752 | var s = 'abc' |
| 1753 | s[1] ..= 'x' |
| 1754 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1755 | v9.CheckDefAndScriptFailure(lines, ['E1141:', 'E689:'], 2) |
Bram Moolenaar | b9c0cd8 | 2021-04-05 20:51:00 +0200 | [diff] [blame] | 1756 | |
| 1757 | lines =<< trim END |
| 1758 | var dd: dict<dict<list<any>>> |
| 1759 | dd.a = {} |
| 1760 | dd.a.b += [1] |
| 1761 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1762 | v9.CheckDefExecAndScriptFailure(lines, 'E716:', 3) |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1763 | enddef |
| 1764 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1765 | def Test_assign_lambda() |
| 1766 | # check if assign a lambda to a variable which type is func or any. |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1767 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1768 | vim9script |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1769 | var FuncRef = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1770 | assert_equal(123, FuncRef()) |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1771 | var FuncRef_Func: func = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1772 | assert_equal(123, FuncRef_Func()) |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1773 | var FuncRef_Any: any = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1774 | assert_equal(123, FuncRef_Any()) |
Bram Moolenaar | 0640950 | 2021-02-17 17:00:27 +0100 | [diff] [blame] | 1775 | var FuncRef_Number: func(): number = () => 321 |
| 1776 | assert_equal(321, FuncRef_Number()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1777 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1778 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 328eac2 | 2021-01-07 19:23:08 +0100 | [diff] [blame] | 1779 | |
| 1780 | lines =<< trim END |
| 1781 | var Ref: func(number) |
| 1782 | Ref = (j) => !j |
| 1783 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1784 | v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected func(number) but got func(any): bool') |
Bram Moolenaar | c7dac85 | 2021-02-17 18:49:11 +0100 | [diff] [blame] | 1785 | |
| 1786 | lines =<< trim END |
| 1787 | echo filter([1, 2, 3], (_, v: string) => v + 1) |
| 1788 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1789 | v9.CheckDefAndScriptFailure(lines, 'E1051:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1790 | enddef |
| 1791 | |
Bram Moolenaar | c0e2901 | 2020-09-27 14:22:48 +0200 | [diff] [blame] | 1792 | def Test_heredoc() |
| 1793 | var lines =<< trim END # comment |
| 1794 | text |
| 1795 | END |
| 1796 | assert_equal(['text'], lines) |
| 1797 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1798 | v9.CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:') |
| 1799 | v9.CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:') |
Bram Moolenaar | 2914a20 | 2020-09-27 18:24:03 +0200 | [diff] [blame] | 1800 | |
| 1801 | lines =<< trim [END] |
| 1802 | def Func() |
| 1803 | var&lines =<< trim END |
| 1804 | x |
| 1805 | x |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 1806 | enddef |
| 1807 | defcompile |
| 1808 | [END] |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1809 | v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END') |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 1810 | delfunc! g:Func |
| 1811 | |
| 1812 | lines =<< trim [END] |
| 1813 | def Func() |
| 1814 | var lines =<< trim END |
| 1815 | x |
| 1816 | x |
Bram Moolenaar | 2914a20 | 2020-09-27 18:24:03 +0200 | [diff] [blame] | 1817 | x |
| 1818 | x |
| 1819 | x |
| 1820 | x |
| 1821 | x |
| 1822 | x |
| 1823 | enddef |
| 1824 | call Func() |
| 1825 | [END] |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1826 | v9.CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END') |
Bram Moolenaar | 2d870f8 | 2020-12-05 13:41:01 +0100 | [diff] [blame] | 1827 | delfunc! g:Func |
Bram Moolenaar | 81530e3 | 2021-07-28 21:25:49 +0200 | [diff] [blame] | 1828 | |
| 1829 | lines =<< trim END |
| 1830 | var lines: number =<< trim STOP |
| 1831 | aaa |
| 1832 | bbb |
| 1833 | STOP |
| 1834 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1835 | v9.CheckDefAndScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<string>', 1) |
Bram Moolenaar | c0e2901 | 2020-09-27 14:22:48 +0200 | [diff] [blame] | 1836 | enddef |
| 1837 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1838 | def Test_var_func_call() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1839 | var lines =<< trim END |
| 1840 | vim9script |
| 1841 | func GetValue() |
| 1842 | if exists('g:count') |
| 1843 | let g:count += 1 |
| 1844 | else |
| 1845 | let g:count = 1 |
| 1846 | endif |
| 1847 | return 'this' |
| 1848 | endfunc |
| 1849 | var val: string = GetValue() |
| 1850 | # env var is always a string |
| 1851 | var env = $TERM |
| 1852 | END |
| 1853 | writefile(lines, 'Xfinished') |
| 1854 | source Xfinished |
| 1855 | # GetValue() is not called during discovery phase |
| 1856 | assert_equal(1, g:count) |
| 1857 | |
| 1858 | unlet g:count |
| 1859 | delete('Xfinished') |
| 1860 | enddef |
| 1861 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1862 | def Test_var_missing_type() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1863 | var lines =<< trim END |
| 1864 | vim9script |
| 1865 | var name = g:unknown |
| 1866 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1867 | v9.CheckScriptFailure(lines, 'E121:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1868 | |
| 1869 | lines =<< trim END |
| 1870 | vim9script |
| 1871 | var nr: number = 123 |
| 1872 | var name = nr |
| 1873 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1874 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1875 | enddef |
| 1876 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1877 | def Test_var_declaration() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1878 | var lines =<< trim END |
| 1879 | vim9script |
| 1880 | var name: string |
| 1881 | g:var_uninit = name |
| 1882 | name = 'text' |
| 1883 | g:var_test = name |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1884 | # prefixing s: is not allowed |
| 1885 | name = 'prefixed' |
| 1886 | g:var_prefixed = name |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1887 | |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 1888 | const FOO: number = 123 |
| 1889 | assert_equal(123, FOO) |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1890 | const FOOS = 'foos' |
| 1891 | assert_equal('foos', FOOS) |
| 1892 | final FLIST = [1] |
| 1893 | assert_equal([1], FLIST) |
| 1894 | FLIST[0] = 11 |
| 1895 | assert_equal([11], FLIST) |
| 1896 | |
| 1897 | const g:FOO: number = 321 |
| 1898 | assert_equal(321, g:FOO) |
| 1899 | const g:FOOS = 'gfoos' |
| 1900 | assert_equal('gfoos', g:FOOS) |
| 1901 | final g:FLIST = [2] |
| 1902 | assert_equal([2], g:FLIST) |
| 1903 | g:FLIST[0] = 22 |
| 1904 | assert_equal([22], g:FLIST) |
| 1905 | |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 1906 | def SetGlobalConst() |
| 1907 | const g:globConst = 123 |
| 1908 | enddef |
| 1909 | SetGlobalConst() |
| 1910 | assert_equal(123, g:globConst) |
| 1911 | assert_true(islocked('g:globConst')) |
| 1912 | |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1913 | const w:FOO: number = 46 |
| 1914 | assert_equal(46, w:FOO) |
| 1915 | const w:FOOS = 'wfoos' |
| 1916 | assert_equal('wfoos', w:FOOS) |
| 1917 | final w:FLIST = [3] |
| 1918 | assert_equal([3], w:FLIST) |
| 1919 | w:FLIST[0] = 33 |
| 1920 | assert_equal([33], w:FLIST) |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 1921 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1922 | var s:other: number |
| 1923 | other = 1234 |
| 1924 | g:other_var = other |
| 1925 | |
Bram Moolenaar | ccc25aa | 2021-03-26 21:27:52 +0100 | [diff] [blame] | 1926 | var xyz: string # comment |
| 1927 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1928 | # type is inferred |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1929 | var dict = {['a']: 222} |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1930 | def GetDictVal(key: any) |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 1931 | g:dict_val = dict[key] |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1932 | enddef |
| 1933 | GetDictVal('a') |
Bram Moolenaar | 0825175 | 2021-01-11 21:20:18 +0100 | [diff] [blame] | 1934 | |
| 1935 | final adict: dict<string> = {} |
| 1936 | def ChangeAdict() |
| 1937 | adict.foo = 'foo' |
| 1938 | enddef |
| 1939 | ChangeAdict() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1940 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1941 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1942 | assert_equal('', g:var_uninit) |
| 1943 | assert_equal('text', g:var_test) |
| 1944 | assert_equal('prefixed', g:var_prefixed) |
| 1945 | assert_equal(1234, g:other_var) |
| 1946 | assert_equal(222, g:dict_val) |
| 1947 | |
| 1948 | unlet g:var_uninit |
| 1949 | unlet g:var_test |
| 1950 | unlet g:var_prefixed |
| 1951 | unlet g:other_var |
Bram Moolenaar | 6e50ec2 | 2021-04-03 19:32:44 +0200 | [diff] [blame] | 1952 | unlet g:globConst |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1953 | unlet g:FOO |
| 1954 | unlet g:FOOS |
| 1955 | unlet g:FLIST |
| 1956 | unlet w:FOO |
| 1957 | unlet w:FOOS |
| 1958 | unlet w:FLIST |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1959 | enddef |
| 1960 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1961 | def Test_var_declaration_fails() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1962 | var lines =<< trim END |
| 1963 | vim9script |
| 1964 | final var: string |
| 1965 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1966 | v9.CheckScriptFailure(lines, 'E1125:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1967 | |
| 1968 | lines =<< trim END |
| 1969 | vim9script |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1970 | const g:constvar = 'string' |
| 1971 | g:constvar = 'xx' |
| 1972 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1973 | v9.CheckScriptFailure(lines, 'E741:') |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1974 | unlet g:constvar |
| 1975 | |
| 1976 | lines =<< trim END |
| 1977 | vim9script |
Bram Moolenaar | f5906aa | 2021-04-02 14:35:15 +0200 | [diff] [blame] | 1978 | var name = 'one' |
| 1979 | lockvar name |
| 1980 | def SetLocked() |
| 1981 | name = 'two' |
| 1982 | enddef |
| 1983 | SetLocked() |
| 1984 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1985 | v9.CheckScriptFailure(lines, 'E741: Value is locked: name', 1) |
Bram Moolenaar | dcf29ac | 2021-04-02 14:44:02 +0200 | [diff] [blame] | 1986 | |
| 1987 | lines =<< trim END |
| 1988 | let s:legacy = 'one' |
| 1989 | lockvar s:legacy |
| 1990 | def SetLocked() |
| 1991 | s:legacy = 'two' |
| 1992 | enddef |
| 1993 | call SetLocked() |
| 1994 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 1995 | v9.CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1) |
Bram Moolenaar | f5906aa | 2021-04-02 14:35:15 +0200 | [diff] [blame] | 1996 | |
| 1997 | lines =<< trim END |
| 1998 | vim9script |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 1999 | def SetGlobalConst() |
| 2000 | const g:globConst = 123 |
| 2001 | enddef |
| 2002 | SetGlobalConst() |
| 2003 | g:globConst = 234 |
| 2004 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2005 | v9.CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6) |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 2006 | unlet g:globConst |
| 2007 | |
| 2008 | lines =<< trim END |
| 2009 | vim9script |
Bram Moolenaar | 0825175 | 2021-01-11 21:20:18 +0100 | [diff] [blame] | 2010 | const cdict: dict<string> = {} |
| 2011 | def Change() |
| 2012 | cdict.foo = 'foo' |
| 2013 | enddef |
| 2014 | defcompile |
| 2015 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2016 | v9.CheckScriptFailure(lines, 'E46:') |
Bram Moolenaar | 0825175 | 2021-01-11 21:20:18 +0100 | [diff] [blame] | 2017 | |
| 2018 | lines =<< trim END |
| 2019 | vim9script |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 2020 | final w:finalvar = [9] |
| 2021 | w:finalvar = [8] |
| 2022 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2023 | v9.CheckScriptFailure(lines, 'E1122:') |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 2024 | unlet w:finalvar |
| 2025 | |
| 2026 | lines =<< trim END |
| 2027 | vim9script |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2028 | const var: string |
| 2029 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2030 | v9.CheckScriptFailure(lines, 'E1021:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2031 | |
| 2032 | lines =<< trim END |
| 2033 | vim9script |
| 2034 | var 9var: string |
| 2035 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2036 | v9.CheckScriptFailure(lines, 'E488:') |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 2037 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2038 | v9.CheckDefFailure(['var foo.bar = 2'], 'E1087:') |
| 2039 | v9.CheckDefFailure(['var foo[3] = 2'], 'E1087:') |
| 2040 | v9.CheckDefFailure(['const foo: number'], 'E1021:') |
Bram Moolenaar | e1d1211 | 2022-03-05 11:37:48 +0000 | [diff] [blame] | 2041 | |
| 2042 | lines =<< trim END |
| 2043 | va foo = 123 |
| 2044 | END |
| 2045 | v9.CheckDefAndScriptFailure(lines, 'E1065:', 1) |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2046 | enddef |
| 2047 | |
Bram Moolenaar | e88c6b7 | 2022-02-15 15:37:11 +0000 | [diff] [blame] | 2048 | def Test_var_declaration_inferred() |
| 2049 | # check that type is set on the list so that extend() fails |
| 2050 | var lines =<< trim END |
| 2051 | vim9script |
| 2052 | def GetList(): list<number> |
| 2053 | var l = [1, 2, 3] |
| 2054 | return l |
| 2055 | enddef |
| 2056 | echo GetList()->extend(['x']) |
| 2057 | END |
| 2058 | v9.CheckScriptFailure(lines, 'E1013:', 6) |
| 2059 | enddef |
| 2060 | |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2061 | def Test_script_local_in_legacy() |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2062 | # OK to define script-local later but before compiling |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2063 | var lines =<< trim END |
| 2064 | def SetLater() |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2065 | legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2066 | enddef |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2067 | let s:legvar = 'one' |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2068 | defcompile |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2069 | call SetLater() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2070 | call assert_equal('two', s:legvar) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2071 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2072 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2073 | |
| 2074 | # OK to leave out s: prefix when script-local already defined |
| 2075 | lines =<< trim END |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2076 | let s:legvar = 'one' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2077 | def SetNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2078 | legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2079 | enddef |
| 2080 | call SetNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2081 | call assert_equal('two', s:legvar) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2082 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2083 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2084 | |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2085 | # Not OK to leave out s: prefix when script-local defined after compiling |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2086 | lines =<< trim END |
| 2087 | def SetLaterNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2088 | legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2089 | enddef |
| 2090 | defcompile |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 2091 | let s:legvar = 'one' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2092 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2093 | v9.CheckScriptFailure(lines, 'E476:', 1) |
Bram Moolenaar | 47bc9c3 | 2021-07-17 21:24:56 +0200 | [diff] [blame] | 2094 | |
| 2095 | edit! Xfile |
| 2096 | lines =<< trim END |
| 2097 | var edit: bool |
| 2098 | legacy edit |
| 2099 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2100 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 2101 | enddef |
| 2102 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 2103 | def Test_var_type_check() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2104 | var lines =<< trim END |
| 2105 | vim9script |
| 2106 | var name: string |
| 2107 | name = 1234 |
| 2108 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2109 | v9.CheckScriptFailure(lines, 'E1012:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2110 | |
| 2111 | lines =<< trim END |
| 2112 | vim9script |
| 2113 | var name:string |
| 2114 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2115 | v9.CheckScriptFailure(lines, 'E1069:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2116 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2117 | v9.CheckDefAndScriptFailure(['var n:number = 42'], 'E1069:') |
Bram Moolenaar | 60faf86 | 2021-08-23 22:22:45 +0200 | [diff] [blame] | 2118 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2119 | lines =<< trim END |
| 2120 | vim9script |
| 2121 | var name: asdf |
| 2122 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2123 | v9.CheckScriptFailure(lines, 'E1010:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2124 | |
| 2125 | lines =<< trim END |
| 2126 | vim9script |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2127 | var l: list<number> |
| 2128 | l = [] |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2129 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2130 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2131 | |
| 2132 | lines =<< trim END |
| 2133 | vim9script |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2134 | var d: dict<number> |
| 2135 | d = {} |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2136 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2137 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 378697a | 2021-07-15 19:23:18 +0200 | [diff] [blame] | 2138 | |
| 2139 | lines =<< trim END |
| 2140 | vim9script |
| 2141 | var d = {a: 1, b: [2]} |
| 2142 | def Func(b: bool) |
| 2143 | var l: list<number> = b ? d.b : [3] |
| 2144 | enddef |
| 2145 | defcompile |
| 2146 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2147 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2148 | enddef |
| 2149 | |
| 2150 | let g:dict_number = #{one: 1, two: 2} |
| 2151 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 2152 | def Test_var_list_dict_type() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2153 | var ll: list<number> |
| 2154 | ll = [1, 2, 2, 3, 3, 3]->uniq() |
| 2155 | ll->assert_equal([1, 2, 3]) |
| 2156 | |
| 2157 | var dd: dict<number> |
| 2158 | dd = g:dict_number |
| 2159 | dd->assert_equal(g:dict_number) |
| 2160 | |
| 2161 | var lines =<< trim END |
| 2162 | var ll: list<number> |
| 2163 | ll = [1, 2, 3]->map('"one"') |
| 2164 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2165 | v9.CheckDefExecFailure(lines, 'E1012: Type mismatch; expected list<number> but got list<string>') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2166 | enddef |
| 2167 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 2168 | def Test_cannot_use_let() |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2169 | v9.CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1) |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 2170 | enddef |
| 2171 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2172 | def Test_unlet() |
| 2173 | g:somevar = 'yes' |
| 2174 | assert_true(exists('g:somevar')) |
| 2175 | unlet g:somevar |
| 2176 | assert_false(exists('g:somevar')) |
| 2177 | unlet! g:somevar |
| 2178 | |
| 2179 | # also works for script-local variable in legacy Vim script |
| 2180 | s:somevar = 'legacy' |
| 2181 | assert_true(exists('s:somevar')) |
| 2182 | unlet s:somevar |
| 2183 | assert_false(exists('s:somevar')) |
| 2184 | unlet! s:somevar |
| 2185 | |
Bram Moolenaar | 83d0cec | 2022-02-04 21:17:58 +0000 | [diff] [blame] | 2186 | if 0 |
| 2187 | unlet g:does_not_exist |
| 2188 | endif |
| 2189 | |
| 2190 | v9.CheckDefExecFailure(['unlet v:notfound.key'], 'E1001:') |
| 2191 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2192 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2193 | 'var dd = 111', |
| 2194 | 'unlet dd', |
| 2195 | ], 'E1081:', 2) |
| 2196 | |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2197 | # dict unlet |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 2198 | var dd = {a: 1, b: 2, c: 3, 4: 4} |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2199 | unlet dd['a'] |
| 2200 | unlet dd.c |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 2201 | unlet dd[4] |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2202 | assert_equal({b: 2}, dd) |
| 2203 | |
| 2204 | # list unlet |
| 2205 | var ll = [1, 2, 3, 4] |
| 2206 | unlet ll[1] |
| 2207 | unlet ll[-1] |
| 2208 | assert_equal([1, 3], ll) |
| 2209 | |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2210 | ll = [1, 2, 3, 4] |
| 2211 | unlet ll[0 : 1] |
| 2212 | assert_equal([3, 4], ll) |
| 2213 | |
| 2214 | ll = [1, 2, 3, 4] |
| 2215 | unlet ll[2 : 8] |
| 2216 | assert_equal([1, 2], ll) |
| 2217 | |
| 2218 | ll = [1, 2, 3, 4] |
| 2219 | unlet ll[-2 : -1] |
| 2220 | assert_equal([1, 2], ll) |
| 2221 | |
Bram Moolenaar | 0c7f261 | 2022-02-17 19:44:07 +0000 | [diff] [blame] | 2222 | g:nrdict = {1: 1, 2: 2} |
| 2223 | g:idx = 1 |
| 2224 | unlet g:nrdict[g:idx] |
| 2225 | assert_equal({2: 2}, g:nrdict) |
| 2226 | unlet g:nrdict |
| 2227 | unlet g:idx |
| 2228 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2229 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2230 | 'var ll = [1, 2]', |
| 2231 | 'll[1 : 2] = 7', |
Bram Moolenaar | 4f0884d | 2021-08-11 21:49:23 +0200 | [diff] [blame] | 2232 | ], 'E1012: Type mismatch; expected list<number> but got number', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2233 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2234 | 'var dd = {a: 1}', |
| 2235 | 'unlet dd["a" : "a"]', |
| 2236 | ], 'E1166:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2237 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2238 | 'unlet g:adict[0 : 1]', |
| 2239 | ], 'E1148:', 1) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2240 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2241 | 'var ll = [1, 2]', |
| 2242 | 'unlet ll[0:1]', |
| 2243 | ], 'E1004:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2244 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2245 | 'var ll = [1, 2]', |
| 2246 | 'unlet ll[0 :1]', |
| 2247 | ], 'E1004:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2248 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2249 | 'var ll = [1, 2]', |
| 2250 | 'unlet ll[0: 1]', |
| 2251 | ], 'E1004:', 2) |
Bram Moolenaar | e08be09 | 2022-02-17 13:08:26 +0000 | [diff] [blame] | 2252 | |
| 2253 | v9.CheckDefExecFailure([ |
| 2254 | 'g:ll = [1, 2]', |
| 2255 | 'g:idx = "x"', |
| 2256 | 'unlet g:ll[g:idx]', |
| 2257 | ], 'E1029: Expected number but got string', 3) |
| 2258 | |
| 2259 | v9.CheckDefExecFailure([ |
| 2260 | 'g:ll = [1, 2, 3]', |
| 2261 | 'g:idx = "x"', |
| 2262 | 'unlet g:ll[g:idx : 2]', |
| 2263 | ], 'E1029: Expected number but got string', 3) |
| 2264 | |
| 2265 | v9.CheckDefExecFailure([ |
| 2266 | 'g:ll = [1, 2, 3]', |
| 2267 | 'g:idx = "x"', |
| 2268 | 'unlet g:ll[0 : g:idx]', |
| 2269 | ], 'E1029: Expected number but got string', 3) |
| 2270 | |
Bram Moolenaar | 7f2c341 | 2021-11-29 16:01:49 +0000 | [diff] [blame] | 2271 | # command recognized as assignment when skipping, should not give an error |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2272 | v9.CheckScriptSuccess([ |
Bram Moolenaar | 7f2c341 | 2021-11-29 16:01:49 +0000 | [diff] [blame] | 2273 | 'vim9script', |
| 2274 | 'for i in []', |
| 2275 | " put =''", |
| 2276 | 'endfor']) |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2277 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2278 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2279 | 'var ll = [1, 2]', |
| 2280 | 'unlet ll["x" : 1]', |
| 2281 | ], 'E1012:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2282 | v9.CheckDefFailure([ |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 2283 | 'var ll = [1, 2]', |
| 2284 | 'unlet ll[0 : "x"]', |
| 2285 | ], 'E1012:', 2) |
| 2286 | |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2287 | # list of dict unlet |
| 2288 | var dl = [{a: 1, b: 2}, {c: 3}] |
| 2289 | unlet dl[0]['b'] |
| 2290 | assert_equal([{a: 1}, {c: 3}], dl) |
| 2291 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2292 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2293 | 'var ll = test_null_list()', |
| 2294 | 'unlet ll[0]', |
| 2295 | ], 'E684:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2296 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2297 | 'var ll = [1]', |
| 2298 | 'unlet ll[2]', |
| 2299 | ], 'E684:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2300 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2301 | 'var ll = [1]', |
| 2302 | 'unlet ll[g:astring]', |
Bram Moolenaar | f30a14d | 2021-01-17 21:51:24 +0100 | [diff] [blame] | 2303 | ], 'E1012:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2304 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2305 | 'var dd = test_null_dict()', |
| 2306 | 'unlet dd["a"]', |
| 2307 | ], 'E716:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2308 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2309 | 'var dd = {a: 1}', |
| 2310 | 'unlet dd["b"]', |
| 2311 | ], 'E716:', 2) |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2312 | v9.CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2313 | 'var dd = {a: 1}', |
| 2314 | 'unlet dd[g:alist]', |
| 2315 | ], 'E1105:', 2) |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2316 | |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 2317 | v9.CheckDefExecFailure([ |
| 2318 | 'g:dd = {"a": 1, 2: 2}' |
| 2319 | 'unlet g:dd[0z11]', |
| 2320 | ], 'E1029:', 2) |
Bram Moolenaar | 6296d1e | 2022-02-17 16:30:11 +0000 | [diff] [blame] | 2321 | v9.CheckDefExecFailure([ |
| 2322 | 'g:str = "a string"' |
| 2323 | 'unlet g:str[0]', |
| 2324 | ], 'E1148: Cannot index a string', 2) |
Bram Moolenaar | ea5c898 | 2022-02-17 14:42:02 +0000 | [diff] [blame] | 2325 | |
Bram Moolenaar | 2ef951d | 2021-01-03 20:55:26 +0100 | [diff] [blame] | 2326 | # can compile unlet before variable exists |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 2327 | g:someDict = {key: 'val'} |
| 2328 | var k = 'key' |
| 2329 | unlet g:someDict[k] |
| 2330 | assert_equal({}, g:someDict) |
| 2331 | unlet g:someDict |
| 2332 | assert_false(exists('g:someDict')) |
Bram Moolenaar | 2ef951d | 2021-01-03 20:55:26 +0100 | [diff] [blame] | 2333 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2334 | v9.CheckScriptFailure([ |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2335 | 'vim9script', |
| 2336 | 'var svar = 123', |
| 2337 | 'unlet svar', |
| 2338 | ], 'E1081:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2339 | v9.CheckScriptFailure([ |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2340 | 'vim9script', |
| 2341 | 'var svar = 123', |
| 2342 | 'unlet s:svar', |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2343 | ], 'E1268:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2344 | v9.CheckScriptFailure([ |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2345 | 'vim9script', |
| 2346 | 'var svar = 123', |
| 2347 | 'def Func()', |
| 2348 | ' unlet svar', |
| 2349 | 'enddef', |
| 2350 | 'defcompile', |
| 2351 | ], 'E1081:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2352 | v9.CheckScriptFailure([ |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2353 | 'vim9script', |
| 2354 | 'var svar = 123', |
Bram Moolenaar | 9aed729 | 2020-12-18 15:38:00 +0100 | [diff] [blame] | 2355 | 'func Func()', |
| 2356 | ' unlet s:svar', |
| 2357 | 'endfunc', |
| 2358 | 'Func()', |
| 2359 | ], 'E1081:') |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2360 | v9.CheckScriptFailure([ |
Bram Moolenaar | 9aed729 | 2020-12-18 15:38:00 +0100 | [diff] [blame] | 2361 | 'vim9script', |
| 2362 | 'var svar = 123', |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2363 | 'def Func()', |
| 2364 | ' unlet s:svar', |
| 2365 | 'enddef', |
| 2366 | 'defcompile', |
| 2367 | ], 'E1081:') |
| 2368 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2369 | v9.CheckScriptFailure([ |
Bram Moolenaar | 71b7685 | 2021-12-17 20:15:38 +0000 | [diff] [blame] | 2370 | 'vim9script', |
| 2371 | 'def Delcount(dict: dict<any>)', |
| 2372 | ' unlet dict.count', |
| 2373 | 'enddef', |
| 2374 | 'Delcount(v:)', |
| 2375 | ], 'E742:') |
| 2376 | |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2377 | v9.CheckScriptFailure([ |
Bram Moolenaar | 71b7685 | 2021-12-17 20:15:38 +0000 | [diff] [blame] | 2378 | 'vim9script', |
| 2379 | 'def DelChangedtick(dict: dict<any>)', |
| 2380 | ' unlet dict.changedtick', |
| 2381 | 'enddef', |
| 2382 | 'DelChangedtick(b:)', |
| 2383 | ], 'E795:') |
| 2384 | |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2385 | writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim') |
| 2386 | var lines =<< trim END |
| 2387 | vim9script |
Bram Moolenaar | d5f400c | 2022-01-06 21:10:28 +0000 | [diff] [blame] | 2388 | import './XunletExport.vim' as exp |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2389 | def UnletSvar() |
Bram Moolenaar | d5f400c | 2022-01-06 21:10:28 +0000 | [diff] [blame] | 2390 | unlet exp.svar |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2391 | enddef |
| 2392 | defcompile |
| 2393 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2394 | v9.CheckScriptFailure(lines, 'E1260:', 1) |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 2395 | delete('XunletExport.vim') |
| 2396 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2397 | $ENVVAR = 'foobar' |
| 2398 | assert_equal('foobar', $ENVVAR) |
| 2399 | unlet $ENVVAR |
| 2400 | assert_equal('', $ENVVAR) |
| 2401 | enddef |
| 2402 | |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 2403 | def Test_expr_error_no_assign() |
| 2404 | var lines =<< trim END |
| 2405 | vim9script |
| 2406 | var x = invalid |
| 2407 | echo x |
| 2408 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2409 | v9.CheckScriptFailureList(lines, ['E121:', 'E121:']) |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 2410 | |
| 2411 | lines =<< trim END |
| 2412 | vim9script |
| 2413 | var x = 1 / 0 |
| 2414 | echo x |
| 2415 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2416 | v9.CheckScriptFailure(lines, 'E1154:') |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 2417 | |
| 2418 | lines =<< trim END |
| 2419 | vim9script |
| 2420 | var x = 1 % 0 |
| 2421 | echo x |
| 2422 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2423 | v9.CheckScriptFailure(lines, 'E1154:') |
Bram Moolenaar | ccc25aa | 2021-03-26 21:27:52 +0100 | [diff] [blame] | 2424 | |
| 2425 | lines =<< trim END |
| 2426 | var x: string 'string' |
| 2427 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2428 | v9.CheckDefAndScriptFailure(lines, 'E488:') |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 2429 | enddef |
| 2430 | |
| 2431 | |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 2432 | def Test_assign_command_modifier() |
| 2433 | var lines =<< trim END |
Bram Moolenaar | 9e0f883 | 2021-01-09 12:09:22 +0100 | [diff] [blame] | 2434 | var verbose = 0 |
| 2435 | verbose = 1 |
| 2436 | assert_equal(1, verbose) |
| 2437 | silent verbose = 2 |
| 2438 | assert_equal(2, verbose) |
| 2439 | silent verbose += 2 |
| 2440 | assert_equal(4, verbose) |
| 2441 | silent verbose -= 1 |
| 2442 | assert_equal(3, verbose) |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 2443 | |
Bram Moolenaar | 9e0f883 | 2021-01-09 12:09:22 +0100 | [diff] [blame] | 2444 | var topleft = {one: 1} |
| 2445 | sandbox topleft.one = 3 |
| 2446 | assert_equal({one: 3}, topleft) |
| 2447 | leftabove topleft[' '] = 4 |
| 2448 | assert_equal({one: 3, ' ': 4}, topleft) |
| 2449 | |
| 2450 | var x: number |
| 2451 | var y: number |
| 2452 | silent [x, y] = [1, 2] |
| 2453 | assert_equal(1, x) |
| 2454 | assert_equal(2, y) |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 2455 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2456 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 2457 | enddef |
| 2458 | |
Bram Moolenaar | 74f4a96 | 2021-06-17 21:03:07 +0200 | [diff] [blame] | 2459 | def Test_assign_alt_buf_register() |
| 2460 | var lines =<< trim END |
| 2461 | edit 'file_b1' |
| 2462 | var b1 = bufnr() |
| 2463 | edit 'file_b2' |
| 2464 | var b2 = bufnr() |
| 2465 | assert_equal(b1, bufnr('#')) |
| 2466 | @# = b2 |
| 2467 | assert_equal(b2, bufnr('#')) |
| 2468 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2469 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 74f4a96 | 2021-06-17 21:03:07 +0200 | [diff] [blame] | 2470 | enddef |
| 2471 | |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2472 | def Test_script_funcref_case() |
| 2473 | var lines =<< trim END |
| 2474 | var Len = (s: string): number => len(s) + 1 |
| 2475 | assert_equal(5, Len('asdf')) |
| 2476 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2477 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2478 | |
| 2479 | lines =<< trim END |
| 2480 | var len = (s: string): number => len(s) + 1 |
| 2481 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2482 | v9.CheckDefAndScriptFailure(lines, 'E704:') |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2483 | |
| 2484 | lines =<< trim END |
| 2485 | vim9script |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2486 | var Len = (s: string): number => len(s) + 2 |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2487 | assert_equal(6, Len('asdf')) |
| 2488 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2489 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2490 | |
| 2491 | lines =<< trim END |
| 2492 | vim9script |
Bram Moolenaar | a749a42 | 2022-02-12 19:52:25 +0000 | [diff] [blame] | 2493 | var len = (s: string): number => len(s) + 1 |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2494 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2495 | v9.CheckScriptFailure(lines, 'E704:') |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 2496 | enddef |
| 2497 | |
Bram Moolenaar | 44a8977 | 2021-12-18 12:31:33 +0000 | [diff] [blame] | 2498 | def Test_script_funcref_runtime_type_check() |
| 2499 | var lines =<< trim END |
| 2500 | vim9script |
| 2501 | def FuncWithNumberArg(n: number) |
| 2502 | enddef |
| 2503 | def Test() |
| 2504 | var Ref: func(string) = function(FuncWithNumberArg) |
| 2505 | enddef |
| 2506 | defcompile |
| 2507 | END |
| 2508 | # OK at compile time |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2509 | v9.CheckScriptSuccess(lines) |
Bram Moolenaar | 44a8977 | 2021-12-18 12:31:33 +0000 | [diff] [blame] | 2510 | |
| 2511 | # Type check fails at runtime |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2512 | v9.CheckScriptFailure(lines + ['Test()'], 'E1012: Type mismatch; expected func(string) but got func(number)') |
Bram Moolenaar | 44a8977 | 2021-12-18 12:31:33 +0000 | [diff] [blame] | 2513 | enddef |
| 2514 | |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 2515 | def Test_inc_dec() |
| 2516 | var lines =<< trim END |
| 2517 | var nr = 7 |
| 2518 | ++nr |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 2519 | assert_equal(8, nr) |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 2520 | --nr |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 2521 | assert_equal(7, nr) |
Bram Moolenaar | f3d3084 | 2021-06-25 19:29:30 +0200 | [diff] [blame] | 2522 | ++nr | ++nr |
| 2523 | assert_equal(9, nr) |
| 2524 | ++nr # comment |
| 2525 | assert_equal(10, nr) |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 2526 | |
| 2527 | var ll = [1, 2] |
| 2528 | --ll[0] |
| 2529 | ++ll[1] |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 2530 | assert_equal([0, 3], ll) |
| 2531 | |
| 2532 | g:count = 1 |
| 2533 | ++g:count |
| 2534 | --g:count |
| 2535 | assert_equal(1, g:count) |
| 2536 | unlet g:count |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 2537 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2538 | v9.CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 22480d1 | 2021-06-25 21:31:09 +0200 | [diff] [blame] | 2539 | |
| 2540 | lines =<< trim END |
| 2541 | var nr = 7 |
| 2542 | ++ nr |
| 2543 | END |
Bram Moolenaar | 62aec93 | 2022-01-29 21:45:34 +0000 | [diff] [blame] | 2544 | v9.CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr") |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 2545 | enddef |
| 2546 | |
Bram Moolenaar | 327d3ee | 2021-07-28 19:34:14 +0200 | [diff] [blame] | 2547 | def Test_abort_after_error() |
| 2548 | # should abort after strpart() fails, not give another type error |
| 2549 | var lines =<< trim END |
| 2550 | vim9script |
| 2551 | var x: string |
| 2552 | x = strpart(1, 2) |
| 2553 | END |
| 2554 | writefile(lines, 'Xtestscript') |
| 2555 | var expected = 'E1174: String required for argument 1' |
| 2556 | assert_fails('so Xtestscript', [expected, expected], 3) |
| 2557 | |
| 2558 | delete('Xtestscript') |
| 2559 | enddef |
| 2560 | |
Bram Moolenaar | afa048f | 2022-02-22 20:43:36 +0000 | [diff] [blame] | 2561 | def Test_using_s_var_in_function() |
| 2562 | var lines =<< trim END |
| 2563 | vim9script |
| 2564 | var scriptlevel = 123 |
| 2565 | def SomeFunc() |
| 2566 | echo s:scriptlevel |
| 2567 | enddef |
| 2568 | SomeFunc() |
| 2569 | END |
| 2570 | v9.CheckScriptFailure(lines, 'E1268:') |
| 2571 | |
| 2572 | # OK in legacy script |
| 2573 | lines =<< trim END |
| 2574 | let s:scriptlevel = 123 |
| 2575 | def s:SomeFunc() |
| 2576 | echo s:scriptlevel |
| 2577 | enddef |
| 2578 | call s:SomeFunc() |
| 2579 | END |
| 2580 | v9.CheckScriptSuccess(lines) |
| 2581 | |
| 2582 | lines =<< trim END |
| 2583 | vim9script |
| 2584 | var scriptlevel = 123 |
| 2585 | def SomeFunc() |
| 2586 | s:scriptlevel = 456 |
| 2587 | enddef |
| 2588 | SomeFunc() |
| 2589 | END |
| 2590 | v9.CheckScriptFailure(lines, 'E1268:') |
| 2591 | |
| 2592 | # OK in legacy script |
| 2593 | lines =<< trim END |
| 2594 | let s:scriptlevel = 123 |
| 2595 | def s:SomeFunc() |
| 2596 | s:scriptlevel = 456 |
| 2597 | enddef |
| 2598 | call s:SomeFunc() |
| 2599 | call assert_equal(456, s:scriptlevel) |
| 2600 | END |
| 2601 | v9.CheckScriptSuccess(lines) |
| 2602 | enddef |
| 2603 | |
Bram Moolenaar | 327d3ee | 2021-07-28 19:34:14 +0200 | [diff] [blame] | 2604 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 2605 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 2606 | " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker |