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