Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1 | " Test Vim9 assignments |
| 2 | |
| 3 | source check.vim |
| 4 | source vim9.vim |
| 5 | |
| 6 | let s:appendToMe = 'xxx' |
| 7 | let s:addToMe = 111 |
| 8 | let g:existing = 'yes' |
| 9 | let g:inc_counter = 1 |
| 10 | let $SOME_ENV_VAR = 'some' |
| 11 | let g:alist = [7] |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 12 | let g:adict = #{a: 1} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 13 | let g:astring = 'text' |
| 14 | |
| 15 | def Test_assignment_bool() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 16 | var bool1: bool = true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 17 | assert_equal(v:true, bool1) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 18 | var bool2: bool = false |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 19 | assert_equal(v:false, bool2) |
| 20 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 21 | var bool3: bool = 0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 22 | assert_equal(false, bool3) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 23 | var bool4: bool = 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 24 | assert_equal(true, bool4) |
| 25 | |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 26 | var bool5: bool = 1 && true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 27 | assert_equal(true, bool5) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 28 | var bool6: bool = 0 && 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 29 | assert_equal(false, bool6) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 30 | var bool7: bool = 0 || 1 && true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 31 | assert_equal(true, bool7) |
| 32 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 33 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 34 | vim9script |
| 35 | def GetFlag(): bool |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 36 | var flag: bool = 1 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 37 | return flag |
| 38 | enddef |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 39 | var flag: bool = GetFlag() |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 40 | assert_equal(true, flag) |
| 41 | flag = 0 |
| 42 | assert_equal(false, flag) |
| 43 | flag = 1 |
| 44 | assert_equal(true, flag) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 45 | flag = 1 || true |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 46 | assert_equal(true, flag) |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 47 | flag = 1 && false |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 48 | assert_equal(false, flag) |
Bram Moolenaar | dd1f426 | 2020-12-31 17:41:01 +0100 | [diff] [blame] | 49 | |
| 50 | var cp: bool = &cp |
| 51 | var fen: bool = &l:fen |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 52 | END |
| 53 | CheckScriptSuccess(lines) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 54 | CheckDefAndScriptFailure(['var x: bool = 2'], 'E1012:') |
| 55 | CheckDefAndScriptFailure(['var x: bool = -1'], 'E1012:') |
| 56 | CheckDefAndScriptFailure(['var x: bool = [1]'], 'E1012:') |
| 57 | CheckDefAndScriptFailure(['var x: bool = {}'], 'E1012:') |
| 58 | CheckDefAndScriptFailure(['var x: bool = "x"'], 'E1012:') |
Bram Moolenaar | 9a562c1 | 2021-01-23 13:39:14 +0100 | [diff] [blame] | 59 | |
| 60 | CheckDefAndScriptFailure(['var x: bool = "x"', '', 'eval 0'], 'E1012:', 1) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 61 | enddef |
| 62 | |
| 63 | def Test_syntax() |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 64 | var name = 234 |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 65 | var other: list<string> = ['asdf'] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 66 | enddef |
| 67 | |
| 68 | def Test_assignment() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 69 | CheckDefFailure(['var x:string'], 'E1069:') |
| 70 | CheckDefFailure(['var x:string = "x"'], 'E1069:') |
| 71 | CheckDefFailure(['var a:string = "x"'], 'E1069:') |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 72 | CheckDefFailure(['var lambda = () => "lambda"'], 'E704:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 73 | CheckScriptFailure(['var x = "x"'], 'E1124:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 74 | |
Bram Moolenaar | 3f32788 | 2021-03-17 20:56:38 +0100 | [diff] [blame] | 75 | # lower case name is OK for a list |
| 76 | var lambdaLines =<< trim END |
| 77 | var lambdaList: list<func> = [Test_syntax] |
| 78 | lambdaList[0] = () => "lambda" |
| 79 | END |
| 80 | CheckDefAndScriptSuccess(lambdaLines) |
| 81 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 82 | var nr: number = 1234 |
| 83 | CheckDefFailure(['var nr: number = "asdf"'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 84 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 85 | var a: number = 6 #comment |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 86 | assert_equal(6, a) |
| 87 | |
| 88 | if has('channel') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 89 | var chan1: channel |
Bram Moolenaar | 218450a | 2020-10-17 18:51:52 +0200 | [diff] [blame] | 90 | assert_equal('fail', ch_status(chan1)) |
| 91 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 92 | var job1: job |
Bram Moolenaar | 218450a | 2020-10-17 18:51:52 +0200 | [diff] [blame] | 93 | assert_equal('fail', job_status(job1)) |
| 94 | |
Bram Moolenaar | fc8aa6d | 2020-10-12 20:31:26 +0200 | [diff] [blame] | 95 | # 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] | 96 | endif |
| 97 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 98 | var float1: float = 3.4 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 99 | endif |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 100 | var Funky1: func |
| 101 | var Funky2: func = function('len') |
| 102 | var Party2: func = funcref('g:Test_syntax') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 103 | |
| 104 | g:newvar = 'new' #comment |
| 105 | assert_equal('new', g:newvar) |
| 106 | |
| 107 | assert_equal('yes', g:existing) |
| 108 | g:existing = 'no' |
| 109 | assert_equal('no', g:existing) |
| 110 | |
| 111 | v:char = 'abc' |
| 112 | assert_equal('abc', v:char) |
| 113 | |
| 114 | $ENVVAR = 'foobar' |
| 115 | assert_equal('foobar', $ENVVAR) |
| 116 | $ENVVAR = '' |
| 117 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 118 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 119 | vim9script |
| 120 | $ENVVAR = 'barfoo' |
| 121 | assert_equal('barfoo', $ENVVAR) |
| 122 | $ENVVAR = '' |
| 123 | END |
| 124 | CheckScriptSuccess(lines) |
| 125 | |
| 126 | s:appendToMe ..= 'yyy' |
| 127 | assert_equal('xxxyyy', s:appendToMe) |
| 128 | s:addToMe += 222 |
| 129 | assert_equal(333, s:addToMe) |
| 130 | s:newVar = 'new' |
| 131 | assert_equal('new', s:newVar) |
| 132 | |
| 133 | set ts=7 |
Bram Moolenaar | dd1f426 | 2020-12-31 17:41:01 +0100 | [diff] [blame] | 134 | var ts: number = &ts |
| 135 | assert_equal(7, ts) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 136 | &ts += 1 |
| 137 | assert_equal(8, &ts) |
| 138 | &ts -= 3 |
| 139 | assert_equal(5, &ts) |
| 140 | &ts *= 2 |
| 141 | assert_equal(10, &ts) |
| 142 | &ts /= 3 |
| 143 | assert_equal(3, &ts) |
| 144 | set ts=10 |
| 145 | &ts %= 4 |
| 146 | assert_equal(2, &ts) |
| 147 | |
| 148 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 149 | var f100: float = 100.0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 150 | f100 /= 5 |
| 151 | assert_equal(20.0, f100) |
| 152 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 153 | var f200: float = 200.0 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 154 | f200 /= 5.0 |
| 155 | assert_equal(40.0, f200) |
| 156 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 157 | CheckDefFailure(['var nr: number = 200', 'nr /= 5.0'], 'E1012:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 158 | endif |
| 159 | |
| 160 | lines =<< trim END |
| 161 | &ts = 6 |
| 162 | &ts += 3 |
| 163 | assert_equal(9, &ts) |
| 164 | |
| 165 | &l:ts = 6 |
| 166 | assert_equal(6, &ts) |
| 167 | &l:ts += 2 |
| 168 | assert_equal(8, &ts) |
| 169 | |
| 170 | &g:ts = 6 |
| 171 | assert_equal(6, &g:ts) |
| 172 | &g:ts += 2 |
| 173 | assert_equal(8, &g:ts) |
Bram Moolenaar | 0ea0440 | 2021-01-04 13:37:54 +0100 | [diff] [blame] | 174 | |
| 175 | &number = true |
| 176 | assert_equal(true, &number) |
| 177 | &number = 0 |
| 178 | assert_equal(false, &number) |
| 179 | &number = 1 |
| 180 | assert_equal(true, &number) |
| 181 | &number = false |
| 182 | assert_equal(false, &number) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 183 | END |
| 184 | CheckDefAndScriptSuccess(lines) |
| 185 | |
| 186 | CheckDefFailure(['¬ex += 3'], 'E113:') |
| 187 | CheckDefFailure(['&ts ..= "xxx"'], 'E1019:') |
| 188 | CheckDefFailure(['&ts = [7]'], 'E1012:') |
| 189 | CheckDefExecFailure(['&ts = g:alist'], 'E1012: Type mismatch; expected number but got list<number>') |
| 190 | CheckDefFailure(['&ts = "xx"'], 'E1012:') |
| 191 | CheckDefExecFailure(['&ts = g:astring'], 'E1012: Type mismatch; expected number but got string') |
| 192 | CheckDefFailure(['&path += 3'], 'E1012:') |
| 193 | CheckDefExecFailure(['&bs = "asdf"'], 'E474:') |
| 194 | # test freeing ISN_STOREOPT |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 195 | CheckDefFailure(['&ts = 3', 'var asdf'], 'E1022:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 196 | &ts = 8 |
| 197 | |
| 198 | lines =<< trim END |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 199 | var save_TI = &t_TI |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 200 | &t_TI = '' |
| 201 | assert_equal('', &t_TI) |
| 202 | &t_TI = 'xxx' |
| 203 | assert_equal('xxx', &t_TI) |
| 204 | &t_TI = save_TI |
| 205 | END |
| 206 | CheckDefAndScriptSuccess(lines) |
| 207 | |
| 208 | CheckDefFailure(['&t_TI = 123'], 'E1012:') |
| 209 | CheckScriptFailure(['vim9script', '&t_TI = 123'], 'E928:') |
| 210 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 211 | CheckDefFailure(['var s:var = 123'], 'E1101:') |
| 212 | CheckDefFailure(['var s:var: number'], 'E1101:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 213 | |
| 214 | lines =<< trim END |
| 215 | vim9script |
| 216 | def SomeFunc() |
| 217 | s:var = 123 |
| 218 | enddef |
| 219 | defcompile |
| 220 | END |
| 221 | CheckScriptFailure(lines, 'E1089:') |
| 222 | |
| 223 | g:inc_counter += 1 |
| 224 | assert_equal(2, g:inc_counter) |
| 225 | |
| 226 | $SOME_ENV_VAR ..= 'more' |
| 227 | assert_equal('somemore', $SOME_ENV_VAR) |
| 228 | CheckDefFailure(['$SOME_ENV_VAR += "more"'], 'E1051:') |
| 229 | CheckDefFailure(['$SOME_ENV_VAR += 123'], 'E1012:') |
| 230 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 231 | v:errmsg = 'none' |
| 232 | v:errmsg ..= 'again' |
| 233 | assert_equal('noneagain', v:errmsg) |
| 234 | CheckDefFailure(['v:errmsg += "more"'], 'E1051:') |
| 235 | CheckDefFailure(['v:errmsg += 123'], 'E1012:') |
| 236 | |
Bram Moolenaar | fc8aa6d | 2020-10-12 20:31:26 +0200 | [diff] [blame] | 237 | var text =<< trim END |
| 238 | some text |
| 239 | END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 240 | enddef |
| 241 | |
Bram Moolenaar | 13e45d1 | 2021-06-26 13:28:35 +0200 | [diff] [blame] | 242 | def Test_assign_register() |
| 243 | var lines =<< trim END |
| 244 | @c = 'areg' |
| 245 | @c ..= 'add' |
| 246 | assert_equal('aregadd', @c) |
| 247 | |
| 248 | @@ = 'some text' |
| 249 | assert_equal('some text', getreg('"')) |
| 250 | END |
| 251 | CheckDefAndScriptSuccess(lines) |
| 252 | |
| 253 | CheckDefFailure(['@a += "more"'], 'E1051:') |
| 254 | CheckDefFailure(['@a += 123'], 'E1012:') |
| 255 | enddef |
| 256 | |
Bram Moolenaar | d0edaf9 | 2021-05-28 21:06:08 +0200 | [diff] [blame] | 257 | def Test_reserved_name() |
| 258 | for name in ['true', 'false', 'null'] |
| 259 | CheckDefExecAndScriptFailure(['var ' .. name .. ' = 0'], 'E1034:') |
| 260 | CheckDefExecAndScriptFailure(['var ' .. name .. ': bool'], 'E1034:') |
| 261 | endfor |
| 262 | enddef |
| 263 | |
Bram Moolenaar | aa1959b | 2021-04-15 22:13:39 +0200 | [diff] [blame] | 264 | def Test_skipped_assignment() |
| 265 | var lines =<< trim END |
| 266 | for x in [] |
| 267 | var i: number = 1 |
| 268 | while false |
| 269 | i += 1 |
| 270 | endwhile |
| 271 | endfor |
| 272 | END |
| 273 | CheckDefAndScriptSuccess(lines) |
| 274 | enddef |
| 275 | |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 276 | def Test_assign_unpack() |
| 277 | var lines =<< trim END |
| 278 | var v1: number |
| 279 | var v2: number |
| 280 | [v1, v2] = [1, 2] |
| 281 | assert_equal(1, v1) |
| 282 | assert_equal(2, v2) |
Bram Moolenaar | f93bbd0 | 2021-04-10 22:35:43 +0200 | [diff] [blame] | 283 | |
| 284 | [v1, _, v2, _] = [1, 99, 2, 77] |
| 285 | assert_equal(1, v1) |
| 286 | assert_equal(2, v2) |
| 287 | |
| 288 | [v1, v2; _] = [1, 2, 3, 4, 5] |
| 289 | assert_equal(1, v1) |
| 290 | assert_equal(2, v2) |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 291 | |
Bram Moolenaar | 4d5dfe2 | 2021-06-26 13:59:29 +0200 | [diff] [blame] | 292 | var reslist = [] |
| 293 | for text in ['aaa {bbb} ccc', 'ddd {eee} fff'] |
| 294 | var before: string |
| 295 | var middle: string |
| 296 | var after: string |
| 297 | [_, before, middle, after; _] = text->matchlist('\(.\{-\}\){\(.\{-\}\)}\(.*\)') |
| 298 | reslist->add(before)->add(middle)->add(after) |
| 299 | endfor |
| 300 | assert_equal(['aaa ', 'bbb', ' ccc', 'ddd ', 'eee', ' fff'], reslist) |
| 301 | |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 302 | var a = 1 |
| 303 | var b = 3 |
| 304 | [a, b] += [2, 4] |
| 305 | assert_equal(3, a) |
| 306 | assert_equal(7, b) |
| 307 | |
| 308 | [a, b] -= [1, 2] |
| 309 | assert_equal(2, a) |
| 310 | assert_equal(5, b) |
| 311 | |
| 312 | [a, b] *= [3, 2] |
| 313 | assert_equal(6, a) |
| 314 | assert_equal(10, b) |
| 315 | |
| 316 | [a, b] /= [2, 4] |
| 317 | assert_equal(3, a) |
| 318 | assert_equal(2, b) |
| 319 | |
| 320 | [a, b] = [17, 15] |
| 321 | [a, b] %= [5, 3] |
| 322 | assert_equal(2, a) |
| 323 | assert_equal(0, b) |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 324 | END |
| 325 | CheckDefAndScriptSuccess(lines) |
| 326 | |
| 327 | lines =<< trim END |
| 328 | var v1: number |
| 329 | var v2: number |
| 330 | [v1, v2] = |
| 331 | END |
| 332 | CheckDefFailure(lines, 'E1097:', 5) |
| 333 | |
| 334 | lines =<< trim END |
| 335 | var v1: number |
| 336 | var v2: number |
| 337 | [v1, v2] = xxx |
| 338 | END |
| 339 | CheckDefFailure(lines, 'E1001:', 3) |
| 340 | |
| 341 | lines =<< trim END |
| 342 | var v1: number |
| 343 | var v2: number |
| 344 | [v1, v2] = popup_clear() |
| 345 | END |
| 346 | CheckDefFailure(lines, 'E1031:', 3) |
| 347 | |
| 348 | lines =<< trim END |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 349 | [v1, v2] = [1, 2] |
| 350 | END |
| 351 | CheckDefFailure(lines, 'E1089', 1) |
| 352 | CheckScriptFailure(['vim9script'] + lines, 'E1089', 2) |
| 353 | |
| 354 | lines =<< trim END |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 355 | var v1: number |
| 356 | var v2: number |
| 357 | [v1, v2] = '' |
| 358 | END |
| 359 | CheckDefFailure(lines, 'E1012: Type mismatch; expected list<any> but got string', 3) |
Bram Moolenaar | f785aa1 | 2021-02-11 21:19:34 +0100 | [diff] [blame] | 360 | |
| 361 | lines =<< trim END |
| 362 | g:values = [false, 0] |
| 363 | var x: bool |
| 364 | var y: string |
| 365 | [x, y] = g:values |
| 366 | END |
| 367 | CheckDefExecAndScriptFailure(lines, 'E1163: Variable 2: type mismatch, expected string but got number') |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 368 | enddef |
| 369 | |
Bram Moolenaar | 7f76494 | 2020-12-02 15:11:18 +0100 | [diff] [blame] | 370 | def Test_assign_linebreak() |
| 371 | var nr: number |
| 372 | nr = |
| 373 | 123 |
| 374 | assert_equal(123, nr) |
| 375 | |
| 376 | var n2: number |
| 377 | [nr, n2] = |
| 378 | [12, 34] |
| 379 | assert_equal(12, nr) |
| 380 | assert_equal(34, n2) |
| 381 | |
Bram Moolenaar | 8ff16e0 | 2020-12-07 21:49:52 +0100 | [diff] [blame] | 382 | CheckDefFailure(["var x = #"], 'E1097:', 3) |
Bram Moolenaar | 77709b1 | 2021-04-03 21:01:01 +0200 | [diff] [blame] | 383 | |
| 384 | var lines =<< trim END |
| 385 | var x: list<string> = ['a'] |
| 386 | var y: list<number> = x |
| 387 | ->copy() |
| 388 | ->copy() |
| 389 | END |
| 390 | CheckDefFailure(lines, 'E1012:', 2) |
Bram Moolenaar | 6977dba | 2021-07-04 22:48:12 +0200 | [diff] [blame] | 391 | |
| 392 | lines =<< trim END |
| 393 | var x: any |
| 394 | x.key = 1 |
| 395 | + 2 |
| 396 | + 3 |
| 397 | + 4 |
| 398 | + 5 |
| 399 | END |
| 400 | CheckDefExecAndScriptFailure2(lines, 'E1148:', 'E1203:', 2) |
Bram Moolenaar | 7f76494 | 2020-12-02 15:11:18 +0100 | [diff] [blame] | 401 | enddef |
| 402 | |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 403 | def Test_assign_index() |
| 404 | # list of list |
| 405 | var l1: list<number> |
| 406 | l1[0] = 123 |
| 407 | assert_equal([123], l1) |
| 408 | |
| 409 | var l2: list<list<number>> |
| 410 | l2[0] = [] |
| 411 | l2[0][0] = 123 |
| 412 | assert_equal([[123]], l2) |
| 413 | |
| 414 | var l3: list<list<list<number>>> |
| 415 | l3[0] = [] |
| 416 | l3[0][0] = [] |
| 417 | l3[0][0][0] = 123 |
| 418 | assert_equal([[[123]]], l3) |
| 419 | |
| 420 | var lines =<< trim END |
| 421 | var l3: list<list<number>> |
| 422 | l3[0] = [] |
| 423 | l3[0][0] = [] |
| 424 | END |
| 425 | CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got list<unknown>', 3) |
| 426 | |
| 427 | # dict of dict |
| 428 | var d1: dict<number> |
| 429 | d1.one = 1 |
| 430 | assert_equal({one: 1}, d1) |
| 431 | |
| 432 | var d2: dict<dict<number>> |
| 433 | d2.one = {} |
| 434 | d2.one.two = 123 |
| 435 | assert_equal({one: {two: 123}}, d2) |
| 436 | |
| 437 | var d3: dict<dict<dict<number>>> |
| 438 | d3.one = {} |
| 439 | d3.one.two = {} |
| 440 | d3.one.two.three = 123 |
| 441 | assert_equal({one: {two: {three: 123}}}, d3) |
| 442 | |
| 443 | lines =<< trim END |
| 444 | var d3: dict<dict<number>> |
| 445 | d3.one = {} |
| 446 | d3.one.two = {} |
| 447 | END |
| 448 | CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got dict<unknown>', 3) |
| 449 | |
Bram Moolenaar | acbae18 | 2020-12-13 18:44:43 +0100 | [diff] [blame] | 450 | lines =<< trim END |
| 451 | var lines: list<string> |
| 452 | lines['a'] = 'asdf' |
| 453 | END |
Bram Moolenaar | f30a14d | 2021-01-17 21:51:24 +0100 | [diff] [blame] | 454 | CheckDefFailure(lines, 'E1012:', 2) |
Bram Moolenaar | acbae18 | 2020-12-13 18:44:43 +0100 | [diff] [blame] | 455 | |
| 456 | lines =<< trim END |
| 457 | var lines: string |
| 458 | lines[9] = 'asdf' |
| 459 | END |
| 460 | CheckDefFailure(lines, 'E1141:', 2) |
| 461 | |
Bram Moolenaar | dc234ca | 2020-11-28 18:52:33 +0100 | [diff] [blame] | 462 | # list of dict |
| 463 | var ld: list<dict<number>> |
| 464 | ld[0] = {} |
| 465 | ld[0].one = 123 |
| 466 | assert_equal([{one: 123}], ld) |
| 467 | |
| 468 | lines =<< trim END |
| 469 | var ld: list<dict<number>> |
| 470 | ld[0] = [] |
| 471 | END |
| 472 | CheckDefFailure(lines, 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2) |
| 473 | |
| 474 | # dict of list |
| 475 | var dl: dict<list<number>> |
| 476 | dl.one = [] |
| 477 | dl.one[0] = 123 |
| 478 | assert_equal({one: [123]}, dl) |
| 479 | |
| 480 | lines =<< trim END |
| 481 | var dl: dict<list<number>> |
| 482 | dl.one = {} |
| 483 | END |
| 484 | CheckDefFailure(lines, 'E1012: Type mismatch; expected list<number> but got dict<unknown>', 2) |
| 485 | enddef |
| 486 | |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 487 | def Test_extend_list() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 488 | var lines =<< trim END |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 489 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 490 | var l: list<number> |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 491 | l += [123] |
| 492 | assert_equal([123], l) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 493 | END |
| 494 | CheckScriptSuccess(lines) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 495 | |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 496 | lines =<< trim END |
| 497 | vim9script |
| 498 | var list: list<string> |
| 499 | extend(list, ['x']) |
| 500 | assert_equal(['x'], list) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 501 | END |
| 502 | CheckScriptSuccess(lines) |
Bram Moolenaar | 1a73923 | 2020-10-10 15:37:58 +0200 | [diff] [blame] | 503 | |
| 504 | # appending to NULL list from a function |
| 505 | lines =<< trim END |
| 506 | vim9script |
| 507 | var list: list<string> |
| 508 | def Func() |
| 509 | list += ['a', 'b'] |
| 510 | enddef |
| 511 | Func() |
| 512 | assert_equal(['a', 'b'], list) |
| 513 | END |
| 514 | CheckScriptSuccess(lines) |
Bram Moolenaar | 3beaf9c | 2020-12-18 17:23:14 +0100 | [diff] [blame] | 515 | lines =<< trim END |
| 516 | vim9script |
| 517 | var list: list<string> |
| 518 | def Func() |
| 519 | extend(list, ['x', 'b']) |
| 520 | enddef |
| 521 | Func() |
| 522 | assert_equal(['x', 'b'], list) |
| 523 | END |
| 524 | CheckScriptSuccess(lines) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 525 | |
| 526 | lines =<< trim END |
| 527 | vim9script |
| 528 | var l: list<string> = test_null_list() |
| 529 | extend(l, ['x']) |
| 530 | assert_equal(['x'], l) |
| 531 | END |
| 532 | CheckScriptSuccess(lines) |
| 533 | |
| 534 | lines =<< trim END |
| 535 | vim9script |
| 536 | extend(test_null_list(), ['x']) |
| 537 | END |
| 538 | CheckScriptFailure(lines, 'E1134:', 2) |
| 539 | enddef |
| 540 | |
| 541 | def Test_extend_dict() |
| 542 | var lines =<< trim END |
| 543 | vim9script |
| 544 | var d: dict<number> |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 545 | extend(d, {a: 1}) |
| 546 | assert_equal({a: 1}, d) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 547 | |
| 548 | var d2: dict<number> |
| 549 | d2['one'] = 1 |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 550 | assert_equal({one: 1}, d2) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 551 | END |
| 552 | CheckScriptSuccess(lines) |
| 553 | |
| 554 | lines =<< trim END |
| 555 | vim9script |
| 556 | var d: dict<string> = test_null_dict() |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 557 | extend(d, {a: 'x'}) |
| 558 | assert_equal({a: 'x'}, d) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 559 | END |
| 560 | CheckScriptSuccess(lines) |
| 561 | |
| 562 | lines =<< trim END |
| 563 | vim9script |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 564 | extend(test_null_dict(), {a: 'x'}) |
Bram Moolenaar | 348be7e | 2020-11-04 11:36:35 +0100 | [diff] [blame] | 565 | END |
| 566 | CheckScriptFailure(lines, 'E1133:', 2) |
Bram Moolenaar | 81ed496 | 2020-09-23 15:56:50 +0200 | [diff] [blame] | 567 | enddef |
| 568 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 569 | def Test_single_letter_vars() |
| 570 | # single letter variables |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 571 | var a: number = 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 572 | a = 123 |
| 573 | assert_equal(123, a) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 574 | var b: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 575 | b = 123 |
| 576 | assert_equal(123, b) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 577 | var g: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 578 | g = 123 |
| 579 | assert_equal(123, g) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 580 | var s: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 581 | s = 123 |
| 582 | assert_equal(123, s) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 583 | var t: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 584 | t = 123 |
| 585 | assert_equal(123, t) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 586 | var v: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 587 | v = 123 |
| 588 | assert_equal(123, v) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 589 | var w: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 590 | w = 123 |
| 591 | assert_equal(123, w) |
| 592 | enddef |
| 593 | |
| 594 | def Test_vim9_single_char_vars() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 595 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 596 | vim9script |
| 597 | |
| 598 | # single character variable declarations work |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 599 | var a: string |
| 600 | var b: number |
| 601 | var l: list<any> |
| 602 | var s: string |
| 603 | var t: number |
| 604 | var v: number |
| 605 | var w: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 606 | |
| 607 | # script-local variables can be used without s: prefix |
| 608 | a = 'script-a' |
| 609 | b = 111 |
| 610 | l = [1, 2, 3] |
| 611 | s = 'script-s' |
| 612 | t = 222 |
| 613 | v = 333 |
| 614 | w = 444 |
| 615 | |
| 616 | assert_equal('script-a', a) |
| 617 | assert_equal(111, b) |
| 618 | assert_equal([1, 2, 3], l) |
| 619 | assert_equal('script-s', s) |
| 620 | assert_equal(222, t) |
| 621 | assert_equal(333, v) |
| 622 | assert_equal(444, w) |
| 623 | END |
| 624 | writefile(lines, 'Xsinglechar') |
| 625 | source Xsinglechar |
| 626 | delete('Xsinglechar') |
| 627 | enddef |
| 628 | |
| 629 | def Test_assignment_list() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 630 | var list1: list<bool> = [false, true, false] |
| 631 | var list2: list<number> = [1, 2, 3] |
| 632 | var list3: list<string> = ['sdf', 'asdf'] |
| 633 | var list4: list<any> = ['yes', true, 1234] |
| 634 | var list5: list<blob> = [0z01, 0z02] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 635 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 636 | var listS: list<string> = [] |
| 637 | var listN: list<number> = [] |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 638 | |
| 639 | assert_equal([1, 2, 3], list2) |
| 640 | list2[-1] = 99 |
| 641 | assert_equal([1, 2, 99], list2) |
| 642 | list2[-2] = 88 |
| 643 | assert_equal([1, 88, 99], list2) |
| 644 | list2[-3] = 77 |
| 645 | assert_equal([77, 88, 99], list2) |
| 646 | list2 += [100] |
| 647 | assert_equal([77, 88, 99, 100], list2) |
| 648 | |
| 649 | list3 += ['end'] |
| 650 | assert_equal(['sdf', 'asdf', 'end'], list3) |
| 651 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 652 | CheckDefExecFailure(['var ll = [1, 2, 3]', 'll[-4] = 6'], 'E684:') |
| 653 | CheckDefExecFailure(['var [v1, v2] = [1, 2]'], 'E1092:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 654 | |
| 655 | # type becomes list<any> |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 656 | var somelist = rand() > 0 ? [1, 2, 3] : ['a', 'b', 'c'] |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 657 | |
| 658 | var lines =<< trim END |
| 659 | var d = {dd: test_null_list()} |
| 660 | d.dd[0] = 0 |
| 661 | END |
| 662 | CheckDefExecFailure(lines, 'E1147:', 2) |
Bram Moolenaar | 7a40ff0 | 2021-07-04 15:54:08 +0200 | [diff] [blame] | 663 | |
| 664 | lines =<< trim END |
| 665 | def OneArg(x: bool) |
| 666 | enddef |
| 667 | def TwoArgs(x: bool, y: bool) |
| 668 | enddef |
| 669 | var fl: list<func(bool, bool, bool)> = [OneArg, TwoArgs] |
| 670 | END |
| 671 | CheckDefExecAndScriptFailure(lines, 'E1012:', 5) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 672 | enddef |
| 673 | |
Bram Moolenaar | 97f227d | 2021-07-04 20:20:52 +0200 | [diff] [blame] | 674 | def PartFuncBool(b: bool): string |
Bram Moolenaar | b7480cd | 2021-07-04 18:28:15 +0200 | [diff] [blame] | 675 | return 'done' |
| 676 | enddef |
| 677 | |
| 678 | def Test_assignment_partial() |
Bram Moolenaar | 97f227d | 2021-07-04 20:20:52 +0200 | [diff] [blame] | 679 | var lines =<< trim END |
| 680 | var Partial: func(): string = function(PartFuncBool, [true]) |
| 681 | assert_equal('done', Partial()) |
| 682 | END |
| 683 | CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 22f85d0 | 2021-07-04 23:29:30 +0200 | [diff] [blame] | 684 | |
| 685 | lines =<< trim END |
| 686 | vim9script |
| 687 | def Func(b: bool) |
| 688 | enddef |
| 689 | var Ref: func = function(Func, [true]) |
| 690 | assert_equal('func()', typename(Ref)) |
| 691 | Ref() |
| 692 | END |
| 693 | CheckScriptSuccess(lines) |
Bram Moolenaar | b7480cd | 2021-07-04 18:28:15 +0200 | [diff] [blame] | 694 | enddef |
| 695 | |
Bram Moolenaar | f30a14d | 2021-01-17 21:51:24 +0100 | [diff] [blame] | 696 | def Test_assignment_list_any_index() |
| 697 | var l: list<number> = [1, 2] |
| 698 | for [x, y, _] |
| 699 | in [[0, 1, ''], [1, 3, '']] |
| 700 | l[x] = l[x] + y |
| 701 | endfor |
| 702 | assert_equal([2, 5], l) |
| 703 | enddef |
| 704 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 705 | def Test_assignment_list_vim9script() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 706 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 707 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 708 | var v1: number |
| 709 | var v2: number |
| 710 | var v3: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 711 | [v1, v2, v3] = [1, 2, 3] |
| 712 | assert_equal([1, 2, 3], [v1, v2, v3]) |
| 713 | END |
| 714 | CheckScriptSuccess(lines) |
| 715 | enddef |
| 716 | |
| 717 | def Test_assignment_dict() |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 718 | var dict1: dict<bool> = {one: false, two: true} |
| 719 | var dict2: dict<number> = {one: 1, two: 2} |
| 720 | var dict3: dict<string> = {key: 'value'} |
| 721 | var dict4: dict<any> = {one: 1, two: '2'} |
| 722 | var dict5: dict<blob> = {one: 0z01, two: 0z02} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 723 | |
| 724 | # overwrite |
| 725 | dict3['key'] = 'another' |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 726 | assert_equal(dict3, {key: 'another'}) |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 727 | dict3.key = 'yet another' |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 728 | assert_equal(dict3, {key: 'yet another'}) |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 729 | |
Bram Moolenaar | d24602f | 2020-12-20 15:20:56 +0100 | [diff] [blame] | 730 | # member "any" can also be a dict and assigned to |
| 731 | var anydict: dict<any> = {nest: {}, nr: 0} |
| 732 | anydict.nest['this'] = 123 |
| 733 | anydict.nest.that = 456 |
| 734 | assert_equal({nest: {this: 123, that: 456}, nr: 0}, anydict) |
| 735 | |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 736 | var lines =<< trim END |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 737 | var dd = {} |
| 738 | dd.two = 2 |
| 739 | assert_equal({two: 2}, dd) |
| 740 | END |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 741 | CheckDefAndScriptSuccess(lines) |
| 742 | |
| 743 | lines =<< trim END |
| 744 | var d = {dd: {}} |
| 745 | d.dd[0] = 2 |
| 746 | d.dd['x'] = 3 |
| 747 | d.dd.y = 4 |
| 748 | assert_equal({dd: {0: 2, x: 3, y: 4}}, d) |
| 749 | END |
| 750 | CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 751 | |
| 752 | lines =<< trim END |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 753 | var dd = {one: 1} |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 754 | dd.one) = 2 |
| 755 | END |
Bram Moolenaar | d88dc4d | 2020-12-20 14:49:42 +0100 | [diff] [blame] | 756 | CheckDefFailure(lines, 'E488:', 2) |
| 757 | |
| 758 | lines =<< trim END |
| 759 | var dd = {one: 1} |
| 760 | var dd.one = 2 |
| 761 | END |
| 762 | CheckDefAndScriptFailure(lines, 'E1017:', 2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 763 | |
| 764 | # empty key can be used |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 765 | var dd = {} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 766 | dd[""] = 6 |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 767 | assert_equal({['']: 6}, dd) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 768 | |
| 769 | # type becomes dict<any> |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 770 | var somedict = rand() > 0 ? {a: 1, b: 2} : {a: 'a', b: 'b'} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 771 | |
| 772 | # assignment to script-local dict |
Bram Moolenaar | fc74d03 | 2020-11-16 22:11:49 +0100 | [diff] [blame] | 773 | lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 774 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 775 | var test: dict<any> = {} |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 776 | def FillDict(): dict<any> |
| 777 | test['a'] = 43 |
| 778 | return test |
| 779 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 780 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 781 | END |
| 782 | CheckScriptSuccess(lines) |
| 783 | |
| 784 | lines =<< trim END |
| 785 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 786 | var test: dict<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 787 | def FillDict(): dict<any> |
| 788 | test['a'] = 43 |
| 789 | return test |
| 790 | enddef |
| 791 | FillDict() |
Bram Moolenaar | 3beaf9c | 2020-12-18 17:23:14 +0100 | [diff] [blame] | 792 | assert_equal({a: 43}, test) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 793 | END |
Bram Moolenaar | 3beaf9c | 2020-12-18 17:23:14 +0100 | [diff] [blame] | 794 | CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 795 | |
| 796 | # assignment to global dict |
| 797 | lines =<< trim END |
| 798 | vim9script |
| 799 | g:test = {} |
| 800 | def FillDict(): dict<any> |
| 801 | g:test['a'] = 43 |
| 802 | return g:test |
| 803 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 804 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 805 | END |
| 806 | CheckScriptSuccess(lines) |
| 807 | |
| 808 | # assignment to buffer dict |
| 809 | lines =<< trim END |
| 810 | vim9script |
| 811 | b:test = {} |
| 812 | def FillDict(): dict<any> |
| 813 | b:test['a'] = 43 |
| 814 | return b:test |
| 815 | enddef |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 816 | assert_equal({a: 43}, FillDict()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 817 | END |
| 818 | CheckScriptSuccess(lines) |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 819 | |
| 820 | lines =<< trim END |
| 821 | var d = {dd: test_null_dict()} |
| 822 | d.dd[0] = 0 |
| 823 | END |
| 824 | CheckDefExecFailure(lines, 'E1103:', 2) |
| 825 | |
| 826 | lines =<< trim END |
| 827 | var d = {dd: 'string'} |
| 828 | d.dd[0] = 0 |
| 829 | END |
| 830 | CheckDefExecFailure(lines, 'E1148:', 2) |
Bram Moolenaar | 3a3b10e | 2021-06-26 15:00:59 +0200 | [diff] [blame] | 831 | |
| 832 | lines =<< trim END |
| 833 | var n: any |
| 834 | n.key = 5 |
| 835 | END |
| 836 | CheckDefExecAndScriptFailure2(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] | 837 | enddef |
| 838 | |
| 839 | def Test_assignment_local() |
| 840 | # Test in a separated file in order not to the current buffer/window/tab is |
| 841 | # changed. |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 842 | var script_lines: list<string> =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 843 | let b:existing = 'yes' |
| 844 | let w:existing = 'yes' |
| 845 | let t:existing = 'yes' |
| 846 | |
| 847 | def Test_assignment_local_internal() |
| 848 | b:newvar = 'new' |
| 849 | assert_equal('new', b:newvar) |
| 850 | assert_equal('yes', b:existing) |
| 851 | b:existing = 'no' |
| 852 | assert_equal('no', b:existing) |
| 853 | b:existing ..= 'NO' |
| 854 | assert_equal('noNO', b:existing) |
| 855 | |
| 856 | w:newvar = 'new' |
| 857 | assert_equal('new', w:newvar) |
| 858 | assert_equal('yes', w:existing) |
| 859 | w:existing = 'no' |
| 860 | assert_equal('no', w:existing) |
| 861 | w:existing ..= 'NO' |
| 862 | assert_equal('noNO', w:existing) |
| 863 | |
| 864 | t:newvar = 'new' |
| 865 | assert_equal('new', t:newvar) |
| 866 | assert_equal('yes', t:existing) |
| 867 | t:existing = 'no' |
| 868 | assert_equal('no', t:existing) |
| 869 | t:existing ..= 'NO' |
| 870 | assert_equal('noNO', t:existing) |
| 871 | enddef |
| 872 | call Test_assignment_local_internal() |
| 873 | END |
| 874 | CheckScriptSuccess(script_lines) |
| 875 | enddef |
| 876 | |
| 877 | def Test_assignment_default() |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 878 | # Test default values. |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 879 | var thebool: bool |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 880 | assert_equal(v:false, thebool) |
| 881 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 882 | var thenumber: number |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 883 | assert_equal(0, thenumber) |
| 884 | |
| 885 | if has('float') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 886 | var thefloat: float |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 887 | assert_equal(0.0, thefloat) |
| 888 | endif |
| 889 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 890 | var thestring: string |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 891 | assert_equal('', thestring) |
| 892 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 893 | var theblob: blob |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 894 | assert_equal(0z, theblob) |
| 895 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 896 | var Thefunc: func |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 897 | assert_equal(test_null_function(), Thefunc) |
| 898 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 899 | var thelist: list<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 900 | assert_equal([], thelist) |
| 901 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 902 | var thedict: dict<any> |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 903 | assert_equal({}, thedict) |
| 904 | |
| 905 | if has('channel') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 906 | var thejob: job |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 907 | assert_equal(test_null_job(), thejob) |
| 908 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 909 | var thechannel: channel |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 910 | assert_equal(test_null_channel(), thechannel) |
| 911 | |
| 912 | if has('unix') && executable('cat') |
| 913 | # check with non-null job and channel, types must match |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 914 | thejob = job_start("cat ", {}) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 915 | thechannel = job_getchannel(thejob) |
| 916 | job_stop(thejob, 'kill') |
| 917 | endif |
| 918 | endif |
| 919 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 920 | var nr = 1234 | nr = 5678 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 921 | assert_equal(5678, nr) |
| 922 | enddef |
| 923 | |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 924 | let scriptvar = 'init' |
| 925 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 926 | def Test_assignment_var_list() |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 927 | var lines =<< trim END |
| 928 | var v1: string |
| 929 | var v2: string |
| 930 | var vrem: list<string> |
| 931 | [v1] = ['aaa'] |
| 932 | assert_equal('aaa', v1) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 933 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 934 | [v1, v2] = ['one', 'two'] |
| 935 | assert_equal('one', v1) |
| 936 | assert_equal('two', v2) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 937 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 938 | [v1, v2; vrem] = ['one', 'two'] |
| 939 | assert_equal('one', v1) |
| 940 | assert_equal('two', v2) |
| 941 | assert_equal([], vrem) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 942 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 943 | [v1, v2; vrem] = ['one', 'two', 'three'] |
| 944 | assert_equal('one', v1) |
| 945 | assert_equal('two', v2) |
| 946 | assert_equal(['three'], vrem) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 947 | |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 948 | [&ts, &sw] = [3, 4] |
| 949 | assert_equal(3, &ts) |
| 950 | assert_equal(4, &sw) |
| 951 | set ts=8 sw=4 |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 952 | |
| 953 | [@a, @z] = ['aa', 'zz'] |
| 954 | assert_equal('aa', @a) |
| 955 | assert_equal('zz', @z) |
| 956 | |
| 957 | [$SOME_VAR, $OTHER_VAR] = ['some', 'other'] |
| 958 | assert_equal('some', $SOME_VAR) |
| 959 | assert_equal('other', $OTHER_VAR) |
| 960 | |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 961 | [g:globalvar, b:bufvar, w:winvar, t:tabvar, v:errmsg] = |
| 962 | ['global', 'buf', 'win', 'tab', 'error'] |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 963 | assert_equal('global', g:globalvar) |
Bram Moolenaar | 004d9b0 | 2020-11-30 21:40:03 +0100 | [diff] [blame] | 964 | assert_equal('buf', b:bufvar) |
| 965 | assert_equal('win', w:winvar) |
| 966 | assert_equal('tab', t:tabvar) |
| 967 | assert_equal('error', v:errmsg) |
| 968 | unlet g:globalvar |
Bram Moolenaar | da7c20c | 2020-11-30 21:12:19 +0100 | [diff] [blame] | 969 | END |
| 970 | CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 971 | |
| 972 | [g:globalvar, s:scriptvar, b:bufvar] = ['global', 'script', 'buf'] |
| 973 | assert_equal('global', g:globalvar) |
| 974 | assert_equal('script', s:scriptvar) |
| 975 | assert_equal('buf', b:bufvar) |
| 976 | |
| 977 | lines =<< trim END |
| 978 | vim9script |
| 979 | var s:scriptvar = 'init' |
| 980 | [g:globalvar, s:scriptvar, w:winvar] = ['global', 'script', 'win'] |
| 981 | assert_equal('global', g:globalvar) |
| 982 | assert_equal('script', s:scriptvar) |
| 983 | assert_equal('win', w:winvar) |
| 984 | END |
| 985 | CheckScriptSuccess(lines) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 986 | enddef |
| 987 | |
| 988 | def Test_assignment_vim9script() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 989 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 990 | vim9script |
| 991 | def Func(): list<number> |
| 992 | return [1, 2] |
| 993 | enddef |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 994 | var name1: number |
| 995 | var name2: number |
| 996 | [name1, name2] = |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 997 | Func() |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 998 | assert_equal(1, name1) |
| 999 | assert_equal(2, name2) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1000 | var ll = |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1001 | Func() |
| 1002 | assert_equal([1, 2], ll) |
| 1003 | |
| 1004 | @/ = 'text' |
| 1005 | assert_equal('text', @/) |
| 1006 | @0 = 'zero' |
| 1007 | assert_equal('zero', @0) |
| 1008 | @1 = 'one' |
| 1009 | assert_equal('one', @1) |
| 1010 | @9 = 'nine' |
| 1011 | assert_equal('nine', @9) |
| 1012 | @- = 'minus' |
| 1013 | assert_equal('minus', @-) |
| 1014 | if has('clipboard_working') |
| 1015 | @* = 'star' |
| 1016 | assert_equal('star', @*) |
| 1017 | @+ = 'plus' |
| 1018 | assert_equal('plus', @+) |
| 1019 | endif |
| 1020 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1021 | var a: number = 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1022 | assert_equal(123, a) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1023 | var s: string = 'yes' |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1024 | assert_equal('yes', s) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1025 | var b: number = 42 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1026 | assert_equal(42, b) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1027 | var w: number = 43 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1028 | assert_equal(43, w) |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1029 | var t: number = 44 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1030 | assert_equal(44, t) |
Bram Moolenaar | 7a66a17 | 2020-10-16 19:56:12 +0200 | [diff] [blame] | 1031 | |
| 1032 | var to_var = 0 |
| 1033 | to_var = 3 |
| 1034 | assert_equal(3, to_var) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1035 | END |
| 1036 | CheckScriptSuccess(lines) |
Bram Moolenaar | 06f9c69 | 2020-09-27 21:27:40 +0200 | [diff] [blame] | 1037 | |
| 1038 | lines =<< trim END |
| 1039 | vim9script |
| 1040 | var n: number |
| 1041 | def Func() |
| 1042 | n = 'string' |
| 1043 | enddef |
| 1044 | defcompile |
| 1045 | END |
| 1046 | CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got string') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1047 | enddef |
| 1048 | |
| 1049 | def Mess(): string |
| 1050 | v:foldstart = 123 |
| 1051 | return 'xxx' |
| 1052 | enddef |
| 1053 | |
| 1054 | def Test_assignment_failure() |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1055 | CheckDefFailure(['var name=234'], 'E1004:') |
| 1056 | CheckDefFailure(['var name =234'], 'E1004:') |
| 1057 | CheckDefFailure(['var name= 234'], 'E1004:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1058 | |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1059 | CheckScriptFailure(['vim9script', 'var name=234'], 'E1004:') |
| 1060 | CheckScriptFailure(['vim9script', 'var name=234'], "before and after '='") |
| 1061 | CheckScriptFailure(['vim9script', 'var name =234'], 'E1004:') |
| 1062 | CheckScriptFailure(['vim9script', 'var name= 234'], 'E1004:') |
| 1063 | CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], 'E1004:') |
| 1064 | CheckScriptFailure(['vim9script', 'var name = 234', 'name+=234'], "before and after '+='") |
| 1065 | CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], 'E1004:') |
| 1066 | CheckScriptFailure(['vim9script', 'var name = "x"', 'name..="y"'], "before and after '..='") |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1067 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1068 | CheckDefFailure(['var true = 1'], 'E1034:') |
| 1069 | CheckDefFailure(['var false = 1'], 'E1034:') |
Bram Moolenaar | 7423577 | 2021-06-12 14:53:05 +0200 | [diff] [blame] | 1070 | CheckDefFailure(['var null = 1'], 'E1034:') |
| 1071 | CheckDefFailure(['var this = 1'], 'E1034:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1072 | |
| 1073 | CheckDefFailure(['[a; b; c] = g:list'], 'E452:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1074 | CheckDefExecFailure(['var a: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1075 | '[a] = test_null_list()'], 'E1093:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1076 | CheckDefExecFailure(['var a: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1077 | '[a] = []'], 'E1093:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1078 | CheckDefExecFailure(['var x: number', |
| 1079 | 'var y: number', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1080 | '[x, y] = [1]'], 'E1093:') |
Bram Moolenaar | 352134b | 2020-10-17 22:04:08 +0200 | [diff] [blame] | 1081 | CheckDefExecFailure(['var x: string', |
| 1082 | 'var y: string', |
| 1083 | '[x, y] = ["x"]'], 'E1093:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1084 | CheckDefExecFailure(['var x: number', |
| 1085 | 'var y: number', |
| 1086 | 'var z: list<number>', |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1087 | '[x, y; z] = [1]'], 'E1093:') |
| 1088 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1089 | CheckDefFailure(['var somevar'], "E1022:") |
| 1090 | CheckDefFailure(['var &tabstop = 4'], 'E1052:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1091 | CheckDefFailure(['&g:option = 5'], 'E113:') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1092 | CheckScriptFailure(['vim9script', 'var &tabstop = 4'], 'E1052:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1093 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1094 | CheckDefFailure(['var $VAR = 5'], 'E1016: Cannot declare an environment variable:') |
| 1095 | CheckScriptFailure(['vim9script', 'var $ENV = "xxx"'], 'E1016:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1096 | |
| 1097 | if has('dnd') |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1098 | CheckDefFailure(['var @~ = 5'], 'E1066:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1099 | else |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1100 | CheckDefFailure(['var @~ = 5'], 'E354:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1101 | CheckDefFailure(['@~ = 5'], 'E354:') |
| 1102 | endif |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1103 | CheckDefFailure(['var @a = 5'], 'E1066:') |
| 1104 | CheckDefFailure(['var @/ = "x"'], 'E1066:') |
| 1105 | CheckScriptFailure(['vim9script', 'var @a = "abc"'], 'E1066:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1106 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1107 | CheckDefFailure(['var g:var = 5'], 'E1016: Cannot declare a global variable:') |
| 1108 | CheckDefFailure(['var w:var = 5'], 'E1016: Cannot declare a window variable:') |
| 1109 | CheckDefFailure(['var b:var = 5'], 'E1016: Cannot declare a buffer variable:') |
| 1110 | CheckDefFailure(['var t:var = 5'], 'E1016: Cannot declare a tab variable:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1111 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1112 | CheckDefFailure(['var anr = 4', 'anr ..= "text"'], 'E1019:') |
| 1113 | CheckDefFailure(['var xnr += 4'], 'E1020:', 1) |
| 1114 | CheckScriptFailure(['vim9script', 'var xnr += 4'], 'E1020:') |
| 1115 | CheckDefFailure(["var xnr = xnr + 1"], 'E1001:', 1) |
| 1116 | CheckScriptFailure(['vim9script', 'var xnr = xnr + 4'], 'E121:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1117 | |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1118 | CheckScriptFailure(['vim9script', 'def Func()', 'var dummy = s:notfound', 'enddef', 'defcompile'], 'E1108:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1119 | |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1120 | CheckDefFailure(['var name: list<string> = [123]'], 'expected list<string> but got list<number>') |
| 1121 | 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] | 1122 | |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1123 | CheckDefFailure(['var name: dict<string> = {key: 123}'], 'expected dict<string> but got dict<number>') |
| 1124 | 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] | 1125 | |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1126 | CheckDefFailure(['var name = feedkeys("0")'], 'E1031:') |
| 1127 | CheckDefFailure(['var name: number = feedkeys("0")'], 'expected number but got void') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1128 | |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1129 | CheckDefFailure(['var name: dict <number>'], 'E1068:') |
| 1130 | CheckDefFailure(['var name: dict<number'], 'E1009:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1131 | |
| 1132 | assert_fails('s/^/\=Mess()/n', 'E794:') |
Bram Moolenaar | 9830938 | 2020-09-27 21:58:45 +0200 | [diff] [blame] | 1133 | CheckDefFailure(['var name: dict<number'], 'E1009:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1134 | |
| 1135 | CheckDefFailure(['w:foo: number = 10'], |
| 1136 | 'E488: Trailing characters: : number = 1') |
| 1137 | CheckDefFailure(['t:foo: bool = true'], |
| 1138 | 'E488: Trailing characters: : bool = true') |
| 1139 | CheckDefFailure(['b:foo: string = "x"'], |
| 1140 | 'E488: Trailing characters: : string = "x"') |
| 1141 | CheckDefFailure(['g:foo: number = 123'], |
| 1142 | 'E488: Trailing characters: : number = 123') |
| 1143 | enddef |
| 1144 | |
| 1145 | def Test_assign_list() |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1146 | var lines =<< trim END |
| 1147 | var l: list<string> = [] |
| 1148 | l[0] = 'value' |
| 1149 | assert_equal('value', l[0]) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1150 | |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1151 | l[1] = 'asdf' |
| 1152 | assert_equal('value', l[0]) |
| 1153 | assert_equal('asdf', l[1]) |
| 1154 | assert_equal('asdf', l[-1]) |
| 1155 | assert_equal('value', l[-2]) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1156 | |
Bram Moolenaar | e65081d | 2021-06-27 15:04:05 +0200 | [diff] [blame] | 1157 | var nrl: list<number> = [] |
| 1158 | for i in range(5) |
| 1159 | nrl[i] = i |
| 1160 | endfor |
| 1161 | assert_equal([0, 1, 2, 3, 4], nrl) |
| 1162 | |
| 1163 | var ul: list<any> |
| 1164 | ul[0] = 1 |
| 1165 | ul[1] = 2 |
| 1166 | ul[2] = 3 |
| 1167 | assert_equal([1, 2, 3], ul) |
| 1168 | END |
| 1169 | CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 334a8b4 | 2020-10-19 16:07:42 +0200 | [diff] [blame] | 1170 | |
| 1171 | CheckDefFailure(["var l: list<number> = ['', true]"], 'E1012: Type mismatch; expected list<number> but got list<any>', 1) |
| 1172 | 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] | 1173 | enddef |
| 1174 | |
| 1175 | def Test_assign_dict() |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1176 | var lines =<< trim END |
| 1177 | var d: dict<string> = {} |
| 1178 | d['key'] = 'value' |
| 1179 | assert_equal('value', d['key']) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1180 | |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1181 | d[123] = 'qwerty' |
| 1182 | assert_equal('qwerty', d[123]) |
| 1183 | assert_equal('qwerty', d['123']) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1184 | |
Bram Moolenaar | c368957 | 2021-01-01 19:40:02 +0100 | [diff] [blame] | 1185 | var nrd: dict<number> = {} |
| 1186 | for i in range(3) |
| 1187 | nrd[i] = i |
| 1188 | endfor |
| 1189 | assert_equal({0: 0, 1: 1, 2: 2}, nrd) |
| 1190 | |
| 1191 | d.somekey = 'someval' |
| 1192 | assert_equal({key: 'value', '123': 'qwerty', somekey: 'someval'}, d) |
| 1193 | # unlet d.somekey |
| 1194 | # assert_equal({key: 'value', '123': 'qwerty'}, d) |
| 1195 | END |
| 1196 | CheckDefAndScriptSuccess(lines) |
| 1197 | |
| 1198 | # TODO: move to above once "unlet d.somekey" in :def is implemented |
| 1199 | lines =<< trim END |
| 1200 | vim9script |
| 1201 | var d: dict<string> = {} |
| 1202 | d['key'] = 'value' |
| 1203 | d.somekey = 'someval' |
| 1204 | assert_equal({key: 'value', somekey: 'someval'}, d) |
| 1205 | unlet d.somekey |
| 1206 | assert_equal({key: 'value'}, d) |
| 1207 | END |
| 1208 | CheckScriptSuccess(lines) |
Bram Moolenaar | 334a8b4 | 2020-10-19 16:07:42 +0200 | [diff] [blame] | 1209 | |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1210 | CheckDefFailure(["var d: dict<number> = {a: '', b: true}"], 'E1012: Type mismatch; expected dict<number> but got dict<any>', 1) |
| 1211 | 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 | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1212 | enddef |
| 1213 | |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1214 | def Test_assign_dict_unknown_type() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1215 | var lines =<< trim END |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1216 | vim9script |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1217 | var mylist = [] |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1218 | mylist += [{one: 'one'}] |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1219 | def Func() |
Bram Moolenaar | 30fd820 | 2020-09-26 15:09:30 +0200 | [diff] [blame] | 1220 | var dd = mylist[0] |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1221 | assert_equal('one', dd.one) |
| 1222 | enddef |
| 1223 | Func() |
| 1224 | END |
| 1225 | CheckScriptSuccess(lines) |
| 1226 | |
Bram Moolenaar | ce2c544 | 2020-11-28 21:21:17 +0100 | [diff] [blame] | 1227 | lines =<< trim END |
| 1228 | vim9script |
| 1229 | var mylist = [[]] |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1230 | mylist[0] += [{one: 'one'}] |
Bram Moolenaar | ce2c544 | 2020-11-28 21:21:17 +0100 | [diff] [blame] | 1231 | def Func() |
| 1232 | var dd = mylist[0][0] |
| 1233 | assert_equal('one', dd.one) |
| 1234 | enddef |
| 1235 | Func() |
| 1236 | END |
| 1237 | CheckScriptSuccess(lines) |
Bram Moolenaar | 04bdd57 | 2020-09-23 13:25:32 +0200 | [diff] [blame] | 1238 | enddef |
| 1239 | |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1240 | def Test_assign_dict_with_op() |
| 1241 | var lines =<< trim END |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1242 | var ds: dict<string> = {a: 'x'} |
| 1243 | ds['a'] ..= 'y' |
| 1244 | ds.a ..= 'z' |
| 1245 | assert_equal('xyz', ds.a) |
| 1246 | |
| 1247 | var dn: dict<number> = {a: 9} |
| 1248 | dn['a'] += 2 |
| 1249 | assert_equal(11, dn.a) |
| 1250 | dn.a += 2 |
| 1251 | assert_equal(13, dn.a) |
| 1252 | |
| 1253 | dn['a'] -= 3 |
| 1254 | assert_equal(10, dn.a) |
| 1255 | dn.a -= 2 |
| 1256 | assert_equal(8, dn.a) |
| 1257 | |
| 1258 | dn['a'] *= 2 |
| 1259 | assert_equal(16, dn.a) |
| 1260 | dn.a *= 2 |
| 1261 | assert_equal(32, dn.a) |
| 1262 | |
| 1263 | dn['a'] /= 3 |
| 1264 | assert_equal(10, dn.a) |
| 1265 | dn.a /= 2 |
| 1266 | assert_equal(5, dn.a) |
| 1267 | |
| 1268 | dn['a'] %= 3 |
| 1269 | assert_equal(2, dn.a) |
| 1270 | dn.a %= 6 |
| 1271 | assert_equal(2, dn.a) |
Bram Moolenaar | b9c0cd8 | 2021-04-05 20:51:00 +0200 | [diff] [blame] | 1272 | |
| 1273 | var dd: dict<dict<list<any>>> |
| 1274 | dd.a = {} |
| 1275 | dd.a.b = [0] |
| 1276 | dd.a.b += [1] |
| 1277 | assert_equal({a: {b: [0, 1]}}, dd) |
Bram Moolenaar | 0d351a0 | 2021-04-05 21:05:26 +0200 | [diff] [blame] | 1278 | |
| 1279 | var dab = {a: ['b']} |
| 1280 | dab.a[0] ..= 'c' |
| 1281 | assert_equal({a: ['bc']}, dab) |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1282 | END |
Bram Moolenaar | e42939a | 2021-04-05 17:11:17 +0200 | [diff] [blame] | 1283 | CheckDefAndScriptSuccess(lines) |
| 1284 | enddef |
| 1285 | |
| 1286 | def Test_assign_list_with_op() |
| 1287 | var lines =<< trim END |
| 1288 | var ls: list<string> = ['x'] |
| 1289 | ls[0] ..= 'y' |
| 1290 | assert_equal('xy', ls[0]) |
| 1291 | |
| 1292 | var ln: list<number> = [9] |
| 1293 | ln[0] += 2 |
| 1294 | assert_equal(11, ln[0]) |
| 1295 | |
| 1296 | ln[0] -= 3 |
| 1297 | assert_equal(8, ln[0]) |
| 1298 | |
| 1299 | ln[0] *= 2 |
| 1300 | assert_equal(16, ln[0]) |
| 1301 | |
| 1302 | ln[0] /= 3 |
| 1303 | assert_equal(5, ln[0]) |
| 1304 | |
| 1305 | ln[0] %= 3 |
| 1306 | assert_equal(2, ln[0]) |
| 1307 | END |
| 1308 | CheckDefAndScriptSuccess(lines) |
| 1309 | enddef |
| 1310 | |
| 1311 | def Test_assign_with_op_fails() |
| 1312 | var lines =<< trim END |
| 1313 | var s = 'abc' |
| 1314 | s[1] += 'x' |
| 1315 | END |
| 1316 | CheckDefAndScriptFailure2(lines, 'E1141:', 'E689:', 2) |
| 1317 | |
| 1318 | lines =<< trim END |
| 1319 | var s = 'abc' |
| 1320 | s[1] ..= 'x' |
| 1321 | END |
| 1322 | CheckDefAndScriptFailure2(lines, 'E1141:', 'E689:', 2) |
Bram Moolenaar | b9c0cd8 | 2021-04-05 20:51:00 +0200 | [diff] [blame] | 1323 | |
| 1324 | lines =<< trim END |
| 1325 | var dd: dict<dict<list<any>>> |
| 1326 | dd.a = {} |
| 1327 | dd.a.b += [1] |
| 1328 | END |
| 1329 | CheckDefExecAndScriptFailure(lines, 'E716:', 3) |
Bram Moolenaar | f76ec1e | 2021-03-03 17:58:16 +0100 | [diff] [blame] | 1330 | enddef |
| 1331 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1332 | def Test_assign_lambda() |
| 1333 | # 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] | 1334 | var lines =<< trim END |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1335 | vim9script |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1336 | var FuncRef = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1337 | assert_equal(123, FuncRef()) |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1338 | var FuncRef_Func: func = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1339 | assert_equal(123, FuncRef_Func()) |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1340 | var FuncRef_Any: any = () => 123 |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1341 | assert_equal(123, FuncRef_Any()) |
Bram Moolenaar | 0640950 | 2021-02-17 17:00:27 +0100 | [diff] [blame] | 1342 | var FuncRef_Number: func(): number = () => 321 |
| 1343 | assert_equal(321, FuncRef_Number()) |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1344 | END |
| 1345 | CheckScriptSuccess(lines) |
Bram Moolenaar | 328eac2 | 2021-01-07 19:23:08 +0100 | [diff] [blame] | 1346 | |
| 1347 | lines =<< trim END |
| 1348 | var Ref: func(number) |
| 1349 | Ref = (j) => !j |
| 1350 | END |
Bram Moolenaar | 0640950 | 2021-02-17 17:00:27 +0100 | [diff] [blame] | 1351 | 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] | 1352 | |
| 1353 | lines =<< trim END |
| 1354 | echo filter([1, 2, 3], (_, v: string) => v + 1) |
| 1355 | END |
| 1356 | CheckDefAndScriptFailure(lines, 'E1051:') |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1357 | enddef |
| 1358 | |
Bram Moolenaar | c0e2901 | 2020-09-27 14:22:48 +0200 | [diff] [blame] | 1359 | def Test_heredoc() |
| 1360 | var lines =<< trim END # comment |
| 1361 | text |
| 1362 | END |
| 1363 | assert_equal(['text'], lines) |
| 1364 | |
| 1365 | CheckDefFailure(['var lines =<< trim END X', 'END'], 'E488:') |
| 1366 | CheckDefFailure(['var lines =<< trim END " comment', 'END'], 'E488:') |
Bram Moolenaar | 2914a20 | 2020-09-27 18:24:03 +0200 | [diff] [blame] | 1367 | |
| 1368 | lines =<< trim [END] |
| 1369 | def Func() |
| 1370 | var&lines =<< trim END |
| 1371 | x |
| 1372 | x |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 1373 | enddef |
| 1374 | defcompile |
| 1375 | [END] |
| 1376 | CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END') |
| 1377 | delfunc! g:Func |
| 1378 | |
| 1379 | lines =<< trim [END] |
| 1380 | def Func() |
| 1381 | var lines =<< trim END |
| 1382 | x |
| 1383 | x |
Bram Moolenaar | 2914a20 | 2020-09-27 18:24:03 +0200 | [diff] [blame] | 1384 | x |
| 1385 | x |
| 1386 | x |
| 1387 | x |
| 1388 | x |
| 1389 | x |
| 1390 | enddef |
| 1391 | call Func() |
| 1392 | [END] |
Bram Moolenaar | b5b9480 | 2020-12-13 17:50:20 +0100 | [diff] [blame] | 1393 | CheckScriptFailure(lines, 'E1145: Missing heredoc end marker: END') |
Bram Moolenaar | 2d870f8 | 2020-12-05 13:41:01 +0100 | [diff] [blame] | 1394 | delfunc! g:Func |
Bram Moolenaar | c0e2901 | 2020-09-27 14:22:48 +0200 | [diff] [blame] | 1395 | enddef |
| 1396 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1397 | def Test_var_func_call() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1398 | var lines =<< trim END |
| 1399 | vim9script |
| 1400 | func GetValue() |
| 1401 | if exists('g:count') |
| 1402 | let g:count += 1 |
| 1403 | else |
| 1404 | let g:count = 1 |
| 1405 | endif |
| 1406 | return 'this' |
| 1407 | endfunc |
| 1408 | var val: string = GetValue() |
| 1409 | # env var is always a string |
| 1410 | var env = $TERM |
| 1411 | END |
| 1412 | writefile(lines, 'Xfinished') |
| 1413 | source Xfinished |
| 1414 | # GetValue() is not called during discovery phase |
| 1415 | assert_equal(1, g:count) |
| 1416 | |
| 1417 | unlet g:count |
| 1418 | delete('Xfinished') |
| 1419 | enddef |
| 1420 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1421 | def Test_var_missing_type() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1422 | var lines =<< trim END |
| 1423 | vim9script |
| 1424 | var name = g:unknown |
| 1425 | END |
| 1426 | CheckScriptFailure(lines, 'E121:') |
| 1427 | |
| 1428 | lines =<< trim END |
| 1429 | vim9script |
| 1430 | var nr: number = 123 |
| 1431 | var name = nr |
| 1432 | END |
| 1433 | CheckScriptSuccess(lines) |
| 1434 | enddef |
| 1435 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1436 | def Test_var_declaration() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1437 | var lines =<< trim END |
| 1438 | vim9script |
| 1439 | var name: string |
| 1440 | g:var_uninit = name |
| 1441 | name = 'text' |
| 1442 | g:var_test = name |
| 1443 | # prefixing s: is optional |
| 1444 | s:name = 'prefixed' |
| 1445 | g:var_prefixed = s:name |
| 1446 | |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 1447 | const FOO: number = 123 |
| 1448 | assert_equal(123, FOO) |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1449 | const FOOS = 'foos' |
| 1450 | assert_equal('foos', FOOS) |
| 1451 | final FLIST = [1] |
| 1452 | assert_equal([1], FLIST) |
| 1453 | FLIST[0] = 11 |
| 1454 | assert_equal([11], FLIST) |
| 1455 | |
| 1456 | const g:FOO: number = 321 |
| 1457 | assert_equal(321, g:FOO) |
| 1458 | const g:FOOS = 'gfoos' |
| 1459 | assert_equal('gfoos', g:FOOS) |
| 1460 | final g:FLIST = [2] |
| 1461 | assert_equal([2], g:FLIST) |
| 1462 | g:FLIST[0] = 22 |
| 1463 | assert_equal([22], g:FLIST) |
| 1464 | |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 1465 | def SetGlobalConst() |
| 1466 | const g:globConst = 123 |
| 1467 | enddef |
| 1468 | SetGlobalConst() |
| 1469 | assert_equal(123, g:globConst) |
| 1470 | assert_true(islocked('g:globConst')) |
| 1471 | |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1472 | const w:FOO: number = 46 |
| 1473 | assert_equal(46, w:FOO) |
| 1474 | const w:FOOS = 'wfoos' |
| 1475 | assert_equal('wfoos', w:FOOS) |
| 1476 | final w:FLIST = [3] |
| 1477 | assert_equal([3], w:FLIST) |
| 1478 | w:FLIST[0] = 33 |
| 1479 | assert_equal([33], w:FLIST) |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 1480 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1481 | var s:other: number |
| 1482 | other = 1234 |
| 1483 | g:other_var = other |
| 1484 | |
Bram Moolenaar | ccc25aa | 2021-03-26 21:27:52 +0100 | [diff] [blame] | 1485 | var xyz: string # comment |
| 1486 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1487 | # type is inferred |
Bram Moolenaar | 3862ea3 | 2021-01-01 21:05:55 +0100 | [diff] [blame] | 1488 | var s:dict = {['a']: 222} |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1489 | def GetDictVal(key: any) |
| 1490 | g:dict_val = s:dict[key] |
| 1491 | enddef |
| 1492 | GetDictVal('a') |
Bram Moolenaar | 0825175 | 2021-01-11 21:20:18 +0100 | [diff] [blame] | 1493 | |
| 1494 | final adict: dict<string> = {} |
| 1495 | def ChangeAdict() |
| 1496 | adict.foo = 'foo' |
| 1497 | enddef |
| 1498 | ChangeAdict() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1499 | END |
| 1500 | CheckScriptSuccess(lines) |
| 1501 | assert_equal('', g:var_uninit) |
| 1502 | assert_equal('text', g:var_test) |
| 1503 | assert_equal('prefixed', g:var_prefixed) |
| 1504 | assert_equal(1234, g:other_var) |
| 1505 | assert_equal(222, g:dict_val) |
| 1506 | |
| 1507 | unlet g:var_uninit |
| 1508 | unlet g:var_test |
| 1509 | unlet g:var_prefixed |
| 1510 | unlet g:other_var |
Bram Moolenaar | 6e50ec2 | 2021-04-03 19:32:44 +0200 | [diff] [blame] | 1511 | unlet g:globConst |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1512 | unlet g:FOO |
| 1513 | unlet g:FOOS |
| 1514 | unlet g:FLIST |
| 1515 | unlet w:FOO |
| 1516 | unlet w:FOOS |
| 1517 | unlet w:FLIST |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1518 | enddef |
| 1519 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1520 | def Test_var_declaration_fails() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1521 | var lines =<< trim END |
| 1522 | vim9script |
| 1523 | final var: string |
| 1524 | END |
| 1525 | CheckScriptFailure(lines, 'E1125:') |
| 1526 | |
| 1527 | lines =<< trim END |
| 1528 | vim9script |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1529 | const g:constvar = 'string' |
| 1530 | g:constvar = 'xx' |
| 1531 | END |
| 1532 | CheckScriptFailure(lines, 'E741:') |
| 1533 | unlet g:constvar |
| 1534 | |
| 1535 | lines =<< trim END |
| 1536 | vim9script |
Bram Moolenaar | f5906aa | 2021-04-02 14:35:15 +0200 | [diff] [blame] | 1537 | var name = 'one' |
| 1538 | lockvar name |
| 1539 | def SetLocked() |
| 1540 | name = 'two' |
| 1541 | enddef |
| 1542 | SetLocked() |
| 1543 | END |
Bram Moolenaar | dcf29ac | 2021-04-02 14:44:02 +0200 | [diff] [blame] | 1544 | CheckScriptFailure(lines, 'E741: Value is locked: name', 1) |
| 1545 | |
| 1546 | lines =<< trim END |
| 1547 | let s:legacy = 'one' |
| 1548 | lockvar s:legacy |
| 1549 | def SetLocked() |
| 1550 | s:legacy = 'two' |
| 1551 | enddef |
| 1552 | call SetLocked() |
| 1553 | END |
| 1554 | CheckScriptFailure(lines, 'E741: Value is locked: s:legacy', 1) |
Bram Moolenaar | f5906aa | 2021-04-02 14:35:15 +0200 | [diff] [blame] | 1555 | |
| 1556 | lines =<< trim END |
| 1557 | vim9script |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 1558 | def SetGlobalConst() |
| 1559 | const g:globConst = 123 |
| 1560 | enddef |
| 1561 | SetGlobalConst() |
| 1562 | g:globConst = 234 |
| 1563 | END |
Bram Moolenaar | 6e50ec2 | 2021-04-03 19:32:44 +0200 | [diff] [blame] | 1564 | CheckScriptFailure(lines, 'E741: Value is locked: g:globConst', 6) |
Bram Moolenaar | d877a57 | 2021-04-01 19:42:48 +0200 | [diff] [blame] | 1565 | unlet g:globConst |
| 1566 | |
| 1567 | lines =<< trim END |
| 1568 | vim9script |
Bram Moolenaar | 0825175 | 2021-01-11 21:20:18 +0100 | [diff] [blame] | 1569 | const cdict: dict<string> = {} |
| 1570 | def Change() |
| 1571 | cdict.foo = 'foo' |
| 1572 | enddef |
| 1573 | defcompile |
| 1574 | END |
| 1575 | CheckScriptFailure(lines, 'E46:') |
| 1576 | |
| 1577 | lines =<< trim END |
| 1578 | vim9script |
Bram Moolenaar | 89b474d | 2020-12-22 21:19:39 +0100 | [diff] [blame] | 1579 | final w:finalvar = [9] |
| 1580 | w:finalvar = [8] |
| 1581 | END |
| 1582 | CheckScriptFailure(lines, 'E1122:') |
| 1583 | unlet w:finalvar |
| 1584 | |
| 1585 | lines =<< trim END |
| 1586 | vim9script |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1587 | const var: string |
| 1588 | END |
| 1589 | CheckScriptFailure(lines, 'E1021:') |
| 1590 | |
| 1591 | lines =<< trim END |
| 1592 | vim9script |
| 1593 | var 9var: string |
| 1594 | END |
Bram Moolenaar | ccc25aa | 2021-03-26 21:27:52 +0100 | [diff] [blame] | 1595 | CheckScriptFailure(lines, 'E488:') |
Bram Moolenaar | 7257af4 | 2020-12-08 22:08:51 +0100 | [diff] [blame] | 1596 | |
| 1597 | CheckDefFailure(['var foo.bar = 2'], 'E1087:') |
| 1598 | CheckDefFailure(['var foo[3] = 2'], 'E1087:') |
| 1599 | CheckDefFailure(['const foo: number'], 'E1021:') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1600 | enddef |
| 1601 | |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1602 | def Test_script_local_in_legacy() |
| 1603 | # OK to define script-local later when prefixed with s: |
| 1604 | var lines =<< trim END |
| 1605 | def SetLater() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1606 | s:legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1607 | enddef |
| 1608 | defcompile |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1609 | let s:legvar = 'one' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1610 | call SetLater() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1611 | call assert_equal('two', s:legvar) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1612 | END |
| 1613 | CheckScriptSuccess(lines) |
| 1614 | |
| 1615 | # OK to leave out s: prefix when script-local already defined |
| 1616 | lines =<< trim END |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1617 | let s:legvar = 'one' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1618 | def SetNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1619 | legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1620 | enddef |
| 1621 | call SetNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1622 | call assert_equal('two', s:legvar) |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1623 | END |
| 1624 | CheckScriptSuccess(lines) |
| 1625 | |
| 1626 | # Not OK to leave out s: prefix when script-local defined later |
| 1627 | lines =<< trim END |
| 1628 | def SetLaterNoPrefix() |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1629 | legvar = 'two' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1630 | enddef |
| 1631 | defcompile |
Bram Moolenaar | 96cf4ba | 2021-04-24 14:15:41 +0200 | [diff] [blame] | 1632 | let s:legvar = 'one' |
Bram Moolenaar | 643ce6c | 2021-04-06 21:17:27 +0200 | [diff] [blame] | 1633 | END |
| 1634 | CheckScriptFailure(lines, 'E476:', 1) |
| 1635 | enddef |
| 1636 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1637 | def Test_var_type_check() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1638 | var lines =<< trim END |
| 1639 | vim9script |
| 1640 | var name: string |
| 1641 | name = 1234 |
| 1642 | END |
| 1643 | CheckScriptFailure(lines, 'E1012:') |
| 1644 | |
| 1645 | lines =<< trim END |
| 1646 | vim9script |
| 1647 | var name:string |
| 1648 | END |
| 1649 | CheckScriptFailure(lines, 'E1069:') |
| 1650 | |
| 1651 | lines =<< trim END |
| 1652 | vim9script |
| 1653 | var name: asdf |
| 1654 | END |
| 1655 | CheckScriptFailure(lines, 'E1010:') |
| 1656 | |
| 1657 | lines =<< trim END |
| 1658 | vim9script |
| 1659 | var s:l: list<number> |
| 1660 | s:l = [] |
| 1661 | END |
| 1662 | CheckScriptSuccess(lines) |
| 1663 | |
| 1664 | lines =<< trim END |
| 1665 | vim9script |
| 1666 | var s:d: dict<number> |
| 1667 | s:d = {} |
| 1668 | END |
| 1669 | CheckScriptSuccess(lines) |
| 1670 | enddef |
| 1671 | |
| 1672 | let g:dict_number = #{one: 1, two: 2} |
| 1673 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1674 | def Test_var_list_dict_type() |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1675 | var ll: list<number> |
| 1676 | ll = [1, 2, 2, 3, 3, 3]->uniq() |
| 1677 | ll->assert_equal([1, 2, 3]) |
| 1678 | |
| 1679 | var dd: dict<number> |
| 1680 | dd = g:dict_number |
| 1681 | dd->assert_equal(g:dict_number) |
| 1682 | |
| 1683 | var lines =<< trim END |
| 1684 | var ll: list<number> |
| 1685 | ll = [1, 2, 3]->map('"one"') |
| 1686 | END |
Bram Moolenaar | 70250fb | 2021-01-16 19:01:53 +0100 | [diff] [blame] | 1687 | CheckDefExecFailure(lines, 'E1012: Type mismatch; expected number but got string') |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1688 | enddef |
| 1689 | |
Bram Moolenaar | 083966f | 2020-12-08 11:29:40 +0100 | [diff] [blame] | 1690 | def Test_cannot_use_let() |
| 1691 | CheckDefAndScriptFailure(['let a = 34'], 'E1126:', 1) |
| 1692 | enddef |
| 1693 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1694 | def Test_unlet() |
| 1695 | g:somevar = 'yes' |
| 1696 | assert_true(exists('g:somevar')) |
| 1697 | unlet g:somevar |
| 1698 | assert_false(exists('g:somevar')) |
| 1699 | unlet! g:somevar |
| 1700 | |
| 1701 | # also works for script-local variable in legacy Vim script |
| 1702 | s:somevar = 'legacy' |
| 1703 | assert_true(exists('s:somevar')) |
| 1704 | unlet s:somevar |
| 1705 | assert_false(exists('s:somevar')) |
| 1706 | unlet! s:somevar |
| 1707 | |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1708 | CheckDefExecFailure([ |
| 1709 | 'var dd = 111', |
| 1710 | 'unlet dd', |
| 1711 | ], 'E1081:', 2) |
| 1712 | |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1713 | # dict unlet |
| 1714 | var dd = {a: 1, b: 2, c: 3} |
| 1715 | unlet dd['a'] |
| 1716 | unlet dd.c |
| 1717 | assert_equal({b: 2}, dd) |
| 1718 | |
| 1719 | # list unlet |
| 1720 | var ll = [1, 2, 3, 4] |
| 1721 | unlet ll[1] |
| 1722 | unlet ll[-1] |
| 1723 | assert_equal([1, 3], ll) |
| 1724 | |
Bram Moolenaar | 5b5ae29 | 2021-02-20 17:04:02 +0100 | [diff] [blame] | 1725 | ll = [1, 2, 3, 4] |
| 1726 | unlet ll[0 : 1] |
| 1727 | assert_equal([3, 4], ll) |
| 1728 | |
| 1729 | ll = [1, 2, 3, 4] |
| 1730 | unlet ll[2 : 8] |
| 1731 | assert_equal([1, 2], ll) |
| 1732 | |
| 1733 | ll = [1, 2, 3, 4] |
| 1734 | unlet ll[-2 : -1] |
| 1735 | assert_equal([1, 2], ll) |
| 1736 | |
| 1737 | CheckDefFailure([ |
| 1738 | 'var ll = [1, 2]', |
| 1739 | 'll[1 : 2] = 7', |
| 1740 | ], 'E1165:', 2) |
| 1741 | CheckDefFailure([ |
| 1742 | 'var dd = {a: 1}', |
| 1743 | 'unlet dd["a" : "a"]', |
| 1744 | ], 'E1166:', 2) |
| 1745 | CheckDefExecFailure([ |
| 1746 | 'unlet g:adict[0 : 1]', |
| 1747 | ], 'E1148:', 1) |
| 1748 | CheckDefFailure([ |
| 1749 | 'var ll = [1, 2]', |
| 1750 | 'unlet ll[0:1]', |
| 1751 | ], 'E1004:', 2) |
| 1752 | CheckDefFailure([ |
| 1753 | 'var ll = [1, 2]', |
| 1754 | 'unlet ll[0 :1]', |
| 1755 | ], 'E1004:', 2) |
| 1756 | CheckDefFailure([ |
| 1757 | 'var ll = [1, 2]', |
| 1758 | 'unlet ll[0: 1]', |
| 1759 | ], 'E1004:', 2) |
| 1760 | |
| 1761 | CheckDefFailure([ |
| 1762 | 'var ll = [1, 2]', |
| 1763 | 'unlet ll["x" : 1]', |
| 1764 | ], 'E1012:', 2) |
| 1765 | CheckDefFailure([ |
| 1766 | 'var ll = [1, 2]', |
| 1767 | 'unlet ll[0 : "x"]', |
| 1768 | ], 'E1012:', 2) |
| 1769 | |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1770 | # list of dict unlet |
| 1771 | var dl = [{a: 1, b: 2}, {c: 3}] |
| 1772 | unlet dl[0]['b'] |
| 1773 | assert_equal([{a: 1}, {c: 3}], dl) |
| 1774 | |
| 1775 | CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1776 | 'var ll = test_null_list()', |
| 1777 | 'unlet ll[0]', |
| 1778 | ], 'E684:', 2) |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1779 | CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1780 | 'var ll = [1]', |
| 1781 | 'unlet ll[2]', |
| 1782 | ], 'E684:', 2) |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1783 | CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1784 | 'var ll = [1]', |
| 1785 | 'unlet ll[g:astring]', |
Bram Moolenaar | f30a14d | 2021-01-17 21:51:24 +0100 | [diff] [blame] | 1786 | ], 'E1012:', 2) |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1787 | CheckDefExecFailure([ |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1788 | 'var dd = test_null_dict()', |
| 1789 | 'unlet dd["a"]', |
| 1790 | ], 'E716:', 2) |
| 1791 | CheckDefExecFailure([ |
| 1792 | 'var dd = {a: 1}', |
| 1793 | 'unlet dd["b"]', |
| 1794 | ], 'E716:', 2) |
| 1795 | CheckDefExecFailure([ |
| 1796 | 'var dd = {a: 1}', |
| 1797 | 'unlet dd[g:alist]', |
| 1798 | ], 'E1105:', 2) |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1799 | |
Bram Moolenaar | 2ef951d | 2021-01-03 20:55:26 +0100 | [diff] [blame] | 1800 | # can compile unlet before variable exists |
Bram Moolenaar | 752fc69 | 2021-01-04 21:57:11 +0100 | [diff] [blame] | 1801 | g:someDict = {key: 'val'} |
| 1802 | var k = 'key' |
| 1803 | unlet g:someDict[k] |
| 1804 | assert_equal({}, g:someDict) |
| 1805 | unlet g:someDict |
| 1806 | assert_false(exists('g:someDict')) |
Bram Moolenaar | 2ef951d | 2021-01-03 20:55:26 +0100 | [diff] [blame] | 1807 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1808 | CheckScriptFailure([ |
| 1809 | 'vim9script', |
| 1810 | 'var svar = 123', |
| 1811 | 'unlet svar', |
| 1812 | ], 'E1081:') |
| 1813 | CheckScriptFailure([ |
| 1814 | 'vim9script', |
| 1815 | 'var svar = 123', |
| 1816 | 'unlet s:svar', |
| 1817 | ], 'E1081:') |
| 1818 | CheckScriptFailure([ |
| 1819 | 'vim9script', |
| 1820 | 'var svar = 123', |
| 1821 | 'def Func()', |
| 1822 | ' unlet svar', |
| 1823 | 'enddef', |
| 1824 | 'defcompile', |
| 1825 | ], 'E1081:') |
| 1826 | CheckScriptFailure([ |
| 1827 | 'vim9script', |
| 1828 | 'var svar = 123', |
Bram Moolenaar | 9aed729 | 2020-12-18 15:38:00 +0100 | [diff] [blame] | 1829 | 'func Func()', |
| 1830 | ' unlet s:svar', |
| 1831 | 'endfunc', |
| 1832 | 'Func()', |
| 1833 | ], 'E1081:') |
| 1834 | CheckScriptFailure([ |
| 1835 | 'vim9script', |
| 1836 | 'var svar = 123', |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1837 | 'def Func()', |
| 1838 | ' unlet s:svar', |
| 1839 | 'enddef', |
| 1840 | 'defcompile', |
| 1841 | ], 'E1081:') |
| 1842 | |
Bram Moolenaar | 0acbf5a | 2021-01-05 20:58:25 +0100 | [diff] [blame] | 1843 | writefile(['vim9script', 'export var svar = 1234'], 'XunletExport.vim') |
| 1844 | var lines =<< trim END |
| 1845 | vim9script |
| 1846 | import svar from './XunletExport.vim' |
| 1847 | def UnletSvar() |
| 1848 | unlet svar |
| 1849 | enddef |
| 1850 | defcompile |
| 1851 | END |
| 1852 | CheckScriptFailure(lines, 'E1081:', 1) |
| 1853 | delete('XunletExport.vim') |
| 1854 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1855 | $ENVVAR = 'foobar' |
| 1856 | assert_equal('foobar', $ENVVAR) |
| 1857 | unlet $ENVVAR |
| 1858 | assert_equal('', $ENVVAR) |
| 1859 | enddef |
| 1860 | |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 1861 | def Test_expr_error_no_assign() |
| 1862 | var lines =<< trim END |
| 1863 | vim9script |
| 1864 | var x = invalid |
| 1865 | echo x |
| 1866 | END |
| 1867 | CheckScriptFailureList(lines, ['E121:', 'E121:']) |
| 1868 | |
| 1869 | lines =<< trim END |
| 1870 | vim9script |
| 1871 | var x = 1 / 0 |
| 1872 | echo x |
| 1873 | END |
Bram Moolenaar | 227c58a | 2021-04-28 20:40:44 +0200 | [diff] [blame] | 1874 | CheckScriptFailure(lines, 'E1154:') |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 1875 | |
| 1876 | lines =<< trim END |
| 1877 | vim9script |
| 1878 | var x = 1 % 0 |
| 1879 | echo x |
| 1880 | END |
Bram Moolenaar | 227c58a | 2021-04-28 20:40:44 +0200 | [diff] [blame] | 1881 | CheckScriptFailure(lines, 'E1154:') |
Bram Moolenaar | ccc25aa | 2021-03-26 21:27:52 +0100 | [diff] [blame] | 1882 | |
| 1883 | lines =<< trim END |
| 1884 | var x: string 'string' |
| 1885 | END |
| 1886 | CheckDefAndScriptFailure(lines, 'E488:') |
Bram Moolenaar | c5f59fa | 2021-01-21 12:34:14 +0100 | [diff] [blame] | 1887 | enddef |
| 1888 | |
| 1889 | |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 1890 | def Test_assign_command_modifier() |
| 1891 | var lines =<< trim END |
Bram Moolenaar | 9e0f883 | 2021-01-09 12:09:22 +0100 | [diff] [blame] | 1892 | var verbose = 0 |
| 1893 | verbose = 1 |
| 1894 | assert_equal(1, verbose) |
| 1895 | silent verbose = 2 |
| 1896 | assert_equal(2, verbose) |
| 1897 | silent verbose += 2 |
| 1898 | assert_equal(4, verbose) |
| 1899 | silent verbose -= 1 |
| 1900 | assert_equal(3, verbose) |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 1901 | |
Bram Moolenaar | 9e0f883 | 2021-01-09 12:09:22 +0100 | [diff] [blame] | 1902 | var topleft = {one: 1} |
| 1903 | sandbox topleft.one = 3 |
| 1904 | assert_equal({one: 3}, topleft) |
| 1905 | leftabove topleft[' '] = 4 |
| 1906 | assert_equal({one: 3, ' ': 4}, topleft) |
| 1907 | |
| 1908 | var x: number |
| 1909 | var y: number |
| 1910 | silent [x, y] = [1, 2] |
| 1911 | assert_equal(1, x) |
| 1912 | assert_equal(2, y) |
Bram Moolenaar | 17126b1 | 2021-01-07 22:03:02 +0100 | [diff] [blame] | 1913 | END |
| 1914 | CheckDefAndScriptSuccess(lines) |
| 1915 | enddef |
| 1916 | |
Bram Moolenaar | 74f4a96 | 2021-06-17 21:03:07 +0200 | [diff] [blame] | 1917 | def Test_assign_alt_buf_register() |
| 1918 | var lines =<< trim END |
| 1919 | edit 'file_b1' |
| 1920 | var b1 = bufnr() |
| 1921 | edit 'file_b2' |
| 1922 | var b2 = bufnr() |
| 1923 | assert_equal(b1, bufnr('#')) |
| 1924 | @# = b2 |
| 1925 | assert_equal(b2, bufnr('#')) |
| 1926 | END |
| 1927 | CheckDefAndScriptSuccess(lines) |
| 1928 | enddef |
| 1929 | |
Bram Moolenaar | 3215466 | 2021-03-28 21:14:06 +0200 | [diff] [blame] | 1930 | def Test_script_funcref_case() |
| 1931 | var lines =<< trim END |
| 1932 | var Len = (s: string): number => len(s) + 1 |
| 1933 | assert_equal(5, Len('asdf')) |
| 1934 | END |
| 1935 | CheckDefAndScriptSuccess(lines) |
| 1936 | |
| 1937 | lines =<< trim END |
| 1938 | var len = (s: string): number => len(s) + 1 |
| 1939 | END |
| 1940 | CheckDefAndScriptFailure(lines, 'E704:') |
| 1941 | |
| 1942 | lines =<< trim END |
| 1943 | vim9script |
| 1944 | var s:Len = (s: string): number => len(s) + 2 |
| 1945 | assert_equal(6, Len('asdf')) |
| 1946 | END |
| 1947 | CheckScriptSuccess(lines) |
| 1948 | |
| 1949 | lines =<< trim END |
| 1950 | vim9script |
| 1951 | var s:len = (s: string): number => len(s) + 1 |
| 1952 | END |
| 1953 | CheckScriptFailure(lines, 'E704:') |
| 1954 | enddef |
| 1955 | |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 1956 | def Test_inc_dec() |
| 1957 | var lines =<< trim END |
| 1958 | var nr = 7 |
| 1959 | ++nr |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 1960 | assert_equal(8, nr) |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 1961 | --nr |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 1962 | assert_equal(7, nr) |
Bram Moolenaar | f3d3084 | 2021-06-25 19:29:30 +0200 | [diff] [blame] | 1963 | ++nr | ++nr |
| 1964 | assert_equal(9, nr) |
| 1965 | ++nr # comment |
| 1966 | assert_equal(10, nr) |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 1967 | |
| 1968 | var ll = [1, 2] |
| 1969 | --ll[0] |
| 1970 | ++ll[1] |
Bram Moolenaar | 730bf30 | 2021-04-24 20:43:56 +0200 | [diff] [blame] | 1971 | assert_equal([0, 3], ll) |
| 1972 | |
| 1973 | g:count = 1 |
| 1974 | ++g:count |
| 1975 | --g:count |
| 1976 | assert_equal(1, g:count) |
| 1977 | unlet g:count |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 1978 | END |
| 1979 | CheckDefAndScriptSuccess(lines) |
Bram Moolenaar | 22480d1 | 2021-06-25 21:31:09 +0200 | [diff] [blame] | 1980 | |
| 1981 | lines =<< trim END |
| 1982 | var nr = 7 |
| 1983 | ++ nr |
| 1984 | END |
| 1985 | CheckDefAndScriptFailure(lines, "E1202: No white space allowed after '++': ++ nr") |
Bram Moolenaar | bdc0f1c | 2021-04-24 19:08:24 +0200 | [diff] [blame] | 1986 | enddef |
| 1987 | |
Bram Moolenaar | 55759b5 | 2020-09-30 22:59:42 +0200 | [diff] [blame] | 1988 | |
Bram Moolenaar | 971caf5 | 2020-09-21 22:21:42 +0200 | [diff] [blame] | 1989 | " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker |