blob: 4941650650220e4f20ce48d880b8e3a5103c094d [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Tests for Vim9 script expressions
2
3source check.vim
Bram Moolenaarcfe435d2020-04-25 20:02:55 +02004source vim9.vim
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01005
Bram Moolenaarc7db5772020-07-21 20:55:50 +02006let g:cond = v:false
7def FuncOne(arg: number): string
8 return 'yes'
9enddef
10def FuncTwo(arg: number): number
11 return 123
12enddef
13
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010014" test cond ? expr : expr
Bram Moolenaar92f26c22020-10-03 20:17:30 +020015def Test_expr1_trinary()
Bram Moolenaar659bb222020-11-12 20:16:39 +010016 var lines =<< trim END
17 assert_equal('one', true ? 'one' : 'two')
18 assert_equal('one', 1 ?
19 'one' :
20 'two')
21 if has('float')
22 assert_equal('one', !!0.1 ? 'one' : 'two')
23 endif
24 assert_equal('one', !!'x' ? 'one' : 'two')
25 assert_equal('one', !!'x'
26 ? 'one'
27 : 'two')
28 assert_equal('one', !!0z1234 ? 'one' : 'two')
29 assert_equal('one', !![0] ? 'one' : 'two')
Bram Moolenaare0de1712020-12-02 17:36:54 +010030 assert_equal('one', !!{x: 0} ? 'one' : 'two')
Bram Moolenaar659bb222020-11-12 20:16:39 +010031 var name = 1
32 assert_equal('one', name ? 'one' : 'two')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010033
Bram Moolenaar659bb222020-11-12 20:16:39 +010034 assert_equal('two', false ? 'one' : 'two')
35 assert_equal('two', 0 ? 'one' : 'two')
36 if has('float')
37 assert_equal('two', !!0.0 ? 'one' : 'two')
38 endif
39 assert_equal('two', !!'' ? 'one' : 'two')
40 assert_equal('two', !!0z ? 'one' : 'two')
41 assert_equal('two', !![] ? 'one' : 'two')
42 assert_equal('two', !!{} ? 'one' : 'two')
43 name = 0
44 assert_equal('two', name ? 'one' : 'two')
Bram Moolenaar939b5db2020-04-28 22:49:08 +020045
Bram Moolenaar5afd0812021-01-03 18:33:13 +010046 echo ['a'] + (1 ? ['b'] : ['c']
47 )
48 echo ['a'] + (1 ? ['b'] : ['c'] # comment
49 )
50
Bram Moolenaar659bb222020-11-12 20:16:39 +010051 # with constant condition expression is not evaluated
52 assert_equal('one', 1 ? 'one' : xxx)
Bram Moolenaar749639e2020-08-27 23:08:47 +020053
Bram Moolenaar659bb222020-11-12 20:16:39 +010054 var Some: func = function('len')
55 var Other: func = function('winnr')
56 var Res: func = g:atrue ? Some : Other
57 assert_equal(function('len'), Res)
Bram Moolenaar939b5db2020-04-28 22:49:08 +020058
Bram Moolenaar659bb222020-11-12 20:16:39 +010059 var RetOne: func(string): number = function('len')
60 var RetTwo: func(string): number = function('winnr')
61 var RetThat: func = g:atrue ? RetOne : RetTwo
62 assert_equal(function('len'), RetThat)
Bram Moolenaarc7db5772020-07-21 20:55:50 +020063
Bram Moolenaar659bb222020-11-12 20:16:39 +010064 var X = FuncOne
65 var Y = FuncTwo
66 var Z = g:cond ? FuncOne : FuncTwo
67 assert_equal(123, Z(3))
68 END
69 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010070enddef
71
Bram Moolenaar92f26c22020-10-03 20:17:30 +020072def Test_expr1_trinary_vimscript()
Bram Moolenaarfdac71c2020-08-05 12:44:41 +020073 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +020074 var lines =<< trim END
Bram Moolenaar793648f2020-06-26 21:28:25 +020075 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +020076 var name = 1
Bram Moolenaar793648f2020-06-26 21:28:25 +020077 ? 'yes'
78 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020079 assert_equal('yes', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020080 END
81 CheckScriptSuccess(lines)
82
83 lines =<< trim END
84 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +020085 var name = v:false
Bram Moolenaar793648f2020-06-26 21:28:25 +020086 ? 'yes'
87 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020088 assert_equal('no', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020089 END
90 CheckScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +020091
92 lines =<< trim END
93 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +020094 var name = v:false ?
Bram Moolenaar9215f012020-06-27 21:18:00 +020095 'yes' :
96 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020097 assert_equal('no', name)
Bram Moolenaar9215f012020-06-27 21:18:00 +020098 END
99 CheckScriptSuccess(lines)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200100
Bram Moolenaar93be1642020-10-11 21:34:41 +0200101 lines =<< trim END
102 vim9script
103 var name = v:false ? # comment
104 'yes' :
105 # comment
106 'no' # comment
107 assert_equal('no', name)
108 END
109 CheckScriptSuccess(lines)
110
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200111 # check white space
112 lines =<< trim END
113 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200114 var name = v:true?1:2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200115 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100116 CheckScriptFailure(lines, 'E1004: White space required before and after ''?'' at "?1:2"', 2)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200117 lines =<< trim END
118 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200119 var name = v:true? 1 : 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200120 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200121 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200122 lines =<< trim END
123 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200124 var name = v:true ?1 : 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200125 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200126 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200127 lines =<< trim END
128 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200129 var name = v:true ? 1: 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200130 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100131 CheckScriptFailure(lines, 'E1004: White space required before and after '':'' at ": 2"', 2)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200132 lines =<< trim END
133 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200134 var name = v:true ? 1 :2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200135 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200136 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar69e445522020-08-22 22:37:20 +0200137
Bram Moolenaar13106602020-10-04 16:06:05 +0200138 lines =<< trim END
139 vim9script
140 var name = 'x' ? 1 : 2
141 END
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100142 CheckScriptFailure(lines, 'E1135:', 2)
Bram Moolenaar13106602020-10-04 16:06:05 +0200143
144 lines =<< trim END
145 vim9script
146 var name = [] ? 1 : 2
147 END
148 CheckScriptFailure(lines, 'E745:', 2)
149
150 lines =<< trim END
151 vim9script
152 var name = {} ? 1 : 2
153 END
154 CheckScriptFailure(lines, 'E728:', 2)
155
Bram Moolenaar69e445522020-08-22 22:37:20 +0200156 # check after failure eval_flags is reset
157 lines =<< trim END
158 vim9script
159 try
Bram Moolenaard2c61702020-09-06 15:58:36 +0200160 eval('0 ? 1: 2')
Bram Moolenaar69e445522020-08-22 22:37:20 +0200161 catch
162 endtry
163 assert_equal(v:true, eval(string(v:true)))
164 END
165 CheckScriptSuccess(lines)
166
167 lines =<< trim END
168 vim9script
169 try
Bram Moolenaard2c61702020-09-06 15:58:36 +0200170 eval('0 ? 1 :2')
Bram Moolenaar69e445522020-08-22 22:37:20 +0200171 catch
172 endtry
173 assert_equal(v:true, eval(string(v:true)))
174 END
175 CheckScriptSuccess(lines)
Bram Moolenaar793648f2020-06-26 21:28:25 +0200176enddef
177
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200178func Test_expr1_trinary_fails()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200179 call CheckDefFailure(["var x = 1 ? 'one'"], "Missing ':' after '?'", 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100180
Bram Moolenaar77072282020-09-16 17:55:40 +0200181 let msg = "White space required before and after '?'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200182 call CheckDefFailure(["var x = 1? 'one' : 'two'"], msg, 1)
183 call CheckDefFailure(["var x = 1 ?'one' : 'two'"], msg, 1)
184 call CheckDefFailure(["var x = 1?'one' : 'two'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100185
Bram Moolenaar77072282020-09-16 17:55:40 +0200186 let msg = "White space required before and after ':'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200187 call CheckDefFailure(["var x = 1 ? 'one': 'two'"], msg, 1)
188 call CheckDefFailure(["var x = 1 ? 'one' :'two'"], msg, 1)
189 call CheckDefFailure(["var x = 1 ? 'one':'two'"], msg, 1)
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200190
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100191 call CheckDefFailure(["var x = 'x' ? 'one' : 'two'"], 'E1135:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200192 call CheckDefFailure(["var x = 0z1234 ? 'one' : 'two'"], 'E974:', 1)
193 call CheckDefExecFailure(["var x = [] ? 'one' : 'two'"], 'E745:', 1)
194 call CheckDefExecFailure(["var x = {} ? 'one' : 'two'"], 'E728:', 1)
195
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100196 call CheckDefExecFailure(["var x = false ? "], 'E1097:', 3)
197 call CheckDefExecFailure(["var x = false ? 'one' : "], 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100198
199 call CheckDefExecFailure(["var x = true ? xxx : 'foo'"], 'E1001:', 1)
200 call CheckDefExecFailure(["var x = false ? 'foo' : xxx"], 'E1001:', 1)
201
Bram Moolenaar13106602020-10-04 16:06:05 +0200202 if has('float')
203 call CheckDefFailure(["var x = 0.1 ? 'one' : 'two'"], 'E805:', 1)
204 endif
205
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200206 " missing argument detected even when common type is used
207 call CheckDefFailure([
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200208 \ 'var X = FuncOne',
209 \ 'var Y = FuncTwo',
210 \ 'var Z = g:cond ? FuncOne : FuncTwo',
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200211 \ 'Z()'], 'E119:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100212endfunc
213
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200214def Test_expr1_falsy()
215 var lines =<< trim END
216 assert_equal(v:true, v:true ?? 456)
217 assert_equal(123, 123 ?? 456)
218 assert_equal('yes', 'yes' ?? 456)
219 assert_equal([1], [1] ?? 456)
Bram Moolenaare0de1712020-12-02 17:36:54 +0100220 assert_equal({one: 1}, {one: 1} ?? 456)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200221 if has('float')
222 assert_equal(0.1, 0.1 ?? 456)
223 endif
224
225 assert_equal(456, v:false ?? 456)
226 assert_equal(456, 0 ?? 456)
227 assert_equal(456, '' ?? 456)
228 assert_equal(456, [] ?? 456)
229 assert_equal(456, {} ?? 456)
230 if has('float')
231 assert_equal(456, 0.0 ?? 456)
232 endif
233 END
234 CheckDefAndScriptSuccess(lines)
235
236 var msg = "White space required before and after '??'"
237 call CheckDefFailure(["var x = 1?? 'one' : 'two'"], msg, 1)
238 call CheckDefFailure(["var x = 1 ??'one' : 'two'"], msg, 1)
239 call CheckDefFailure(["var x = 1??'one' : 'two'"], msg, 1)
240enddef
241
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100242def Record(val: any): any
243 g:vals->add(val)
244 return val
245enddef
246
247" test ||
248def Test_expr2()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100249 var lines =<< trim END
250 assert_equal(true, 1 || 0)
251 assert_equal(true, 0 ||
252 0 ||
253 1)
254 assert_equal(true, 0 ||
255 0 ||
256 !!7)
257 assert_equal(false, 0 || 0)
258 assert_equal(false, 0
259 || 0)
260 assert_equal(false, 0 || false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100261
Bram Moolenaar659bb222020-11-12 20:16:39 +0100262 g:vals = []
263 assert_equal(true, Record(1) || Record(3))
264 assert_equal([1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100265
Bram Moolenaar659bb222020-11-12 20:16:39 +0100266 g:vals = []
267 assert_equal(true, Record(0) || Record(1))
268 assert_equal([0, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100269
Bram Moolenaar659bb222020-11-12 20:16:39 +0100270 g:vals = []
271 assert_equal(true, Record(0) || Record(true))
272 assert_equal([0, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100273
Bram Moolenaar659bb222020-11-12 20:16:39 +0100274 g:vals = []
275 assert_equal(true, Record(0)
276 || Record(1)
277 || Record(0))
278 assert_equal([0, 1], g:vals)
279
280 g:vals = []
281 assert_equal(true, Record(0)
282 || Record(true)
283 || Record(0))
284 assert_equal([0, true], g:vals)
285
286 g:vals = []
287 assert_equal(true, Record(true) || Record(false))
288 assert_equal([true], g:vals)
289
290 g:vals = []
291 assert_equal(false, Record(0) || Record(false) || Record(0))
292 assert_equal([0, false, 0], g:vals)
293 END
294 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100295enddef
296
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200297def Test_expr2_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200298 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200299 var lines =<< trim END
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200300 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200301 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200302 || 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200303 assert_equal(true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200304 END
305 CheckScriptSuccess(lines)
306
307 lines =<< trim END
308 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200309 var name = v:false
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200310 || v:true
311 || v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200312 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200313 END
314 CheckScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200315
316 lines =<< trim END
317 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200318 var name = v:false ||
Bram Moolenaar9215f012020-06-27 21:18:00 +0200319 v:true ||
320 v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200321 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200322 END
323 CheckScriptSuccess(lines)
324
Bram Moolenaar93be1642020-10-11 21:34:41 +0200325 lines =<< trim END
326 vim9script
327 var name = v:false || # comment
328 # comment
329 v:true ||
330 # comment
331 v:false # comment
332 assert_equal(v:true, name)
333 END
334 CheckScriptSuccess(lines)
335
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200336 # check white space
337 lines =<< trim END
338 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200339 var name = v:true||v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200340 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100341 CheckScriptFailure(lines, 'E1004: White space required before and after ''||'' at "||v:true"', 2)
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200342 lines =<< trim END
343 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200344 var name = v:true ||v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200345 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200346 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200347 lines =<< trim END
348 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200349 var name = v:true|| v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200350 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200351 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200352enddef
353
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200354def Test_expr2_fails()
355 var msg = "White space required before and after '||'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200356 call CheckDefFailure(["var x = 1||2"], msg, 1)
357 call CheckDefFailure(["var x = 1 ||2"], msg, 1)
358 call CheckDefFailure(["var x = 1|| 2"], msg, 1)
Bram Moolenaara8c17702020-04-01 21:17:24 +0200359
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100360 call CheckDefFailure(["var x = false || "], 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100361
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200362 call CheckDefFailure(["var x = 1 || xxx"], 'E1001:', 1)
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100363 call CheckDefFailure(["var x = [] || false"], 'E1012:', 1)
364 call CheckDefFailure(["if 'yes' || 0", 'echo 0', 'endif'], 'E1012: Type mismatch; expected bool but got string', 1)
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200365
366 # TODO: should fail at compile time
367 call CheckDefExecFailure(["var x = 3 || 7"], 'E1023:', 1)
368 call CheckScriptFailure(["vim9script", "var x = 3 || 7"], 'E1023:', 2)
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200369 call CheckScriptFailure(["vim9script", "var x = [] || false"], 'E745:', 2)
370enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100371
372" test &&
373def Test_expr3()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100374 var lines =<< trim END
375 assert_equal(false, 1 && 0)
376 assert_equal(false, 0 &&
377 0 &&
378 1)
379 assert_equal(true, 1
380 && true
381 && 1)
382 assert_equal(false, 0 && 0)
383 assert_equal(false, 0 && false)
384 assert_equal(true, 1 && true)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100385
Bram Moolenaar659bb222020-11-12 20:16:39 +0100386 g:vals = []
387 assert_equal(true, Record(true) && Record(1))
388 assert_equal([true, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100389
Bram Moolenaar659bb222020-11-12 20:16:39 +0100390 g:vals = []
391 assert_equal(true, Record(1) && Record(true))
392 assert_equal([1, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100393
Bram Moolenaar659bb222020-11-12 20:16:39 +0100394 g:vals = []
395 assert_equal(false, Record(0) && Record(1))
396 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100397
Bram Moolenaar659bb222020-11-12 20:16:39 +0100398 g:vals = []
399 assert_equal(false, Record(0) && Record(1) && Record(0))
400 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100401
Bram Moolenaar659bb222020-11-12 20:16:39 +0100402 g:vals = []
403 assert_equal(false, Record(0) && Record(4) && Record(0))
404 assert_equal([0], g:vals)
405
406 g:vals = []
407 assert_equal(false, Record(1) && Record(true) && Record(0))
408 assert_equal([1, true, 0], g:vals)
409 END
410 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100411enddef
412
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200413def Test_expr3_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200414 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200415 var lines =<< trim END
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200416 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200417 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200418 && 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200419 assert_equal(false, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200420 END
421 CheckScriptSuccess(lines)
422
423 lines =<< trim END
424 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200425 var name = v:true
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200426 && v:true
427 && v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200428 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200429 END
430 CheckScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200431
432 lines =<< trim END
433 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200434 var name = v:true &&
Bram Moolenaar9215f012020-06-27 21:18:00 +0200435 v:true &&
436 v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200437 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200438 END
439 CheckScriptSuccess(lines)
440
Bram Moolenaar93be1642020-10-11 21:34:41 +0200441 lines =<< trim END
442 vim9script
443 var name = v:true && # comment
444 # comment
445 v:true &&
446 # comment
447 v:true
448 assert_equal(v:true, name)
449 END
450 CheckScriptSuccess(lines)
451
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200452 # check white space
453 lines =<< trim END
454 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200455 var name = v:true&&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200456 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200457 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200458 lines =<< trim END
459 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200460 var name = v:true &&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200461 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100462 CheckScriptFailure(lines, 'E1004: White space required before and after ''&&'' at "&&v:true"', 2)
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200463 lines =<< trim END
464 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200465 var name = v:true&& v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200466 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200467 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200468enddef
469
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100470func Test_expr3_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +0200471 let msg = "White space required before and after '&&'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200472 call CheckDefFailure(["var x = 1&&2"], msg, 1)
473 call CheckDefFailure(["var x = 1 &&2"], msg, 1)
474 call CheckDefFailure(["var x = 1&& 2"], msg, 1)
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100475
476 call CheckDefFailure(["if 'yes' && 0", 'echo 0', 'endif'], 'E1012: Type mismatch; expected bool but got string', 1)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100477
478 call CheckDefExecFailure(['assert_equal(false, Record(1) && Record(4) && Record(0))'], 'E1023: Using a Number as a Bool: 4', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100479endfunc
480
Bram Moolenaar56acb092020-08-16 14:48:19 +0200481" global variables to use for tests with the "any" type
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100482let atrue = v:true
483let afalse = v:false
484let anone = v:none
485let anull = v:null
486let anint = 10
Bram Moolenaar56acb092020-08-16 14:48:19 +0200487let theone = 1
488let thefour = 4
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100489if has('float')
490 let afloat = 0.1
491endif
492let astring = 'asdf'
493let ablob = 0z01ab
494let alist = [2, 3, 4]
495let adict = #{aaa: 2, bbb: 8}
496
497" test == comperator
498def Test_expr4_equal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100499 var lines =<< trim END
500 var trueVar = true
501 var falseVar = false
502 assert_equal(true, true == true)
503 assert_equal(false, true ==
504 false)
505 assert_equal(true, true
506 == trueVar)
507 assert_equal(false, true == falseVar)
508 assert_equal(true, true == g:atrue)
509 assert_equal(false, g:atrue == false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100510
Bram Moolenaar659bb222020-11-12 20:16:39 +0100511 assert_equal(true, v:none == v:none)
512 assert_equal(false, v:none == v:null)
513 assert_equal(true, g:anone == v:none)
Bram Moolenaar67977822021-01-03 21:53:53 +0100514 assert_equal(true, null == v:null)
515 assert_equal(true, null == g:anull)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100516 assert_equal(false, v:none == g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100517
Bram Moolenaar659bb222020-11-12 20:16:39 +0100518 var nr0 = 0
519 var nr61 = 61
520 assert_equal(false, 2 == 0)
521 assert_equal(false, 2 == nr0)
522 assert_equal(true, 61 == 61)
523 assert_equal(true, 61 == nr61)
524 assert_equal(true, g:anint == 10)
525 assert_equal(false, 61 == g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100526
Bram Moolenaar659bb222020-11-12 20:16:39 +0100527 if has('float')
528 var ff = 0.3
529 assert_equal(true, ff == 0.3)
530 assert_equal(false, 0.4 == ff)
531 assert_equal(true, 0.1 == g:afloat)
532 assert_equal(false, g:afloat == 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100533
Bram Moolenaar659bb222020-11-12 20:16:39 +0100534 ff = 3.0
535 assert_equal(true, ff == 3)
536 assert_equal(true, 3 == ff)
537 ff = 3.1
538 assert_equal(false, ff == 3)
539 assert_equal(false, 3 == ff)
540 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100541
Bram Moolenaar659bb222020-11-12 20:16:39 +0100542 assert_equal(true, 'abc' == 'abc')
543 assert_equal(false, 'xyz' == 'abc')
544 assert_equal(true, g:astring == 'asdf')
545 assert_equal(false, 'xyz' == g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100546
Bram Moolenaar659bb222020-11-12 20:16:39 +0100547 assert_equal(false, 'abc' == 'aBc')
548 assert_equal(false, 'abc' ==# 'aBc')
549 assert_equal(true, 'abc' ==? 'aBc')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200550
Bram Moolenaar659bb222020-11-12 20:16:39 +0100551 assert_equal(false, 'abc' == 'ABC')
552 set ignorecase
553 assert_equal(false, 'abc' == 'ABC')
554 assert_equal(false, 'abc' ==# 'ABC')
555 assert_equal(true, 'abc' ==? 'ABC')
556 set noignorecase
557
558 var bb = 0z3f
559 assert_equal(true, 0z3f == bb)
560 assert_equal(false, bb == 0z4f)
561 assert_equal(true, g:ablob == 0z01ab)
562 assert_equal(false, 0z3f == g:ablob)
563
564 assert_equal(true, [1, 2, 3] == [1, 2, 3])
565 assert_equal(false, [1, 2, 3] == [2, 3, 1])
566 assert_equal(true, [2, 3, 4] == g:alist)
567 assert_equal(false, g:alist == [2, 3, 1])
568 assert_equal(false, [1, 2, 3] == [])
569 assert_equal(false, [1, 2, 3] == ['1', '2', '3'])
570
Bram Moolenaare0de1712020-12-02 17:36:54 +0100571 assert_equal(true, {one: 1, two: 2} == {one: 1, two: 2})
572 assert_equal(false, {one: 1, two: 2} == {one: 2, two: 2})
573 assert_equal(false, {one: 1, two: 2} == {two: 2})
574 assert_equal(false, {one: 1, two: 2} == {})
575 assert_equal(true, g:adict == {bbb: 8, aaa: 2})
576 assert_equal(false, {ccc: 9, aaa: 2} == g:adict)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100577
578 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal'))
579 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is'))
580
581 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123]))
582 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_is', [123]))
583 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [999]))
584
Bram Moolenaara065a142020-11-14 20:57:20 +0100585 # TODO: this unexpectedly sometimes fails on Appveyor
586 if !has('win32')
587 var OneFunc: func
588 var TwoFunc: func
589 OneFunc = function('len')
590 TwoFunc = function('len')
591 assert_equal(true, OneFunc('abc') == TwoFunc('123'))
592 endif
Bram Moolenaar659bb222020-11-12 20:16:39 +0100593 END
594 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100595
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200596 CheckDefFailure(["var x = 'a' == xxx"], 'E1001:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100597 CheckDefFailure(["var x = 'a' == "], 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100598
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200599 CheckDefExecFailure(['var items: any', 'eval 1', 'eval 2', 'if items == []', 'endif'], 'E691:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100600enddef
601
602" test != comperator
603def Test_expr4_notequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100604 var lines =<< trim END
605 var trueVar = true
606 var falseVar = false
607 assert_equal(false, true != true)
608 assert_equal(true, true !=
609 false)
610 assert_equal(false, true
611 != trueVar)
612 assert_equal(true, true != falseVar)
613 assert_equal(false, true != g:atrue)
614 assert_equal(true, g:atrue != false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100615
Bram Moolenaar659bb222020-11-12 20:16:39 +0100616 assert_equal(false, v:none != v:none)
617 assert_equal(true, v:none != v:null)
618 assert_equal(false, g:anone != v:none)
619 assert_equal(true, v:none != g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100620
Bram Moolenaar659bb222020-11-12 20:16:39 +0100621 var nr55 = 55
622 var nr0 = 55
623 assert_equal(true, 2 != 0)
624 assert_equal(true, 2 != nr0)
625 assert_equal(false, 55 != 55)
626 assert_equal(false, 55 != nr55)
627 assert_equal(false, g:anint != 10)
628 assert_equal(true, 61 != g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100629
Bram Moolenaar659bb222020-11-12 20:16:39 +0100630 if has('float')
631 var ff = 0.3
632 assert_equal(false, 0.3 != ff)
633 assert_equal(true, 0.4 != ff)
634 assert_equal(false, 0.1 != g:afloat)
635 assert_equal(true, g:afloat != 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100636
Bram Moolenaar659bb222020-11-12 20:16:39 +0100637 ff = 3.0
638 assert_equal(false, ff != 3)
639 assert_equal(false, 3 != ff)
640 ff = 3.1
641 assert_equal(true, ff != 3)
642 assert_equal(true, 3 != ff)
643 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100644
Bram Moolenaar659bb222020-11-12 20:16:39 +0100645 assert_equal(false, 'abc' != 'abc')
646 assert_equal(true, 'xyz' != 'abc')
647 assert_equal(false, g:astring != 'asdf')
648 assert_equal(true, 'xyz' != g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100649
Bram Moolenaar659bb222020-11-12 20:16:39 +0100650 assert_equal(true, 'abc' != 'ABC')
651 set ignorecase
652 assert_equal(true, 'abc' != 'ABC')
653 assert_equal(true, 'abc' !=# 'ABC')
654 assert_equal(false, 'abc' !=? 'ABC')
655 set noignorecase
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100656
Bram Moolenaar659bb222020-11-12 20:16:39 +0100657 var bb = 0z3f
658 assert_equal(false, 0z3f != bb)
659 assert_equal(true, bb != 0z4f)
660 assert_equal(false, g:ablob != 0z01ab)
661 assert_equal(true, 0z3f != g:ablob)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100662
Bram Moolenaar659bb222020-11-12 20:16:39 +0100663 assert_equal(false, [1, 2, 3] != [1, 2, 3])
664 assert_equal(true, [1, 2, 3] != [2, 3, 1])
665 assert_equal(false, [2, 3, 4] != g:alist)
666 assert_equal(true, g:alist != [2, 3, 1])
667 assert_equal(true, [1, 2, 3] != [])
668 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100669
Bram Moolenaare0de1712020-12-02 17:36:54 +0100670 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
671 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
672 assert_equal(true, {one: 1, two: 2} != {two: 2})
673 assert_equal(true, {one: 1, two: 2} != {})
674 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
675 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100676
Bram Moolenaar659bb222020-11-12 20:16:39 +0100677 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
678 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100679
Bram Moolenaar659bb222020-11-12 20:16:39 +0100680 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
681 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
682 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
683 END
684 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100685enddef
686
687" test > comperator
688def Test_expr4_greater()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100689 var lines =<< trim END
690 assert_true(2 > 0)
691 assert_true(2 >
692 1)
693 assert_false(2 > 2)
694 assert_false(2 > 3)
695 var nr2 = 2
696 assert_true(nr2 > 0)
697 assert_true(nr2 >
698 1)
699 assert_false(nr2 > 2)
700 assert_false(nr2
701 > 3)
702 if has('float')
703 var ff = 2.0
704 assert_true(ff > 0.0)
705 assert_true(ff > 1.0)
706 assert_false(ff > 2.0)
707 assert_false(ff > 3.0)
708 endif
709 END
710 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100711enddef
712
713" test >= comperator
714def Test_expr4_greaterequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100715 var lines =<< trim END
716 assert_true(2 >= 0)
717 assert_true(2 >=
718 2)
719 assert_false(2 >= 3)
720 var nr2 = 2
721 assert_true(nr2 >= 0)
722 assert_true(nr2 >= 2)
723 assert_false(nr2 >= 3)
724 if has('float')
725 var ff = 2.0
726 assert_true(ff >= 0.0)
727 assert_true(ff >= 2.0)
728 assert_false(ff >= 3.0)
729 endif
730 END
731 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100732enddef
733
734" test < comperator
735def Test_expr4_smaller()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100736 var lines =<< trim END
737 assert_false(2 < 0)
738 assert_false(2 <
739 2)
740 assert_true(2
741 < 3)
742 var nr2 = 2
743 assert_false(nr2 < 0)
744 assert_false(nr2 < 2)
745 assert_true(nr2 < 3)
746 if has('float')
747 var ff = 2.0
748 assert_false(ff < 0.0)
749 assert_false(ff < 2.0)
750 assert_true(ff < 3.0)
751 endif
752 END
753 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100754enddef
755
756" test <= comperator
757def Test_expr4_smallerequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100758 var lines =<< trim END
759 assert_false(2 <= 0)
760 assert_false(2 <=
761 1)
762 assert_true(2
763 <= 2)
764 assert_true(2 <= 3)
765 var nr2 = 2
766 assert_false(nr2 <= 0)
767 assert_false(nr2 <= 1)
768 assert_true(nr2 <= 2)
769 assert_true(nr2 <= 3)
770 if has('float')
771 var ff = 2.0
772 assert_false(ff <= 0.0)
773 assert_false(ff <= 1.0)
774 assert_true(ff <= 2.0)
775 assert_true(ff <= 3.0)
776 endif
777 END
778 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100779enddef
780
781" test =~ comperator
782def Test_expr4_match()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100783 var lines =<< trim END
784 assert_equal(false, '2' =~ '0')
785 assert_equal(false, ''
786 =~ '0')
787 assert_equal(true, '2' =~
788 '[0-9]')
789 set ignorecase
790 assert_equal(false, 'abc' =~ 'ABC')
791 assert_equal(false, 'abc' =~# 'ABC')
792 assert_equal(true, 'abc' =~? 'ABC')
793 set noignorecase
794 END
795 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100796enddef
797
798" test !~ comperator
799def Test_expr4_nomatch()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100800 var lines =<< trim END
801 assert_equal(true, '2' !~ '0')
802 assert_equal(true, ''
803 !~ '0')
804 assert_equal(false, '2' !~
805 '[0-9]')
806 END
807 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100808enddef
809
810" test is comperator
811def Test_expr4_is()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100812 var lines =<< trim END
813 var mylist = [2]
814 assert_false(mylist is [2])
815 var other = mylist
816 assert_true(mylist is
817 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100818
Bram Moolenaar659bb222020-11-12 20:16:39 +0100819 var myblob = 0z1234
820 assert_false(myblob
821 is 0z1234)
822 var otherblob = myblob
823 assert_true(myblob is otherblob)
824 END
825 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100826enddef
827
828" test isnot comperator
829def Test_expr4_isnot()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100830 var lines =<< trim END
831 var mylist = [2]
832 assert_true('2' isnot '0')
833 assert_true(mylist isnot [2])
834 var other = mylist
835 assert_false(mylist isnot
836 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100837
Bram Moolenaar659bb222020-11-12 20:16:39 +0100838 var myblob = 0z1234
839 assert_true(myblob
840 isnot 0z1234)
841 var otherblob = myblob
842 assert_false(myblob isnot otherblob)
843 END
844 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100845enddef
846
847def RetVoid()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200848 var x = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100849enddef
850
Bram Moolenaar8294d492020-08-10 22:40:56 +0200851def Test_expr4_vim9script()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200852 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200853 var lines =<< trim END
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200854 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200855 var name = 0
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200856 < 1
Bram Moolenaar98309382020-09-27 21:58:45 +0200857 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200858 END
859 CheckScriptSuccess(lines)
860
861 lines =<< trim END
862 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200863 var name = 123
Bram Moolenaar93be1642020-10-11 21:34:41 +0200864 # comment
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200865 != 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200866 assert_equal(false, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200867 END
868 CheckScriptSuccess(lines)
869
870 lines =<< trim END
871 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200872 var name = 123 ==
Bram Moolenaar9215f012020-06-27 21:18:00 +0200873 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200874 assert_equal(true, name)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200875 END
876 CheckScriptSuccess(lines)
877
878 lines =<< trim END
879 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200880 var list = [1, 2, 3]
881 var name = list
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200882 is list
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200883 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200884 END
885 CheckScriptSuccess(lines)
886
887 lines =<< trim END
888 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +0200889 var list = [1, 2, 3]
890 var name = list # comment
891 # comment
892 is list
893 assert_equal(true, name)
894 END
895 CheckScriptSuccess(lines)
896
897 lines =<< trim END
898 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200899 var myblob = 0z1234
900 var name = myblob
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200901 isnot 0z11
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200902 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200903 END
904 CheckScriptSuccess(lines)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200905
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200906 # spot check mismatching types
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200907 lines =<< trim END
908 vim9script
909 echo '' == 0
910 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200911 CheckScriptFailure(lines, 'E1072:', 2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200912
913 lines =<< trim END
914 vim9script
915 echo v:true > v:false
916 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200917 CheckScriptFailure(lines, 'Cannot compare bool with bool', 2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200918
919 lines =<< trim END
920 vim9script
921 echo 123 is 123
922 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200923 CheckScriptFailure(lines, 'Cannot use "is" with number', 2)
Bram Moolenaarc71f36a2020-07-21 21:31:00 +0200924
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200925 # check missing white space
926 lines =<< trim END
927 vim9script
928 echo 2>3
929 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100930 CheckScriptFailure(lines, 'E1004: White space required before and after ''>'' at ">3"', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200931 lines =<< trim END
932 vim9script
933 echo 2 >3
934 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200935 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200936 lines =<< trim END
937 vim9script
938 echo 2> 3
939 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200940 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200941 lines =<< trim END
942 vim9script
943 echo 2!=3
944 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200945 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200946 lines =<< trim END
947 vim9script
948 echo 2 !=3
949 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100950 CheckScriptFailure(lines, 'E1004: White space required before and after ''!'' at "!=3"', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200951 lines =<< trim END
952 vim9script
953 echo 2!= 3
954 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200955 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar8294d492020-08-10 22:40:56 +0200956
957 lines =<< trim END
958 vim9script
959 echo len('xxx') == 3
960 END
961 CheckScriptSuccess(lines)
Bram Moolenaarf9235712020-08-16 18:42:53 +0200962
963 lines =<< trim END
964 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200965 var line = 'abc'
Bram Moolenaarf9235712020-08-16 18:42:53 +0200966 echo line[1] =~ '\w'
967 END
968 CheckScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200969enddef
970
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100971func Test_expr4_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +0200972 let msg = "White space required before and after '>'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200973 call CheckDefFailure(["var x = 1>2"], msg, 1)
974 call CheckDefFailure(["var x = 1 >2"], msg, 1)
975 call CheckDefFailure(["var x = 1> 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100976
Bram Moolenaar77072282020-09-16 17:55:40 +0200977 let msg = "White space required before and after '=='"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200978 call CheckDefFailure(["var x = 1==2"], msg, 1)
979 call CheckDefFailure(["var x = 1 ==2"], msg, 1)
980 call CheckDefFailure(["var x = 1== 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100981
Bram Moolenaar77072282020-09-16 17:55:40 +0200982 let msg = "White space required before and after 'is'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200983 call CheckDefFailure(["var x = '1'is'2'"], msg, 1)
984 call CheckDefFailure(["var x = '1' is'2'"], msg, 1)
985 call CheckDefFailure(["var x = '1'is '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100986
Bram Moolenaar77072282020-09-16 17:55:40 +0200987 let msg = "White space required before and after 'isnot'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200988 call CheckDefFailure(["var x = '1'isnot'2'"], msg, 1)
989 call CheckDefFailure(["var x = '1' isnot'2'"], msg, 1)
990 call CheckDefFailure(["var x = '1'isnot '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100991
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200992 call CheckDefFailure(["var x = 1 is# 2"], 'E15:', 1)
993 call CheckDefFailure(["var x = 1 is? 2"], 'E15:', 1)
994 call CheckDefFailure(["var x = 1 isnot# 2"], 'E15:', 1)
995 call CheckDefFailure(["var x = 1 isnot? 2"], 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100996
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200997 call CheckDefFailure(["var x = 1 == '2'"], 'Cannot compare number with string', 1)
998 call CheckDefFailure(["var x = '1' == 2"], 'Cannot compare string with number', 1)
999 call CheckDefFailure(["var x = 1 == RetVoid()"], 'Cannot compare number with void', 1)
1000 call CheckDefFailure(["var x = RetVoid() == 1"], 'Cannot compare void with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001001
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001002 call CheckDefFailure(["var x = true > false"], 'Cannot compare bool with bool', 1)
1003 call CheckDefFailure(["var x = true >= false"], 'Cannot compare bool with bool', 1)
1004 call CheckDefFailure(["var x = true < false"], 'Cannot compare bool with bool', 1)
1005 call CheckDefFailure(["var x = true <= false"], 'Cannot compare bool with bool', 1)
1006 call CheckDefFailure(["var x = true =~ false"], 'Cannot compare bool with bool', 1)
1007 call CheckDefFailure(["var x = true !~ false"], 'Cannot compare bool with bool', 1)
1008 call CheckDefFailure(["var x = true is false"], 'Cannot use "is" with bool', 1)
1009 call CheckDefFailure(["var x = true isnot false"], 'Cannot use "isnot" with bool', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001010
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001011 call CheckDefFailure(["var x = v:none is v:null"], 'Cannot use "is" with special', 1)
1012 call CheckDefFailure(["var x = v:none isnot v:null"], 'Cannot use "isnot" with special', 1)
1013 call CheckDefFailure(["var x = 123 is 123"], 'Cannot use "is" with number', 1)
1014 call CheckDefFailure(["var x = 123 isnot 123"], 'Cannot use "isnot" with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001015 if has('float')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001016 call CheckDefFailure(["var x = 1.3 is 1.3"], 'Cannot use "is" with float', 1)
1017 call CheckDefFailure(["var x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001018 endif
1019
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001020 call CheckDefFailure(["var x = 0za1 > 0z34"], 'Cannot compare blob with blob', 1)
1021 call CheckDefFailure(["var x = 0za1 >= 0z34"], 'Cannot compare blob with blob', 1)
1022 call CheckDefFailure(["var x = 0za1 < 0z34"], 'Cannot compare blob with blob', 1)
1023 call CheckDefFailure(["var x = 0za1 <= 0z34"], 'Cannot compare blob with blob', 1)
1024 call CheckDefFailure(["var x = 0za1 =~ 0z34"], 'Cannot compare blob with blob', 1)
1025 call CheckDefFailure(["var x = 0za1 !~ 0z34"], 'Cannot compare blob with blob', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001026
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001027 call CheckDefFailure(["var x = [13] > [88]"], 'Cannot compare list with list', 1)
1028 call CheckDefFailure(["var x = [13] >= [88]"], 'Cannot compare list with list', 1)
1029 call CheckDefFailure(["var x = [13] < [88]"], 'Cannot compare list with list', 1)
1030 call CheckDefFailure(["var x = [13] <= [88]"], 'Cannot compare list with list', 1)
1031 call CheckDefFailure(["var x = [13] =~ [88]"], 'Cannot compare list with list', 1)
1032 call CheckDefFailure(["var x = [13] !~ [88]"], 'Cannot compare list with list', 1)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001033
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001034 call CheckDefFailure(['var j: job', 'var chan: channel', 'var r = j == chan'], 'Cannot compare job with channel', 3)
1035 call CheckDefFailure(['var j: job', 'var x: list<any>', 'var r = j == x'], 'Cannot compare job with list', 3)
1036 call CheckDefFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
1037 call CheckDefFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001038endfunc
1039
1040" test addition, subtraction, concatenation
1041def Test_expr5()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001042 var lines =<< trim END
1043 assert_equal(66, 60 + 6)
1044 assert_equal(70, 60 +
1045 g:anint)
1046 assert_equal(9, g:thefour
1047 + 5)
1048 assert_equal(14, g:thefour + g:anint)
1049 assert_equal([1, 2, 3, 4], [1] + g:alist)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001050
Bram Moolenaar659bb222020-11-12 20:16:39 +01001051 assert_equal(54, 60 - 6)
1052 assert_equal(50, 60 -
1053 g:anint)
1054 assert_equal(-1, g:thefour
1055 - 5)
1056 assert_equal(-6, g:thefour - g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001057
Bram Moolenaar659bb222020-11-12 20:16:39 +01001058 assert_equal('hello', 'hel' .. 'lo')
1059 assert_equal('hello 123', 'hello ' ..
1060 123)
1061 assert_equal('hello 123', 'hello '
1062 .. 123)
1063 assert_equal('123 hello', 123 .. ' hello')
1064 assert_equal('123456', 123 .. 456)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001065
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001066 assert_equal('atrue', 'a' .. true)
1067 assert_equal('afalse', 'a' .. false)
Bram Moolenaar67977822021-01-03 21:53:53 +01001068 assert_equal('anull', 'a' .. v:null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001069 assert_equal('av:none', 'a' .. v:none)
1070 if has('float')
1071 assert_equal('a0.123', 'a' .. 0.123)
1072 endif
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001073
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001074 set digraph
1075 assert_equal('val: true', 'val: ' .. &digraph)
1076 set nodigraph
1077 assert_equal('val: false', 'val: ' .. &digraph)
1078
Bram Moolenaar659bb222020-11-12 20:16:39 +01001079 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
1080 assert_equal(0z11223344, 0z1122 + 0z3344)
1081 assert_equal(0z112201ab, 0z1122
1082 + g:ablob)
1083 assert_equal(0z01ab3344, g:ablob + 0z3344)
1084 assert_equal(0z01ab01ab, g:ablob + g:ablob)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001085
Bram Moolenaar659bb222020-11-12 20:16:39 +01001086 # concatenate non-constant to constant
1087 var save_path = &path
1088 &path = 'b'
1089 assert_equal('ab', 'a' .. &path)
1090 &path = save_path
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001091
Bram Moolenaar659bb222020-11-12 20:16:39 +01001092 @b = 'b'
1093 assert_equal('ab', 'a' .. @b)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001094
Bram Moolenaar659bb222020-11-12 20:16:39 +01001095 $ENVVAR = 'env'
1096 assert_equal('aenv', 'a' .. $ENVVAR)
Bram Moolenaard62d87d2021-01-04 17:40:12 +01001097
1098 assert_equal('val', '' .. {key: 'val'}['key'])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001099 END
1100 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001101enddef
1102
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001103def Test_expr5_vim9script()
Bram Moolenaar696ba232020-07-29 21:20:41 +02001104 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001105 var lines =<< trim END
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001106 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001107 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001108 + 77
1109 - 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001110 assert_equal(66, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001111 END
1112 CheckScriptSuccess(lines)
1113
1114 lines =<< trim END
1115 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001116 var name = 11 +
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001117 77 -
1118 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001119 assert_equal(66, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001120 END
1121 CheckScriptSuccess(lines)
1122
1123 lines =<< trim END
1124 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +02001125 var name = 11 + # comment
1126 77 -
1127 # comment
1128 22
1129 assert_equal(66, name)
1130 END
1131 CheckScriptSuccess(lines)
1132
1133 lines =<< trim END
1134 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001135 var name = 'one'
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001136 .. 'two'
Bram Moolenaar98309382020-09-27 21:58:45 +02001137 assert_equal('onetwo', name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001138 END
1139 CheckScriptSuccess(lines)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001140
1141 lines =<< trim END
1142 vim9script
1143 echo 'abc' is# 'abc'
1144 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001145 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001146
1147 lines =<< trim END
1148 vim9script
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001149 echo {} - 22
1150 END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001151 CheckScriptFailure(lines, 'E728:', 2)
1152
1153 lines =<< trim END
1154 vim9script
1155 echo [] - 33
1156 END
1157 CheckScriptFailure(lines, 'E745:', 2)
1158
1159 lines =<< trim END
1160 vim9script
1161 echo 0z1234 - 44
1162 END
1163 CheckScriptFailure(lines, 'E974:', 2)
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001164
1165 lines =<< trim END
1166 vim9script
Bram Moolenaar696ba232020-07-29 21:20:41 +02001167 echo 'abc' is? 'abc'
1168 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001169 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001170
1171 lines =<< trim END
1172 vim9script
1173 echo 'abc' isnot# 'abc'
1174 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001175 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001176
1177 lines =<< trim END
1178 vim9script
1179 echo 'abc' isnot? 'abc'
1180 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001181 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001182
1183 # check white space
1184 lines =<< trim END
1185 vim9script
1186 echo 5+6
1187 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001188 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001189 lines =<< trim END
1190 vim9script
1191 echo 5 +6
1192 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001193 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001194 lines =<< trim END
1195 vim9script
1196 echo 5+ 6
1197 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001198 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001199
1200 lines =<< trim END
1201 vim9script
1202 echo 'a'..'b'
1203 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001204 CheckScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001205 lines =<< trim END
1206 vim9script
1207 echo 'a' ..'b'
1208 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001209 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001210 lines =<< trim END
1211 vim9script
1212 echo 'a'.. 'b'
1213 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001214 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001215
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001216 # check invalid string concatenation
1217 lines =<< trim END
1218 vim9script
1219 echo 'a' .. [1]
1220 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001221 CheckScriptFailure(lines, 'E730:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001222 lines =<< trim END
1223 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01001224 echo 'a' .. {a: 1}
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001225 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001226 CheckScriptFailure(lines, 'E731:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001227 lines =<< trim END
1228 vim9script
1229 echo 'a' .. test_void()
1230 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001231 CheckScriptFailure(lines, 'E908:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001232 lines =<< trim END
1233 vim9script
1234 echo 'a' .. 0z33
1235 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001236 CheckScriptFailure(lines, 'E976:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001237 lines =<< trim END
1238 vim9script
1239 echo 'a' .. function('len')
1240 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001241 CheckScriptFailure(lines, 'E729:', 2)
Bram Moolenaar79182382020-09-05 20:06:33 +02001242enddef
1243
1244def Test_expr5_vim9script_channel()
1245 if !has('channel')
1246 MissingFeature 'float'
1247 else
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001248 var lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001249 vim9script
1250 echo 'a' .. test_null_job()
1251 END
1252 CheckScriptFailure(lines, 'E908:', 2)
1253 lines =<< trim END
1254 vim9script
1255 echo 'a' .. test_null_channel()
1256 END
1257 CheckScriptFailure(lines, 'E908:', 2)
1258 endif
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001259enddef
1260
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001261def Test_expr5_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001262 if !has('float')
1263 MissingFeature 'float'
1264 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001265 var lines =<< trim END
1266 assert_equal(66.0, 60.0 + 6.0)
1267 assert_equal(66.0, 60.0 + 6)
1268 assert_equal(66.0, 60 +
1269 6.0)
1270 assert_equal(5.1, g:afloat
1271 + 5)
1272 assert_equal(8.1, 8 + g:afloat)
1273 assert_equal(10.1, g:anint + g:afloat)
1274 assert_equal(10.1, g:afloat + g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001275
Bram Moolenaar659bb222020-11-12 20:16:39 +01001276 assert_equal(54.0, 60.0 - 6.0)
1277 assert_equal(54.0, 60.0
1278 - 6)
1279 assert_equal(54.0, 60 - 6.0)
1280 assert_equal(-4.9, g:afloat - 5)
1281 assert_equal(7.9, 8 - g:afloat)
1282 assert_equal(9.9, g:anint - g:afloat)
1283 assert_equal(-9.9, g:afloat - g:anint)
1284 END
1285 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001286 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001287enddef
1288
1289func Test_expr5_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001290 let msg = "White space required before and after '+'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001291 call CheckDefFailure(["var x = 1+2"], msg, 1)
1292 call CheckDefFailure(["var x = 1 +2"], msg, 1)
1293 call CheckDefFailure(["var x = 1+ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001294
Bram Moolenaar77072282020-09-16 17:55:40 +02001295 let msg = "White space required before and after '-'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001296 call CheckDefFailure(["var x = 1-2"], msg, 1)
1297 call CheckDefFailure(["var x = 1 -2"], msg, 1)
1298 call CheckDefFailure(["var x = 1- 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001299
Bram Moolenaar77072282020-09-16 17:55:40 +02001300 let msg = "White space required before and after '..'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001301 call CheckDefFailure(["var x = '1'..'2'"], msg, 1)
1302 call CheckDefFailure(["var x = '1' ..'2'"], msg, 1)
1303 call CheckDefFailure(["var x = '1'.. '2'"], msg, 1)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001304
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001305 call CheckDefFailure(["var x = 0z1122 + 33"], 'E1051:', 1)
1306 call CheckDefFailure(["var x = 0z1122 + [3]"], 'E1051:', 1)
1307 call CheckDefFailure(["var x = 0z1122 + 'asd'"], 'E1051:', 1)
1308 call CheckDefFailure(["var x = 33 + 0z1122"], 'E1051:', 1)
1309 call CheckDefFailure(["var x = [3] + 0z1122"], 'E1051:', 1)
1310 call CheckDefFailure(["var x = 'asdf' + 0z1122"], 'E1051:', 1)
1311 call CheckDefFailure(["var x = 6 + xxx"], 'E1001:', 1)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001312
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001313 call CheckDefFailure(["var x = 'a' .. [1]"], 'E1105:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01001314 call CheckDefFailure(["var x = 'a' .. {a: 1}"], 'E1105:', 1)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001315 call CheckDefFailure(["var x = 'a' .. test_void()"], 'E1105:', 1)
1316 call CheckDefFailure(["var x = 'a' .. 0z32"], 'E1105:', 1)
1317 call CheckDefFailure(["var x = 'a' .. function('len')"], 'E1105:', 1)
1318 call CheckDefFailure(["var x = 'a' .. function('len', ['a'])"], 'E1105:', 1)
Bram Moolenaard92cc132020-11-18 17:17:15 +01001319
1320 call CheckScriptFailure(['vim9script', 'var x = 1 + v:none'], 'E611:', 2)
1321 call CheckScriptFailure(['vim9script', 'var x = 1 + v:null'], 'E611:', 2)
1322 call CheckScriptFailure(['vim9script', 'var x = 1 + v:true'], 'E1138:', 2)
1323 call CheckScriptFailure(['vim9script', 'var x = 1 + v:false'], 'E1138:', 2)
1324 call CheckScriptFailure(['vim9script', 'var x = 1 + true'], 'E1138:', 2)
1325 call CheckScriptFailure(['vim9script', 'var x = 1 + false'], 'E1138:', 2)
Bram Moolenaar79182382020-09-05 20:06:33 +02001326endfunc
1327
1328func Test_expr5_fails_channel()
1329 CheckFeature channel
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001330 call CheckDefFailure(["var x = 'a' .. test_null_job()"], 'E1105:', 1)
1331 call CheckDefFailure(["var x = 'a' .. test_null_channel()"], 'E1105:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001332endfunc
1333
Bram Moolenaar399ea812020-12-15 21:28:57 +01001334def Test_expr5_list_add()
1335 # concatenating two lists with same member types is OK
1336 var d = {}
1337 for i in ['a'] + ['b']
1338 d = {[i]: 0}
1339 endfor
1340
1341 # concatenating two lists with different member types results in "any"
1342 var lines =<< trim END
1343 var d = {}
1344 for i in ['a'] + [0]
1345 d = {[i]: 0}
1346 endfor
1347 END
1348 CheckDefExecFailure(lines, 'E1012:')
1349enddef
1350
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001351" test multiply, divide, modulo
1352def Test_expr6()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001353 var lines =<< trim END
1354 assert_equal(36, 6 * 6)
1355 assert_equal(24, 6 *
1356 g:thefour)
1357 assert_equal(24, g:thefour
1358 * 6)
1359 assert_equal(40, g:anint * g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001360
Bram Moolenaar659bb222020-11-12 20:16:39 +01001361 assert_equal(10, 60 / 6)
1362 assert_equal(6, 60 /
1363 g:anint)
1364 assert_equal(1, g:anint / 6)
1365 assert_equal(2, g:anint
1366 / g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001367
Bram Moolenaar659bb222020-11-12 20:16:39 +01001368 assert_equal(5, 11 % 6)
1369 assert_equal(4, g:anint % 6)
1370 assert_equal(3, 13 %
1371 g:anint)
1372 assert_equal(2, g:anint
1373 % g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001374
Bram Moolenaar659bb222020-11-12 20:16:39 +01001375 assert_equal(4, 6 * 4 / 6)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001376
Bram Moolenaar659bb222020-11-12 20:16:39 +01001377 var x = [2]
1378 var y = [3]
1379 assert_equal(5, x[0] + y[0])
1380 assert_equal(6, x[0] * y[0])
1381 if has('float')
1382 var xf = [2.0]
1383 var yf = [3.0]
1384 assert_equal(5.0, xf[0]
1385 + yf[0])
1386 assert_equal(6.0, xf[0]
1387 * yf[0])
1388 endif
1389 END
1390 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001391
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001392 CheckDefFailure(["var x = 6 * xxx"], 'E1001:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001393 CheckDefFailure(["var d = 6 * "], 'E1097:', 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001394enddef
1395
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001396def Test_expr6_vim9script()
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001397 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001398 var lines =<< trim END
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001399 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001400 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001401 * 22
1402 / 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001403 assert_equal(80, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001404 END
1405 CheckScriptSuccess(lines)
1406
1407 lines =<< trim END
1408 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001409 var name = 25
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001410 % 10
Bram Moolenaar98309382020-09-27 21:58:45 +02001411 assert_equal(5, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001412 END
1413 CheckScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001414
1415 lines =<< trim END
1416 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +02001417 var name = 25
1418 # comment
1419
1420 # comment
1421 % 10
1422 assert_equal(5, name)
1423 END
1424 CheckScriptSuccess(lines)
1425
1426 lines =<< trim END
1427 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001428 var name = 11 *
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001429 22 /
1430 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001431 assert_equal(80, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001432 END
1433 CheckScriptSuccess(lines)
1434
1435 # check white space
1436 lines =<< trim END
1437 vim9script
1438 echo 5*6
1439 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001440 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001441 lines =<< trim END
1442 vim9script
1443 echo 5 *6
1444 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001445 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001446 lines =<< trim END
1447 vim9script
1448 echo 5* 6
1449 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001450 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001451enddef
1452
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001453def Test_expr6_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001454 if !has('float')
1455 MissingFeature 'float'
1456 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001457 var lines =<< trim END
1458 assert_equal(36.0, 6.0 * 6)
1459 assert_equal(36.0, 6 *
1460 6.0)
1461 assert_equal(36.0, 6.0 * 6.0)
1462 assert_equal(1.0, g:afloat * g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001463
Bram Moolenaar659bb222020-11-12 20:16:39 +01001464 assert_equal(10.0, 60 / 6.0)
1465 assert_equal(10.0, 60.0 /
1466 6)
1467 assert_equal(10.0, 60.0 / 6.0)
1468 assert_equal(0.01, g:afloat / g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001469
Bram Moolenaar659bb222020-11-12 20:16:39 +01001470 assert_equal(4.0, 6.0 * 4 / 6)
1471 assert_equal(4.0, 6 *
1472 4.0 /
1473 6)
1474 assert_equal(4.0, 6 * 4 / 6.0)
1475 assert_equal(4.0, 6.0 * 4.0 / 6)
1476 assert_equal(4.0, 6 * 4.0 / 6.0)
1477 assert_equal(4.0, 6.0 * 4 / 6.0)
1478 assert_equal(4.0, 6.0 * 4.0 / 6.0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001479
Bram Moolenaar659bb222020-11-12 20:16:39 +01001480 assert_equal(4.0, 6.0 * 4.0 / 6.0)
1481 END
1482 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001483 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001484enddef
1485
1486func Test_expr6_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001487 let msg = "White space required before and after '*'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001488 call CheckDefFailure(["var x = 1*2"], msg, 1)
1489 call CheckDefFailure(["var x = 1 *2"], msg, 1)
1490 call CheckDefFailure(["var x = 1* 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001491
Bram Moolenaar77072282020-09-16 17:55:40 +02001492 let msg = "White space required before and after '/'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001493 call CheckDefFailure(["var x = 1/2"], msg, 1)
1494 call CheckDefFailure(["var x = 1 /2"], msg, 1)
1495 call CheckDefFailure(["var x = 1/ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001496
Bram Moolenaar77072282020-09-16 17:55:40 +02001497 let msg = "White space required before and after '%'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001498 call CheckDefFailure(["var x = 1%2"], msg, 1)
1499 call CheckDefFailure(["var x = 1 %2"], msg, 1)
1500 call CheckDefFailure(["var x = 1% 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001501
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001502 call CheckDefFailure(["var x = '1' * '2'"], 'E1036:', 1)
1503 call CheckDefFailure(["var x = '1' / '2'"], 'E1036:', 1)
1504 call CheckDefFailure(["var x = '1' % '2'"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001505
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001506 call CheckDefFailure(["var x = 0z01 * 0z12"], 'E1036:', 1)
1507 call CheckDefFailure(["var x = 0z01 / 0z12"], 'E1036:', 1)
1508 call CheckDefFailure(["var x = 0z01 % 0z12"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001509
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001510 call CheckDefFailure(["var x = [1] * [2]"], 'E1036:', 1)
1511 call CheckDefFailure(["var x = [1] / [2]"], 'E1036:', 1)
1512 call CheckDefFailure(["var x = [1] % [2]"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001513
Bram Moolenaare0de1712020-12-02 17:36:54 +01001514 call CheckDefFailure(["var x = {one: 1} * {two: 2}"], 'E1036:', 1)
1515 call CheckDefFailure(["var x = {one: 1} / {two: 2}"], 'E1036:', 1)
1516 call CheckDefFailure(["var x = {one: 1} % {two: 2}"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001517
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001518 call CheckDefFailure(["var x = 0xff[1]"], 'E1107:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001519 if has('float')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001520 call CheckDefFailure(["var x = 0.7[1]"], 'E1107:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001521 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001522endfunc
1523
1524func Test_expr6_float_fails()
1525 CheckFeature float
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001526 call CheckDefFailure(["var x = 1.0 % 2"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001527endfunc
1528
1529" define here to use old style parsing
1530if has('float')
1531 let g:float_zero = 0.0
1532 let g:float_neg = -9.8
1533 let g:float_big = 9.9e99
1534endif
1535let g:blob_empty = 0z
1536let g:blob_one = 0z01
1537let g:blob_long = 0z0102.0304
1538
1539let g:string_empty = ''
1540let g:string_short = 'x'
1541let g:string_long = 'abcdefghijklm'
1542let g:string_special = "ab\ncd\ref\ekk"
1543
1544let g:special_true = v:true
1545let g:special_false = v:false
1546let g:special_null = v:null
1547let g:special_none = v:none
1548
1549let g:list_empty = []
1550let g:list_mixed = [1, 'b', v:false]
1551
1552let g:dict_empty = {}
1553let g:dict_one = #{one: 1}
1554
1555let $TESTVAR = 'testvar'
1556
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001557" type casts
1558def Test_expr7t()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001559 var ls: list<string> = ['a', <string>g:string_empty]
1560 var ln: list<number> = [<number>g:anint, <number>g:thefour]
1561 var nr = <number>234
Bram Moolenaard1103582020-08-14 22:44:25 +02001562 assert_equal(234, nr)
1563
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001564 CheckDefFailure(["var x = <nr>123"], 'E1010:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001565 CheckDefFailure(["var x = <number>"], 'E1097:', 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001566 CheckDefFailure(["var x = <number >123"], 'E1068:', 1)
1567 CheckDefFailure(["var x = <number 123"], 'E1104:', 1)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001568enddef
1569
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001570" test low level expression
1571def Test_expr7_number()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001572 # number constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001573 var lines =<< trim END
1574 assert_equal(0, 0)
1575 assert_equal(654, 0654)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001576
Bram Moolenaar659bb222020-11-12 20:16:39 +01001577 assert_equal(6, 0x6)
1578 assert_equal(15, 0xf)
1579 assert_equal(255, 0xff)
1580 END
1581 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001582enddef
1583
1584def Test_expr7_float()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001585 # float constant
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001586 if !has('float')
1587 MissingFeature 'float'
1588 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001589 var lines =<< trim END
1590 assert_equal(g:float_zero, .0)
1591 assert_equal(g:float_zero, 0.0)
1592 assert_equal(g:float_neg, -9.8)
1593 assert_equal(g:float_big, 9.9e99)
1594 END
1595 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001596 endif
1597enddef
1598
1599def Test_expr7_blob()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001600 # blob constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001601 var lines =<< trim END
1602 assert_equal(g:blob_empty, 0z)
1603 assert_equal(g:blob_one, 0z01)
1604 assert_equal(g:blob_long, 0z0102.0304)
1605 END
1606 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001607
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001608 CheckDefFailure(["var x = 0z123"], 'E973:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001609enddef
1610
1611def Test_expr7_string()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001612 # string constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001613 var lines =<< trim END
1614 assert_equal(g:string_empty, '')
1615 assert_equal(g:string_empty, "")
1616 assert_equal(g:string_short, 'x')
1617 assert_equal(g:string_short, "x")
1618 assert_equal(g:string_long, 'abcdefghijklm')
1619 assert_equal(g:string_long, "abcdefghijklm")
1620 assert_equal(g:string_special, "ab\ncd\ref\ekk")
1621 END
1622 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001623
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001624 CheckDefFailure(['var x = "abc'], 'E114:', 1)
1625 CheckDefFailure(["var x = 'abc"], 'E115:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001626enddef
1627
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001628def Test_expr7_vimvar()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001629 var old: list<string> = v:oldfiles
1630 var compl: dict<any> = v:completed_item
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001631
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001632 CheckDefFailure(["var old: list<number> = v:oldfiles"], 'E1012: Type mismatch; expected list<number> but got list<string>', 1)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001633 new
1634 exec "normal! afoo fo\<C-N>\<Esc>"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001635 CheckDefExecFailure(["var old: dict<number> = v:completed_item"], 'E1012: Type mismatch; expected dict<number> but got dict<string>', 1)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001636 bwipe!
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001637enddef
1638
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001639def Test_expr7_special()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001640 # special constant
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001641 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001642 assert_equal(g:special_true, true)
1643 assert_equal(g:special_false, false)
1644 assert_equal(g:special_true, v:true)
1645 assert_equal(g:special_false, v:false)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001646 assert_equal(v:true, true)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001647 assert_equal(v:false, false)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001648
Bram Moolenaar6e4cfff2020-08-09 22:17:55 +02001649 assert_equal(true, !false)
1650 assert_equal(false, !true)
1651 assert_equal(true, !0)
1652 assert_equal(false, !1)
1653 assert_equal(false, !!false)
1654 assert_equal(true, !!true)
1655 assert_equal(false, !!0)
1656 assert_equal(true, !!1)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001657
1658 var t = true
1659 var f = false
1660 assert_equal(true, t)
1661 assert_equal(false, f)
1662
1663 assert_equal(g:special_null, v:null)
Bram Moolenaar67977822021-01-03 21:53:53 +01001664 assert_equal(g:special_null, null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001665 assert_equal(g:special_none, v:none)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001666 END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001667 CheckDefAndScriptSuccess(lines)
1668
1669 CheckDefFailure(['v:true = true'], 'E46:', 1)
1670 CheckDefFailure(['v:true = false'], 'E46:', 1)
1671 CheckDefFailure(['v:false = true'], 'E46:', 1)
1672 CheckDefFailure(['v:null = 11'], 'E46:', 1)
1673 CheckDefFailure(['v:none = 22'], 'E46:', 1)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001674enddef
1675
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001676def Test_expr7_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001677 # list
Bram Moolenaar659bb222020-11-12 20:16:39 +01001678 var lines =<< trim END
1679 assert_equal(g:list_empty, [])
1680 assert_equal(g:list_empty, [ ])
Bram Moolenaar127542b2020-08-09 17:22:04 +02001681
Bram Moolenaar659bb222020-11-12 20:16:39 +01001682 var numbers: list<number> = [1, 2, 3]
1683 numbers = [1]
1684 numbers = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001685
Bram Moolenaar659bb222020-11-12 20:16:39 +01001686 var strings: list<string> = ['a', 'b', 'c']
1687 strings = ['x']
1688 strings = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001689
Bram Moolenaar659bb222020-11-12 20:16:39 +01001690 var mixed: list<any> = [1, 'b', false,]
1691 assert_equal(g:list_mixed, mixed)
1692 assert_equal('b', mixed[1])
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001693
Bram Moolenaar659bb222020-11-12 20:16:39 +01001694 echo [1,
1695 2] [3,
1696 4]
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001697
Bram Moolenaar659bb222020-11-12 20:16:39 +01001698 var llstring: list<list<string>> = [['text'], []]
1699 llstring = [[], ['text']]
1700 llstring = [[], []]
1701 END
1702 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02001703
Bram Moolenaar5597ba02020-09-27 17:45:03 +02001704 var rangelist: list<number> = range(3)
1705 g:rangelist = range(3)
1706 CheckDefExecFailure(["var x: list<string> = g:rangelist"], 'E1012: Type mismatch; expected list<string> but got list<number>', 1)
1707
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001708 CheckDefFailure(["var x = 1234[3]"], 'E1107:', 1)
1709 CheckDefExecFailure(["var x = g:anint[3]"], 'E1062:', 1)
Bram Moolenaar56acb092020-08-16 14:48:19 +02001710
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001711 CheckDefFailure(["var x = g:list_mixed[xxx]"], 'E1001:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001712
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001713 CheckDefFailure(["var x = [1,2,3]"], 'E1069:', 1)
1714 CheckDefFailure(["var x = [1 ,2, 3]"], 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001715
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001716 CheckDefExecFailure(["echo 1", "var x = [][0]", "echo 3"], 'E684:', 2)
Bram Moolenaar1d634542020-08-18 13:41:50 +02001717
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001718 CheckDefExecFailure(["var x = g:list_mixed['xx']"], 'E1012:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001719 CheckDefFailure(["var x = g:list_mixed["], 'E1097:', 3)
1720 CheckDefFailure(["var x = g:list_mixed[0"], 'E1097:', 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001721 CheckDefExecFailure(["var x = g:list_empty[3]"], 'E684:', 1)
1722 CheckDefExecFailure(["var l: list<number> = [234, 'x']"], 'E1012:', 1)
1723 CheckDefExecFailure(["var l: list<number> = ['x', 234]"], 'E1012:', 1)
1724 CheckDefExecFailure(["var l: list<string> = [234, 'x']"], 'E1012:', 1)
1725 CheckDefExecFailure(["var l: list<string> = ['x', 123]"], 'E1012:', 1)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001726
Bram Moolenaar659bb222020-11-12 20:16:39 +01001727 lines =<< trim END
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001728 vim9script
1729 var datalist: list<string>
1730 def Main()
1731 datalist += ['x'.
1732 enddef
1733 Main()
1734 END
1735 CheckScriptFailure(lines, 'E1127:')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001736
1737 lines =<< trim END
1738 var numbers = [1, 2, 3, 4]
1739 var a = 1
1740 var b = 2
1741 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001742 CheckDefAndScriptFailure(lines + ['echo numbers[1:b]'],
1743 'E1004: White space required before and after '':'' at ":b]"', 4)
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001744 CheckDefAndScriptFailure(lines + ['echo numbers[1: b]'], 'E1004:', 4)
1745 CheckDefAndScriptFailure(lines + ['echo numbers[a :b]'], 'E1004:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001746enddef
1747
Bram Moolenaar71478202020-06-26 22:46:27 +02001748def Test_expr7_list_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001749 var lines =<< trim END
Bram Moolenaar71478202020-06-26 22:46:27 +02001750 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001751 var l = [
Bram Moolenaar71478202020-06-26 22:46:27 +02001752 11,
1753 22,
1754 ]
1755 assert_equal([11, 22], l)
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001756
1757 echo [1,
1758 2] [3,
1759 4]
Bram Moolenaar93be1642020-10-11 21:34:41 +02001760
1761 echo [1, # comment
1762 # comment
1763 2] [3,
1764 # comment
1765 4]
Bram Moolenaar71478202020-06-26 22:46:27 +02001766 END
1767 CheckScriptSuccess(lines)
1768
1769 lines =<< trim END
1770 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001771 var l = [11,
Bram Moolenaar71478202020-06-26 22:46:27 +02001772 22]
1773 assert_equal([11, 22], l)
1774 END
1775 CheckScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001776
1777 lines =<< trim END
1778 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001779 var l = [11,22]
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001780 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001781 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02001782
1783 lines =<< trim END
1784 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001785 var l = [11 , 22]
Bram Moolenaardb199212020-08-12 18:01:53 +02001786 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001787 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001788
1789 lines =<< trim END
1790 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001791 var l: list<number> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001792 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001793 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001794 lines =<< trim END
1795 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001796 var l: list<number> = ['x', 234]
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001797 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001798 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001799 lines =<< trim END
1800 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001801 var l: list<string> = ['x', 234]
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001802 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001803 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001804 lines =<< trim END
1805 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001806 var l: list<string> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001807 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001808 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01001809
1810 lines =<< trim END
1811 vim9script
1812 def Failing()
1813 job_stop()
1814 enddef
1815 var list = [Failing]
1816 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001817 if has('channel')
1818 CheckScriptFailure(lines, 'E119:', 1)
1819 else
1820 CheckScriptFailure(lines, 'E117:', 1)
1821 endif
Bram Moolenaar71478202020-06-26 22:46:27 +02001822enddef
1823
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001824def LambdaWithComments(): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001825 return (x) =>
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001826 # some comment
1827 x == 1
1828 # some comment
1829 ||
1830 x == 2
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001831enddef
1832
Bram Moolenaarfd777482020-08-12 19:42:01 +02001833def LambdaUsingArg(x: number): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001834 return () =>
Bram Moolenaarfd777482020-08-12 19:42:01 +02001835 # some comment
1836 x == 1
1837 # some comment
1838 ||
1839 x == 2
Bram Moolenaarfd777482020-08-12 19:42:01 +02001840enddef
1841
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001842def Test_expr7_lambda()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001843 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001844 var La = () => 'result'
Bram Moolenaar659bb222020-11-12 20:16:39 +01001845 assert_equal('result', La())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001846 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02001847
Bram Moolenaar659bb222020-11-12 20:16:39 +01001848 # line continuation inside lambda with "cond ? expr : expr" works
1849 var ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001850 map(ll, (k, v) => v % 2 ? {
Bram Moolenaare0de1712020-12-02 17:36:54 +01001851 ['111']: 111 } : {}
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001852 )
Bram Moolenaare0de1712020-12-02 17:36:54 +01001853 assert_equal([{}, {111: 111}, {}], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001854
Bram Moolenaar659bb222020-11-12 20:16:39 +01001855 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001856 map(ll, (k, v) => v == 8 || v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001857 == 9
1858 || v % 2 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001859 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001860 assert_equal([222, 111, 222], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001861
Bram Moolenaar659bb222020-11-12 20:16:39 +01001862 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001863 map(ll, (k, v) => v != 8 && v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001864 != 9
1865 && v % 2 == 0 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001866 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001867 assert_equal([111, 222, 111], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001868
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001869 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
Bram Moolenaare0de1712020-12-02 17:36:54 +01001870 assert_equal([{key: 22}], dl)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02001871
Bram Moolenaare0de1712020-12-02 17:36:54 +01001872 dl = [{key: 12}, {['foo']: 34}]
1873 assert_equal([{key: 12}], filter(dl,
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001874 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
Bram Moolenaar7892b952020-07-20 22:09:34 +02001875
Bram Moolenaar659bb222020-11-12 20:16:39 +01001876 assert_equal(false, LambdaWithComments()(0))
1877 assert_equal(true, LambdaWithComments()(1))
1878 assert_equal(true, LambdaWithComments()(2))
1879 assert_equal(false, LambdaWithComments()(3))
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001880
Bram Moolenaar659bb222020-11-12 20:16:39 +01001881 assert_equal(false, LambdaUsingArg(0)())
1882 assert_equal(true, LambdaUsingArg(1)())
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001883
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001884 var res = map([1, 2, 3], (i: number, v: number) => i + v)
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001885 assert_equal([1, 3, 5], res)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001886 END
1887 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfd777482020-08-12 19:42:01 +02001888
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001889 CheckDefFailure(["var Ref = (a)=>a + 1"], 'E1004:')
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001890 CheckDefFailure(["var Ref = (a)=> a + 1"], 'E1004: White space required before and after ''=>'' at "=> a + 1"')
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001891 CheckDefFailure(["var Ref = (a) =>a + 1"], 'E1004:')
Bram Moolenaar27bf7af2020-12-23 20:27:31 +01001892
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001893 CheckDefFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001894 # error is in first line of the lambda
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001895 CheckDefFailure(["var L = (a) => a + b"], 'E1001:', 0)
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001896
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001897 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001898
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001899 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"], 'E118:')
1900 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"], 'E118:')
1901 CheckDefFailure(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 1)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02001902
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001903 CheckDefSuccess(['var Fx = (a) => ({k1: 0,', ' k2: 1})'])
1904 CheckDefFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
1905 CheckDefFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02001906
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001907 CheckDefSuccess(['var Fx = (a) => [0,', ' 1]'])
1908 CheckDefFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001909enddef
1910
Bram Moolenaar65c44152020-12-24 15:14:01 +01001911def NewLambdaWithComments(): func
1912 return (x) =>
1913 # some comment
1914 x == 1
1915 # some comment
1916 ||
1917 x == 2
1918enddef
1919
1920def NewLambdaUsingArg(x: number): func
1921 return () =>
1922 # some comment
1923 x == 1
1924 # some comment
1925 ||
1926 x == 2
1927enddef
1928
1929def Test_expr7_new_lambda()
1930 var lines =<< trim END
1931 var La = () => 'result'
1932 assert_equal('result', La())
1933 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
1934
1935 # line continuation inside lambda with "cond ? expr : expr" works
1936 var ll = range(3)
1937 map(ll, (k, v) => v % 2 ? {
1938 ['111']: 111 } : {}
1939 )
1940 assert_equal([{}, {111: 111}, {}], ll)
1941
1942 ll = range(3)
1943 map(ll, (k, v) => v == 8 || v
1944 == 9
1945 || v % 2 ? 111 : 222
1946 )
1947 assert_equal([222, 111, 222], ll)
1948
1949 ll = range(3)
1950 map(ll, (k, v) => v != 8 && v
1951 != 9
1952 && v % 2 == 0 ? 111 : 222
1953 )
1954 assert_equal([111, 222, 111], ll)
1955
1956 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
1957 assert_equal([{key: 22}], dl)
1958
1959 dl = [{key: 12}, {['foo']: 34}]
1960 assert_equal([{key: 12}], filter(dl,
1961 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
1962
1963 assert_equal(false, NewLambdaWithComments()(0))
1964 assert_equal(true, NewLambdaWithComments()(1))
1965 assert_equal(true, NewLambdaWithComments()(2))
1966 assert_equal(false, NewLambdaWithComments()(3))
1967
1968 assert_equal(false, NewLambdaUsingArg(0)())
1969 assert_equal(true, NewLambdaUsingArg(1)())
1970
1971 var res = map([1, 2, 3], (i: number, v: number) => i + v)
1972 assert_equal([1, 3, 5], res)
1973
1974 # Lambda returning a dict
Bram Moolenaar9e68c322020-12-25 12:38:04 +01001975 var Lmb = () => ({key: 42})
Bram Moolenaar65c44152020-12-24 15:14:01 +01001976 assert_equal({key: 42}, Lmb())
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01001977
1978 var RefOne: func(number): string = (a: number): string => 'x'
1979 var RefTwo: func(number): any = (a: number): any => 'x'
1980
1981 var Fx = (a) => ({k1: 0,
1982 k2: 1})
1983 var Fy = (a) => [0,
1984 1]
Bram Moolenaar65c44152020-12-24 15:14:01 +01001985 END
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01001986 CheckDefAndScriptSuccess(lines)
Bram Moolenaar65c44152020-12-24 15:14:01 +01001987
Bram Moolenaare462f522020-12-27 14:43:30 +01001988 CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
1989 CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004:')
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001990 CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"],
1991 'E1004: White space required before and after ''=>'' at " =>a + 1"')
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01001992
Bram Moolenaar9e68c322020-12-25 12:38:04 +01001993 CheckDefFailure(["var Ref: func(number): number = (a: number): string => 'x'"], 'E1012:')
1994 CheckDefFailure(["var Ref: func(number): string = (a: number): string => 99"], 'E1012:')
1995
Bram Moolenaar65c44152020-12-24 15:14:01 +01001996 CheckDefFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
1997 # error is in first line of the lambda
1998 CheckDefFailure(["var L = (a) -> a + b"], 'E1001:', 1)
1999
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002000# TODO: ->(lambda)() doesn't work yet
Bram Moolenaar65c44152020-12-24 15:14:01 +01002001# assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
2002
2003# CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x')"],
2004# 'E1106: One argument too many')
2005# CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x', 'y')"],
2006# 'E1106: 2 arguments too many')
2007# CheckDefFailure(["echo 'asdf'->{a -> a}(x)"], 'E1001:', 1)
2008
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002009 CheckDefFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2010 CheckDefFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002011
Bram Moolenaar65c44152020-12-24 15:14:01 +01002012 CheckDefFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
2013enddef
2014
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002015def Test_expr7_lambda_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002016 var lines =<< trim END
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002017 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002018 var v = 10->((a) =>
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002019 a
2020 + 2
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002021 )()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002022 assert_equal(12, v)
2023 END
2024 CheckScriptSuccess(lines)
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002025
2026 # nested lambda with line breaks
2027 lines =<< trim END
2028 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002029 search('"', 'cW', 0, 0, () =>
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002030 synstack('.', col('.'))
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002031 ->map((_, v) => synIDattr(v, 'name'))->len())
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002032 END
2033 CheckScriptSuccess(lines)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002034enddef
2035
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002036def Test_epxr7_funcref()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002037 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002038 def RetNumber(): number
2039 return 123
2040 enddef
2041 var FuncRef = RetNumber
2042 assert_equal(123, FuncRef())
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002043 END
2044 CheckDefAndScriptSuccess(lines)
2045enddef
2046
Bram Moolenaar2bede172020-11-19 18:53:18 +01002047let g:test_space_dict = {'': 'empty', ' ': 'space'}
2048let g:test_hash_dict = #{one: 1, two: 2}
2049
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002050def Test_expr7_dict()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002051 # dictionary
Bram Moolenaar659bb222020-11-12 20:16:39 +01002052 var lines =<< trim END
2053 assert_equal(g:dict_empty, {})
2054 assert_equal(g:dict_empty, { })
Bram Moolenaare0de1712020-12-02 17:36:54 +01002055 assert_equal(g:dict_one, {['one']: 1})
Bram Moolenaar659bb222020-11-12 20:16:39 +01002056 var key = 'one'
2057 var val = 1
Bram Moolenaar2bede172020-11-19 18:53:18 +01002058 assert_equal(g:dict_one, {[key]: val})
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002059
Bram Moolenaar2bede172020-11-19 18:53:18 +01002060 var numbers: dict<number> = {a: 1, b: 2, c: 3}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002061 numbers = {a: 1}
2062 numbers = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002063
Bram Moolenaar2bede172020-11-19 18:53:18 +01002064 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002065 strings = {a: 'x'}
2066 strings = {}
2067
2068 var dash = {xx-x: 8}
2069 assert_equal({['xx-x']: 8}, dash)
2070
2071 var dnr = {8: 8}
2072 assert_equal({['8']: 8}, dnr)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002073
Bram Moolenaar2bede172020-11-19 18:53:18 +01002074 var mixed: dict<any> = {a: 'a', b: 42}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002075 mixed = {a: 'x'}
2076 mixed = {a: 234}
2077 mixed = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002078
Bram Moolenaare0de1712020-12-02 17:36:54 +01002079 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
2080 dictlist = {absent: ['hi'], present: []}
2081 dictlist = {absent: [], present: []}
Bram Moolenaar77b20972020-09-19 14:12:34 +02002082
Bram Moolenaare0de1712020-12-02 17:36:54 +01002083 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
2084 dictdict = {one: {}, two: {a: 'text'}}
2085 dictdict = {one: {}, two: {}}
Bram Moolenaarc7f7f6d2020-11-04 13:38:28 +01002086
Bram Moolenaare0de1712020-12-02 17:36:54 +01002087 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
Bram Moolenaar2bede172020-11-19 18:53:18 +01002088
2089 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
2090 assert_equal(g:test_hash_dict, {one: 1, two: 2})
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01002091
2092 assert_equal({['a a']: 1, ['b/c']: 2}, {'a a': 1, "b/c": 2})
Bram Moolenaar6b553772020-12-31 13:31:23 +01002093
2094 var d = {a: () => 3, b: () => 7}
2095 assert_equal(3, d.a())
2096 assert_equal(7, d.b())
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002097
2098 var cd = { # comment
2099 key: 'val' # comment
2100 }
Bram Moolenaar659bb222020-11-12 20:16:39 +01002101 END
2102 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002103
Bram Moolenaare0de1712020-12-02 17:36:54 +01002104 # legacy syntax doesn't work
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002105 CheckDefFailure(["var x = #{key: 8}"], 'E1097:', 3)
2106 CheckDefFailure(["var x = 'a' .. #{a: 1}"], 'E1097:', 3)
Bram Moolenaar17a836c2020-08-12 17:35:58 +02002107
Bram Moolenaare0de1712020-12-02 17:36:54 +01002108 CheckDefFailure(["var x = {a:8}"], 'E1069:', 1)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002109 CheckDefFailure(["var x = {a : 8}"], 'E1068:', 1)
2110 CheckDefFailure(["var x = {a :8}"], 'E1068:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002111 CheckDefFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
2112 CheckDefFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
2113
2114 CheckDefFailure(["var x = {xxx}"], 'E720:', 1)
2115 CheckDefFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
2116 CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
2117 CheckDefFailure(["var x = {['a']: xxx}"], 'E1001:', 1)
2118 CheckDefFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002119 CheckDefExecFailure(["var x = g:anint.member"], 'E715:', 1)
2120 CheckDefExecFailure(["var x = g:dict_empty.member"], 'E716:', 1)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002121
Bram Moolenaare0de1712020-12-02 17:36:54 +01002122 CheckDefExecFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
2123 CheckDefExecFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
2124 CheckDefExecFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
2125 CheckDefExecFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002126
2127 CheckDefFailure(['var x = ({'], 'E723:', 2)
Bram Moolenaar7bb4e742020-12-09 12:41:50 +01002128 CheckDefExecFailure(['{}[getftype("file")]'], 'E716: Key not present in Dictionary: ""', 1)
Bram Moolenaar9987fb02020-12-15 21:41:56 +01002129
2130 # no automatic conversion from number to string
2131 lines =<< trim END
2132 var n = 123
2133 var d = {[n]: 1}
2134 END
2135 CheckDefFailure(lines, 'E1012:', 2)
2136 CheckScriptFailure(['vim9script'] + lines, 'E928:', 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002137enddef
2138
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002139def Test_expr7_dict_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002140 var lines =<< trim END
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002141 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002142 var d = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002143 ['one']:
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002144 1,
Bram Moolenaare0de1712020-12-02 17:36:54 +01002145 ['two']: 2,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002146 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002147 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar93be1642020-10-11 21:34:41 +02002148
2149 d = { # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002150 ['one']:
Bram Moolenaar93be1642020-10-11 21:34:41 +02002151 # comment
2152
2153 1,
2154 # comment
2155 # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002156 ['two']: 2,
Bram Moolenaar93be1642020-10-11 21:34:41 +02002157 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002158 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002159
2160 var dd = {k: 123->len()}
2161 assert_equal(3, dd.k)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002162 END
2163 CheckScriptSuccess(lines)
2164
2165 lines =<< trim END
2166 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002167 var d = { ["one"]: "one", ["two"]: "two", }
2168 assert_equal({one: 'one', two: 'two'}, d)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002169 END
2170 CheckScriptSuccess(lines)
2171
2172 lines =<< trim END
2173 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002174 var d = {one: 1,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002175 two: 2,
2176 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002177 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002178 END
2179 CheckScriptSuccess(lines)
2180
2181 lines =<< trim END
2182 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002183 var d = {one:1, two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002184 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002185 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002186
2187 lines =<< trim END
2188 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002189 var d = {one: 1,two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002190 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002191 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02002192
2193 lines =<< trim END
2194 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002195 var d = {one : 1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002196 END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002197 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02002198
2199 lines =<< trim END
2200 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002201 var d = {one:1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002202 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002203 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002204
2205 lines =<< trim END
2206 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002207 var d = {one: 1 , two: 2}
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002208 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002209 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002210
2211 lines =<< trim END
2212 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002213 var l: dict<number> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002214 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002215 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002216 lines =<< trim END
2217 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002218 var l: dict<number> = {a: 'x', b: 234}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002219 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002220 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002221 lines =<< trim END
2222 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002223 var l: dict<string> = {a: 'x', b: 234}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002224 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002225 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002226 lines =<< trim END
2227 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002228 var l: dict<string> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002229 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002230 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002231
2232 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002233 vim9script
2234 var d = {['a']: 234, ['b': 'x'}
2235 END
2236 CheckScriptFailure(lines, 'E1139:', 2)
2237 lines =<< trim END
2238 vim9script
2239 def Func()
2240 var d = {['a']: 234, ['b': 'x'}
2241 enddef
2242 defcompile
2243 END
2244 CheckScriptFailure(lines, 'E1139:', 1)
2245 lines =<< trim END
2246 vim9script
2247 var d = {'a':
2248 END
2249 CheckScriptFailure(lines, 'E15:', 2)
2250 lines =<< trim END
2251 vim9script
2252 def Func()
2253 var d = {'a':
2254 enddef
2255 defcompile
2256 END
2257 CheckScriptFailure(lines, 'E723:', 1)
2258
2259 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002260 vim9script
2261 def Failing()
2262 job_stop()
2263 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002264 var dict = {name: Failing}
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002265 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002266 if has('channel')
2267 CheckScriptFailure(lines, 'E119:', 1)
2268 else
2269 CheckScriptFailure(lines, 'E117:', 1)
2270 endif
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002271enddef
2272
Bram Moolenaar50788ef2020-07-05 16:51:26 +02002273let g:oneString = 'one'
2274
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002275def Test_expr_member()
2276 assert_equal(1, g:dict_one.one)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002277 var d: dict<number> = g:dict_one
Bram Moolenaar4dac32c2020-05-15 21:44:19 +02002278 assert_equal(1, d['one'])
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002279 assert_equal(1, d[
2280 'one'
2281 ])
2282 assert_equal(1, d
2283 .one)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002284 d = {1: 1, _: 2}
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002285 assert_equal(1, d
2286 .1)
2287 assert_equal(2, d
2288 ._)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002289
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002290 # getting the one member should clear the dict after getting the item
Bram Moolenaare0de1712020-12-02 17:36:54 +01002291 assert_equal('one', {one: 'one'}.one)
2292 assert_equal('one', {one: 'one'}[g:oneString])
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002293
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002294 CheckDefFailure(["var x = g:dict_one.#$!"], 'E1002:', 1)
2295 CheckDefExecFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2296 CheckDefExecFailure(["var d: dict<number>", "d = g:list_empty"], 'E1012: Type mismatch; expected dict<number> but got list<unknown>', 2)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002297enddef
2298
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002299def Test_expr7_any_index_slice()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002300 var lines =<< trim END
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002301 # getting the one member should clear the list only after getting the item
2302 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
2303
2304 # string is permissive, index out of range accepted
2305 g:teststring = 'abcdef'
2306 assert_equal('b', g:teststring[1])
2307 assert_equal('', g:teststring[-1])
2308 assert_equal('', g:teststring[99])
2309
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002310 assert_equal('b', g:teststring[1 : 1])
2311 assert_equal('bcdef', g:teststring[1 :])
2312 assert_equal('abcd', g:teststring[: 3])
2313 assert_equal('cdef', g:teststring[-4 :])
2314 assert_equal('abcdef', g:teststring[-9 :])
2315 assert_equal('abcd', g:teststring[: -3])
2316 assert_equal('', g:teststring[: -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002317
2318 # blob index cannot be out of range
2319 g:testblob = 0z01ab
2320 assert_equal(0x01, g:testblob[0])
2321 assert_equal(0xab, g:testblob[1])
2322 assert_equal(0xab, g:testblob[-1])
2323 assert_equal(0x01, g:testblob[-2])
2324
2325 # blob slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002326 assert_equal(0z01ab, g:testblob[0 : 1])
2327 assert_equal(0z01, g:testblob[0 : 0])
2328 assert_equal(0z01, g:testblob[-2 : -2])
2329 assert_equal(0zab, g:testblob[1 : 1])
2330 assert_equal(0zab, g:testblob[-1 : -1])
2331 assert_equal(0z, g:testblob[2 : 2])
2332 assert_equal(0z, g:testblob[0 : -3])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002333
2334 # list index cannot be out of range
2335 g:testlist = [0, 1, 2, 3]
2336 assert_equal(0, g:testlist[0])
2337 assert_equal(1, g:testlist[1])
2338 assert_equal(3, g:testlist[3])
2339 assert_equal(3, g:testlist[-1])
2340 assert_equal(0, g:testlist[-4])
2341 assert_equal(1, g:testlist[g:theone])
2342
2343 # list slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002344 assert_equal([0], g:testlist[0 : 0])
2345 assert_equal([3], g:testlist[3 : 3])
2346 assert_equal([0, 1], g:testlist[0 : 1])
2347 assert_equal([0, 1, 2, 3], g:testlist[0 : 3])
2348 assert_equal([0, 1, 2, 3], g:testlist[0 : 9])
2349 assert_equal([], g:testlist[-1 : 1])
2350 assert_equal([1], g:testlist[-3 : 1])
2351 assert_equal([0, 1], g:testlist[-4 : 1])
2352 assert_equal([0, 1], g:testlist[-9 : 1])
2353 assert_equal([1, 2, 3], g:testlist[1 : -1])
2354 assert_equal([1], g:testlist[1 : -3])
2355 assert_equal([], g:testlist[1 : -4])
2356 assert_equal([], g:testlist[1 : -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002357
Bram Moolenaare0de1712020-12-02 17:36:54 +01002358 g:testdict = {a: 1, b: 2}
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002359 assert_equal(1, g:testdict['a'])
2360 assert_equal(2, g:testdict['b'])
2361 END
2362
2363 CheckDefSuccess(lines)
2364 CheckScriptSuccess(['vim9script'] + lines)
2365
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002366 CheckDefExecFailure(['echo g:testblob[2]'], 'E979:', 1)
2367 CheckScriptFailure(['vim9script', 'echo g:testblob[2]'], 'E979:', 2)
2368 CheckDefExecFailure(['echo g:testblob[-3]'], 'E979:', 1)
2369 CheckScriptFailure(['vim9script', 'echo g:testblob[-3]'], 'E979:', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002370
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002371 CheckDefExecFailure(['echo g:testlist[4]'], 'E684:', 1)
2372 CheckScriptFailure(['vim9script', 'echo g:testlist[4]'], 'E684:', 2)
2373 CheckDefExecFailure(['echo g:testlist[-5]'], 'E684:', 1)
2374 CheckScriptFailure(['vim9script', 'echo g:testlist[-5]'], 'E684:', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002375
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002376 CheckDefExecFailure(['echo g:testdict["a" : "b"]'], 'E719:', 1)
2377 CheckScriptFailure(['vim9script', 'echo g:testdict["a" : "b"]'], 'E719:', 2)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002378 CheckDefExecFailure(['echo g:testdict[1]'], 'E716:', 1)
2379 CheckScriptFailure(['vim9script', 'echo g:testdict[1]'], 'E716:', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002380
2381 unlet g:teststring
2382 unlet g:testblob
2383 unlet g:testlist
Bram Moolenaar435d8972020-07-05 16:42:13 +02002384enddef
2385
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002386def Test_expr_member_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002387 var lines =<< trim END
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002388 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002389 var d = {one:
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002390 'one',
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002391 two: 'two',
2392 1: 1,
2393 _: 2}
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002394 assert_equal('one', d.one)
2395 assert_equal('one', d
2396 .one)
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002397 assert_equal(1, d
2398 .1)
2399 assert_equal(2, d
2400 ._)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002401 assert_equal('one', d[
2402 'one'
2403 ])
2404 END
2405 CheckScriptSuccess(lines)
2406
2407 lines =<< trim END
2408 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002409 var l = [1,
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002410 2,
2411 3, 4
2412 ]
2413 assert_equal(2, l[
2414 1
2415 ])
2416 assert_equal([2, 3], l[1 : 2])
2417 assert_equal([1, 2, 3], l[
2418 :
2419 2
2420 ])
2421 assert_equal([3, 4], l[
2422 2
2423 :
2424 ])
2425 END
2426 CheckScriptSuccess(lines)
2427enddef
2428
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002429def Test_expr7_option()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002430 # option
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002431 set ts=11
2432 assert_equal(11, &ts)
Bram Moolenaar401d9ff2020-02-19 18:14:44 +01002433 &ts = 9
2434 assert_equal(9, &ts)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002435 set ts=8
2436 set grepprg=some\ text
2437 assert_equal('some text', &grepprg)
Bram Moolenaar97a2af32020-01-28 22:52:48 +01002438 &grepprg = test_null_string()
2439 assert_equal('', &grepprg)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002440 set grepprg&
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01002441
2442 # check matching type
2443 var bval: bool = &tgc
2444 var nval: number = &ts
2445 var sval: string = &path
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002446enddef
2447
2448def Test_expr7_environment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002449 # environment variable
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002450 assert_equal('testvar', $TESTVAR)
2451 assert_equal('', $ASDF_ASD_XXX)
Bram Moolenaarc58164c2020-03-29 18:40:30 +02002452
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002453 CheckDefFailure(["var x = $$$"], 'E1002:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002454enddef
2455
2456def Test_expr7_register()
Bram Moolenaar401d9ff2020-02-19 18:14:44 +01002457 @a = 'register a'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002458 assert_equal('register a', @a)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002459
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002460 var fname = expand('%')
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002461 assert_equal(fname, @%)
2462
2463 feedkeys(":echo 'some'\<CR>", "xt")
2464 assert_equal("echo 'some'", @:)
2465
2466 normal axyz
2467 assert_equal("xyz", @.)
Bram Moolenaard2c61702020-09-06 15:58:36 +02002468 CheckDefFailure(["@. = 'yes'"], 'E354:', 1)
Bram Moolenaar65821722020-08-02 18:58:54 +02002469
2470 @/ = 'slash'
2471 assert_equal('slash', @/)
2472
2473 @= = 'equal'
2474 assert_equal('equal', @=)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002475enddef
2476
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002477def Test_expr7_namespace()
2478 g:some_var = 'some'
2479 assert_equal('some', get(g:, 'some_var'))
2480 assert_equal('some', get(g:, 'some_var', 'xxx'))
2481 assert_equal('xxx', get(g:, 'no_var', 'xxx'))
2482 unlet g:some_var
2483
2484 b:some_var = 'some'
2485 assert_equal('some', get(b:, 'some_var'))
2486 assert_equal('some', get(b:, 'some_var', 'xxx'))
2487 assert_equal('xxx', get(b:, 'no_var', 'xxx'))
2488 unlet b:some_var
2489
2490 w:some_var = 'some'
2491 assert_equal('some', get(w:, 'some_var'))
2492 assert_equal('some', get(w:, 'some_var', 'xxx'))
2493 assert_equal('xxx', get(w:, 'no_var', 'xxx'))
2494 unlet w:some_var
2495
2496 t:some_var = 'some'
2497 assert_equal('some', get(t:, 'some_var'))
2498 assert_equal('some', get(t:, 'some_var', 'xxx'))
2499 assert_equal('xxx', get(t:, 'no_var', 'xxx'))
2500 unlet t:some_var
2501enddef
2502
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002503def Test_expr7_parens()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002504 # (expr)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002505 assert_equal(4, (6 * 4) / 6)
2506 assert_equal(0, 6 * ( 4 / 6 ))
2507
2508 assert_equal(6, +6)
2509 assert_equal(-6, -6)
2510 assert_equal(6, --6)
2511 assert_equal(6, -+-6)
2512 assert_equal(-6, ---6)
Bram Moolenaar0b1cd522020-06-27 13:11:50 +02002513 assert_equal(false, !-3)
2514 assert_equal(true, !+-+0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002515enddef
2516
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002517def Test_expr7_parens_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002518 var lines =<< trim END
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002519 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002520 var s = (
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002521 'one'
2522 ..
2523 'two'
2524 )
2525 assert_equal('onetwo', s)
2526 END
2527 CheckScriptSuccess(lines)
2528enddef
2529
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002530def Test_expr7_negate_add()
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002531 assert_equal(-99, -99)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002532 assert_equal(-99, - 99)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002533 assert_equal(99, --99)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002534 assert_equal(99, -- 99)
2535 assert_equal(99, - - 99)
2536 assert_equal(99, +99)
2537 assert_equal(-99, -+99)
2538 assert_equal(-99, -+ 99)
2539 assert_equal(-99, - +99)
2540 assert_equal(-99, - + 99)
2541 assert_equal(-99, +-99)
2542 assert_equal(-99, + -99)
2543 assert_equal(-99, + - 99)
2544
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002545 var nr = 88
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002546 assert_equal(-88, -nr)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002547 assert_equal(-88, - nr)
2548 assert_equal(-88, - +nr)
2549 assert_equal(88, -- nr)
2550 assert_equal(88, + nr)
2551 assert_equal(88, --+ nr)
2552 assert_equal(88, - - nr)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002553enddef
2554
Bram Moolenaar6e949782020-04-13 17:21:00 +02002555def Echo(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002556 return arg
2557enddef
2558
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02002559def s:Echo4Arg(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002560 return arg
2561enddef
2562
2563def Test_expr7_call()
Bram Moolenaar659bb222020-11-12 20:16:39 +01002564 var lines =<< trim END
2565 assert_equal('yes', 'yes'->Echo())
2566 assert_equal(true, !range(5)->empty())
2567 assert_equal([0, 1, 2], --3->range())
2568 END
2569 CheckDefAndScriptSuccess(lines)
2570
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002571 assert_equal('yes', 'yes'
Bram Moolenaar659bb222020-11-12 20:16:39 +01002572 ->s:Echo4Arg())
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002573
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002574 CheckDefFailure(["var x = 'yes'->Echo"], 'E107:', 1)
Bram Moolenaard2c61702020-09-06 15:58:36 +02002575 CheckScriptFailure([
2576 "vim9script",
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002577 "var x = substitute ('x', 'x', 'x', 'x')"
Bram Moolenaard2c61702020-09-06 15:58:36 +02002578 ], 'E121:', 2)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002579 CheckDefFailure(["var Ref = function('len' [1, 2])"], 'E1123:', 1)
Bram Moolenaara1773442020-08-12 15:21:22 +02002580
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002581 var auto_lines =<< trim END
Bram Moolenaara1773442020-08-12 15:21:22 +02002582 def g:some#func(): string
2583 return 'found'
2584 enddef
2585 END
2586 mkdir('Xruntime/autoload', 'p')
2587 writefile(auto_lines, 'Xruntime/autoload/some.vim')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002588 var save_rtp = &rtp
Bram Moolenaara1773442020-08-12 15:21:22 +02002589 &rtp = getcwd() .. '/Xruntime,' .. &rtp
2590 assert_equal('found', g:some#func())
2591 assert_equal('found', some#func())
2592
2593 &rtp = save_rtp
2594 delete('Xruntime', 'rf')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002595enddef
2596
Bram Moolenaar7e368202020-12-25 21:56:57 +01002597def Test_expr7_method_call()
2598 new
2599 setline(1, ['first', 'last'])
2600 'second'->append(1)
2601 "third"->append(2)
2602 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
2603 bwipe!
2604
2605 var bufnr = bufnr()
2606 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
2607 loclist->setloclist(0)
2608 assert_equal([{bufnr: bufnr,
2609 lnum: 42,
2610 col: 17,
2611 text: 'wrong',
2612 pattern: '',
2613 valid: 1,
2614 vcol: 0,
2615 nr: 0,
2616 type: '',
2617 module: ''}
2618 ], getloclist(0))
2619
2620 var result: bool = get({n: 0}, 'n', 0)
2621 assert_equal(false, result)
2622
2623 assert_equal('+string+', 'string'->((s) => '+' .. s .. '+')())
2624 assert_equal('-text-', 'text'->((s, c) => c .. s .. c)('-'))
2625
2626 var Join = (l) => join(l, 'x')
2627 assert_equal('axb', ['a', 'b']->(Join)())
2628enddef
2629
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002630
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002631def Test_expr7_not()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002632 var lines =<< trim END
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002633 assert_equal(true, !'')
2634 assert_equal(true, ![])
2635 assert_equal(false, !'asdf')
2636 assert_equal(false, ![2])
2637 assert_equal(true, !!'asdf')
2638 assert_equal(true, !![2])
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002639
Bram Moolenaar27491cd2020-10-15 21:54:56 +02002640 assert_equal(true, ! false)
2641 assert_equal(true, !! true)
2642 assert_equal(true, ! ! true)
2643 assert_equal(true, !!! false)
2644 assert_equal(true, ! ! ! false)
2645
2646 g:true = true
2647 g:false = false
2648 assert_equal(true, ! g:false)
2649 assert_equal(true, !! g:true)
2650 assert_equal(true, ! ! g:true)
2651 assert_equal(true, !!! g:false)
2652 assert_equal(true, ! ! ! g:false)
2653 unlet g:true
2654 unlet g:false
2655
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002656 assert_equal(true, !test_null_partial())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002657 assert_equal(false, !() => 'yes')
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002658
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002659 assert_equal(true, !test_null_dict())
2660 assert_equal(true, !{})
Bram Moolenaare0de1712020-12-02 17:36:54 +01002661 assert_equal(false, !{yes: 'no'})
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002662
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002663 if has('channel')
2664 assert_equal(true, !test_null_job())
2665 assert_equal(true, !test_null_channel())
2666 endif
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002667
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002668 assert_equal(true, !test_null_blob())
2669 assert_equal(true, !0z)
2670 assert_equal(false, !0z01)
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002671
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002672 assert_equal(true, !test_void())
2673 assert_equal(true, !test_unknown())
Bram Moolenaar59eccb92020-08-10 23:09:37 +02002674
2675 assert_equal(false, ![1, 2, 3]->reverse())
2676 assert_equal(true, ![]->reverse())
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002677 END
Bram Moolenaar27491cd2020-10-15 21:54:56 +02002678 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002679enddef
2680
2681func Test_expr7_fails()
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002682 call CheckDefFailure(["var x = (12"], "E1097:", 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002683
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002684 call CheckDefFailure(["var x = -'xx'"], "E1030:", 1)
2685 call CheckDefFailure(["var x = +'xx'"], "E1030:", 1)
2686 call CheckDefFailure(["var x = -0z12"], "E974:", 1)
2687 call CheckDefExecFailure(["var x = -[8]"], "E39:", 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002688 call CheckDefExecFailure(["var x = -{a: 1}"], "E39:", 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002689
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002690 call CheckDefFailure(["var x = @"], "E1002:", 1)
2691 call CheckDefFailure(["var x = @<"], "E354:", 1)
Bram Moolenaar58ceca52020-01-28 22:46:22 +01002692
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002693 call CheckDefFailure(["var x = [1, 2"], "E697:", 2)
2694 call CheckDefFailure(["var x = [notfound]"], "E1001:", 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01002695
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002696 call CheckDefFailure(["var X = () => 123)"], "E488:", 1)
2697 call CheckDefFailure(["var x = 123->((x) => x + 5)"], "E107:", 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01002698
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002699 call CheckDefFailure(["var x = &notexist"], 'E113:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002700 call CheckDefFailure(["&grepprg = [343]"], 'E1012:', 1)
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002701
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002702 call CheckDefExecFailure(["echo s:doesnt_exist"], 'E121:', 1)
2703 call CheckDefExecFailure(["echo g:doesnt_exist"], 'E121:', 1)
Bram Moolenaar09f28f42020-02-20 23:08:34 +01002704
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002705 call CheckDefFailure(["echo a:somevar"], 'E1075:', 1)
2706 call CheckDefFailure(["echo l:somevar"], 'E1075:', 1)
2707 call CheckDefFailure(["echo x:somevar"], 'E1075:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002708
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002709 call CheckDefExecFailure(["var x = +g:astring"], 'E1030:', 1)
2710 call CheckDefExecFailure(["var x = +g:ablob"], 'E974:', 1)
2711 call CheckDefExecFailure(["var x = +g:alist"], 'E745:', 1)
2712 call CheckDefExecFailure(["var x = +g:adict"], 'E728:', 1)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01002713
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002714 call CheckDefFailure(["var x = ''", "var y = x.memb"], 'E715:', 2)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002715
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002716 call CheckDefFailure(["'yes'->", "Echo()"], 'E488: Trailing characters: ->', 1)
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002717
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002718 call CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002719 call CheckDefExecFailure(["{a: 1->len()"], 'E723:', 2)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002720 call CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002721endfunc
2722
2723let g:Funcrefs = [function('add')]
2724
2725func CallMe(arg)
2726 return a:arg
2727endfunc
2728
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002729func CallMe2(one, two)
2730 return a:one .. a:two
2731endfunc
2732
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002733def Test_expr7_trailing()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002734 # user function call
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002735 assert_equal(123, g:CallMe(123))
2736 assert_equal(123, g:CallMe( 123))
2737 assert_equal(123, g:CallMe(123 ))
2738 assert_equal('yesno', g:CallMe2('yes', 'no'))
2739 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
2740 assert_equal('nothing', g:CallMe('nothing'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002741
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002742 # partial call
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002743 var Part = function('g:CallMe')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002744 assert_equal('yes', Part('yes'))
2745
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002746 # funcref call, using list index
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002747 var l = []
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002748 g:Funcrefs[0](l, 2)
2749 assert_equal([2], l)
2750
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002751 # method call
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002752 l = [2, 5, 6]
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002753 l->map((k, v) => k + v)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002754 assert_equal([2, 6, 8], l)
2755
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002756 # lambda method call
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002757 l = [2, 5]
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002758 l->((l) => add(l, 8))()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002759 assert_equal([2, 5, 8], l)
2760
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002761 # dict member
Bram Moolenaare0de1712020-12-02 17:36:54 +01002762 var d = {key: 123}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002763 assert_equal(123, d.key)
2764enddef
2765
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002766def Test_expr7_string_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002767 var lines =<< trim END
2768 var text = 'abcdef'
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002769 assert_equal('', text[-1])
2770 assert_equal('a', text[0])
2771 assert_equal('e', text[4])
2772 assert_equal('f', text[5])
2773 assert_equal('', text[6])
2774
2775 text = 'ábçdëf'
2776 assert_equal('', text[-999])
2777 assert_equal('', text[-1])
2778 assert_equal('á', text[0])
2779 assert_equal('b', text[1])
2780 assert_equal('ç', text[2])
2781 assert_equal('d', text[3])
2782 assert_equal('ë', text[4])
2783 assert_equal('f', text[5])
2784 assert_equal('', text[6])
2785 assert_equal('', text[999])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002786
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002787 assert_equal('ábçdëf', text[0 : -1])
2788 assert_equal('ábçdëf', text[0 : -1])
2789 assert_equal('ábçdëf', text[0 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002790 assert_equal('ábçdëf', text[0 : -1])
2791 assert_equal('ábçdëf', text[0
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002792 : -1])
2793 assert_equal('ábçdëf', text[0 :
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002794 -1])
2795 assert_equal('ábçdëf', text[0 : -1
2796 ])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002797 assert_equal('bçdëf', text[1 : -1])
2798 assert_equal('çdëf', text[2 : -1])
2799 assert_equal('dëf', text[3 : -1])
2800 assert_equal('ëf', text[4 : -1])
2801 assert_equal('f', text[5 : -1])
2802 assert_equal('', text[6 : -1])
2803 assert_equal('', text[999 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002804
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002805 assert_equal('ábçd', text[: 3])
2806 assert_equal('bçdëf', text[1 :])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002807 assert_equal('ábçdëf', text[:])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002808 END
2809 CheckDefSuccess(lines)
2810 CheckScriptSuccess(['vim9script'] + lines)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002811
2812 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002813 var d = 'asdf'[1 :
Bram Moolenaar918a4242020-12-06 14:37:08 +01002814 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002815 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002816 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002817 var d = 'asdf'[1 : xxx]
Bram Moolenaar918a4242020-12-06 14:37:08 +01002818 END
2819 CheckDefFailure(lines, 'E1001:', 1)
2820 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002821 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01002822 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002823 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002824 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002825 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01002826 echo d
2827 END
2828 CheckDefFailure(lines, 'E111:', 2)
2829 lines =<< trim END
2830 var d = 'asdf'['1']
2831 echo d
2832 END
2833 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
2834 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002835 var d = 'asdf'['1' : 2]
Bram Moolenaar918a4242020-12-06 14:37:08 +01002836 echo d
2837 END
2838 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
2839 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002840 var d = 'asdf'[1 : '2']
Bram Moolenaar918a4242020-12-06 14:37:08 +01002841 echo d
2842 END
2843 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02002844enddef
2845
Bram Moolenaared591872020-08-15 22:14:53 +02002846def Test_expr7_list_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002847 var lines =<< trim END
2848 var list = [0, 1, 2, 3, 4]
Bram Moolenaared591872020-08-15 22:14:53 +02002849 assert_equal(0, list[0])
2850 assert_equal(4, list[4])
2851 assert_equal(4, list[-1])
2852 assert_equal(0, list[-5])
2853
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002854 assert_equal([0, 1, 2, 3, 4], list[0 : 4])
Bram Moolenaared591872020-08-15 22:14:53 +02002855 assert_equal([0, 1, 2, 3, 4], list[:])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002856 assert_equal([1, 2, 3, 4], list[1 :])
2857 assert_equal([2, 3, 4], list[2 : -1])
2858 assert_equal([4], list[4 : -1])
2859 assert_equal([], list[5 : -1])
2860 assert_equal([], list[999 : -1])
2861 assert_equal([1, 2, 3, 4], list[g:theone : g:thefour])
Bram Moolenaared591872020-08-15 22:14:53 +02002862
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002863 assert_equal([0, 1, 2, 3], list[0 : 3])
2864 assert_equal([0], list[0 : 0])
2865 assert_equal([0, 1, 2, 3, 4], list[0 : -1])
2866 assert_equal([0, 1, 2], list[0 : -3])
2867 assert_equal([0], list[0 : -5])
2868 assert_equal([], list[0 : -6])
2869 assert_equal([], list[0 : -99])
Bram Moolenaared591872020-08-15 22:14:53 +02002870 END
2871 CheckDefSuccess(lines)
2872 CheckScriptSuccess(['vim9script'] + lines)
Bram Moolenaar56acb092020-08-16 14:48:19 +02002873
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002874 lines = ['var l = [0, 1, 2]', 'echo l[g:astring : g:theone]']
Bram Moolenaar5e654232020-09-16 15:22:00 +02002875 CheckDefExecFailure(lines, 'E1012:')
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002876 CheckScriptFailure(['vim9script'] + lines, 'E1030:', 3)
Bram Moolenaared591872020-08-15 22:14:53 +02002877enddef
2878
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02002879def Test_expr7_dict_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002880 var lines =<< trim END
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02002881 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002882 var l = [{lnum: 2}, {lnum: 1}]
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002883 var res = l[0].lnum > l[1].lnum
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02002884 assert_true(res)
2885 END
2886 CheckScriptSuccess(lines)
2887enddef
2888
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002889def Test_expr7_subscript_linebreak()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002890 var range = range(
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002891 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002892 var l = range
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002893 ->map('string(v:key)')
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002894 assert_equal(['0', '1', '2'], l)
2895
Bram Moolenaar23c55272020-06-21 16:58:13 +02002896 l = range
2897 ->map('string(v:key)')
2898 assert_equal(['0', '1', '2'], l)
2899
2900 l = range # comment
2901 ->map('string(v:key)')
2902 assert_equal(['0', '1', '2'], l)
2903
2904 l = range
2905
2906 ->map('string(v:key)')
2907 assert_equal(['0', '1', '2'], l)
2908
2909 l = range
2910 # comment
2911 ->map('string(v:key)')
2912 assert_equal(['0', '1', '2'], l)
2913
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002914 assert_equal('1', l[
2915 1])
2916
Bram Moolenaare0de1712020-12-02 17:36:54 +01002917 var d = {one: 33}
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02002918 assert_equal(33, d.
2919 one)
2920enddef
2921
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002922func Test_expr7_trailing_fails()
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002923 call CheckDefFailure(['var l = [2]', 'l->((l) => add(l, 8))'], 'E107:', 2)
2924 call CheckDefFailure(['var l = [2]', 'l->((l) => add(l, 8)) ()'], 'E274:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002925endfunc
2926
2927func Test_expr_fails()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002928 call CheckDefFailure(["var x = '1'is2"], 'E488:', 1)
2929 call CheckDefFailure(["var x = '1'isnot2"], 'E488:', 1)
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002930
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002931 call CheckDefFailure(["CallMe ('yes')"], 'E476:', 1)
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02002932 call CheckScriptFailure(["CallMe ('yes')"], 'E492:', 1)
Bram Moolenaarba7c0d72020-09-09 18:54:42 +02002933 call CheckDefAndScriptFailure(["CallMe2('yes','no')"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002934 call CheckDefFailure(["CallMe2('yes' , 'no')"], 'E1068:', 1)
Bram Moolenaar0c2ca582020-02-25 22:58:29 +01002935
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002936 call CheckDefFailure(["v:nosuch += 3"], 'E1001:', 1)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002937 call CheckDefFailure(["var v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:', 1)
2938 call CheckDefFailure(["var asdf = v:nosuch"], 'E1001:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002939
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002940 call CheckDefFailure(["echo len('asdf'"], 'E110:', 2)
2941 call CheckDefFailure(["echo Func0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], 'E1011:', 1)
2942 call CheckDefFailure(["echo doesnotexist()"], 'E117:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002943endfunc
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02002944
2945" vim: shiftwidth=2 sts=2 expandtab