blob: c181b203f75925135798e1f267a9ea64fa37887f [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 Moolenaarcff40ff2021-01-09 16:21:37 +0100600
601 CheckDefExecFailure(['var x: any = "a"', 'echo x == true'], 'E1072: Cannot compare string with bool', 2)
602 CheckDefExecFailure(["var x: any = true", 'echo x == ""'], 'E1072: Cannot compare bool with string', 2)
603 CheckDefExecFailure(["var x: any = 99", 'echo x == true'], 'E1138', 2)
604 CheckDefExecFailure(["var x: any = 'a'", 'echo x == 99'], 'E1030:', 2)
605
606 for op in ['>', '>=', '<', '<=', '=~', '!~']
607 CheckDefExecFailure([
608 "var a: any = 'a'",
609 'var b: any = true',
610 'echo a ' .. op .. ' b'], 'E1072:', 3)
611 endfor
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100612enddef
613
614" test != comperator
615def Test_expr4_notequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100616 var lines =<< trim END
617 var trueVar = true
618 var falseVar = false
619 assert_equal(false, true != true)
620 assert_equal(true, true !=
621 false)
622 assert_equal(false, true
623 != trueVar)
624 assert_equal(true, true != falseVar)
625 assert_equal(false, true != g:atrue)
626 assert_equal(true, g:atrue != false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100627
Bram Moolenaar659bb222020-11-12 20:16:39 +0100628 assert_equal(false, v:none != v:none)
629 assert_equal(true, v:none != v:null)
630 assert_equal(false, g:anone != v:none)
631 assert_equal(true, v:none != g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100632
Bram Moolenaar659bb222020-11-12 20:16:39 +0100633 var nr55 = 55
634 var nr0 = 55
635 assert_equal(true, 2 != 0)
636 assert_equal(true, 2 != nr0)
637 assert_equal(false, 55 != 55)
638 assert_equal(false, 55 != nr55)
639 assert_equal(false, g:anint != 10)
640 assert_equal(true, 61 != g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100641
Bram Moolenaar659bb222020-11-12 20:16:39 +0100642 if has('float')
643 var ff = 0.3
644 assert_equal(false, 0.3 != ff)
645 assert_equal(true, 0.4 != ff)
646 assert_equal(false, 0.1 != g:afloat)
647 assert_equal(true, g:afloat != 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100648
Bram Moolenaar659bb222020-11-12 20:16:39 +0100649 ff = 3.0
650 assert_equal(false, ff != 3)
651 assert_equal(false, 3 != ff)
652 ff = 3.1
653 assert_equal(true, ff != 3)
654 assert_equal(true, 3 != ff)
655 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100656
Bram Moolenaar659bb222020-11-12 20:16:39 +0100657 assert_equal(false, 'abc' != 'abc')
658 assert_equal(true, 'xyz' != 'abc')
659 assert_equal(false, g:astring != 'asdf')
660 assert_equal(true, 'xyz' != g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100661
Bram Moolenaar659bb222020-11-12 20:16:39 +0100662 assert_equal(true, 'abc' != 'ABC')
663 set ignorecase
664 assert_equal(true, 'abc' != 'ABC')
665 assert_equal(true, 'abc' !=# 'ABC')
666 assert_equal(false, 'abc' !=? 'ABC')
667 set noignorecase
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100668
Bram Moolenaar659bb222020-11-12 20:16:39 +0100669 var bb = 0z3f
670 assert_equal(false, 0z3f != bb)
671 assert_equal(true, bb != 0z4f)
672 assert_equal(false, g:ablob != 0z01ab)
673 assert_equal(true, 0z3f != g:ablob)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100674
Bram Moolenaar659bb222020-11-12 20:16:39 +0100675 assert_equal(false, [1, 2, 3] != [1, 2, 3])
676 assert_equal(true, [1, 2, 3] != [2, 3, 1])
677 assert_equal(false, [2, 3, 4] != g:alist)
678 assert_equal(true, g:alist != [2, 3, 1])
679 assert_equal(true, [1, 2, 3] != [])
680 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100681
Bram Moolenaare0de1712020-12-02 17:36:54 +0100682 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
683 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
684 assert_equal(true, {one: 1, two: 2} != {two: 2})
685 assert_equal(true, {one: 1, two: 2} != {})
686 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
687 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100688
Bram Moolenaar659bb222020-11-12 20:16:39 +0100689 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
690 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100691
Bram Moolenaar659bb222020-11-12 20:16:39 +0100692 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
693 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
694 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
695 END
696 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100697enddef
698
699" test > comperator
700def Test_expr4_greater()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100701 var lines =<< trim END
702 assert_true(2 > 0)
703 assert_true(2 >
704 1)
705 assert_false(2 > 2)
706 assert_false(2 > 3)
707 var nr2 = 2
708 assert_true(nr2 > 0)
709 assert_true(nr2 >
710 1)
711 assert_false(nr2 > 2)
712 assert_false(nr2
713 > 3)
714 if has('float')
715 var ff = 2.0
716 assert_true(ff > 0.0)
717 assert_true(ff > 1.0)
718 assert_false(ff > 2.0)
719 assert_false(ff > 3.0)
720 endif
721 END
722 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100723enddef
724
725" test >= comperator
726def Test_expr4_greaterequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100727 var lines =<< trim END
728 assert_true(2 >= 0)
729 assert_true(2 >=
730 2)
731 assert_false(2 >= 3)
732 var nr2 = 2
733 assert_true(nr2 >= 0)
734 assert_true(nr2 >= 2)
735 assert_false(nr2 >= 3)
736 if has('float')
737 var ff = 2.0
738 assert_true(ff >= 0.0)
739 assert_true(ff >= 2.0)
740 assert_false(ff >= 3.0)
741 endif
742 END
743 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100744enddef
745
746" test < comperator
747def Test_expr4_smaller()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100748 var lines =<< trim END
749 assert_false(2 < 0)
750 assert_false(2 <
751 2)
752 assert_true(2
753 < 3)
754 var nr2 = 2
755 assert_false(nr2 < 0)
756 assert_false(nr2 < 2)
757 assert_true(nr2 < 3)
758 if has('float')
759 var ff = 2.0
760 assert_false(ff < 0.0)
761 assert_false(ff < 2.0)
762 assert_true(ff < 3.0)
763 endif
764 END
765 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100766enddef
767
768" test <= comperator
769def Test_expr4_smallerequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100770 var lines =<< trim END
771 assert_false(2 <= 0)
772 assert_false(2 <=
773 1)
774 assert_true(2
775 <= 2)
776 assert_true(2 <= 3)
777 var nr2 = 2
778 assert_false(nr2 <= 0)
779 assert_false(nr2 <= 1)
780 assert_true(nr2 <= 2)
781 assert_true(nr2 <= 3)
782 if has('float')
783 var ff = 2.0
784 assert_false(ff <= 0.0)
785 assert_false(ff <= 1.0)
786 assert_true(ff <= 2.0)
787 assert_true(ff <= 3.0)
788 endif
789 END
790 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100791enddef
792
793" test =~ comperator
794def Test_expr4_match()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100795 var lines =<< trim END
796 assert_equal(false, '2' =~ '0')
797 assert_equal(false, ''
798 =~ '0')
799 assert_equal(true, '2' =~
800 '[0-9]')
801 set ignorecase
802 assert_equal(false, 'abc' =~ 'ABC')
803 assert_equal(false, 'abc' =~# 'ABC')
804 assert_equal(true, 'abc' =~? 'ABC')
805 set noignorecase
806 END
807 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100808enddef
809
810" test !~ comperator
811def Test_expr4_nomatch()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100812 var lines =<< trim END
813 assert_equal(true, '2' !~ '0')
814 assert_equal(true, ''
815 !~ '0')
816 assert_equal(false, '2' !~
817 '[0-9]')
818 END
819 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100820enddef
821
822" test is comperator
823def Test_expr4_is()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100824 var lines =<< trim END
825 var mylist = [2]
826 assert_false(mylist is [2])
827 var other = mylist
828 assert_true(mylist is
829 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100830
Bram Moolenaar659bb222020-11-12 20:16:39 +0100831 var myblob = 0z1234
832 assert_false(myblob
833 is 0z1234)
834 var otherblob = myblob
835 assert_true(myblob is otherblob)
836 END
837 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100838enddef
839
840" test isnot comperator
841def Test_expr4_isnot()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100842 var lines =<< trim END
843 var mylist = [2]
844 assert_true('2' isnot '0')
845 assert_true(mylist isnot [2])
846 var other = mylist
847 assert_false(mylist isnot
848 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100849
Bram Moolenaar659bb222020-11-12 20:16:39 +0100850 var myblob = 0z1234
851 assert_true(myblob
852 isnot 0z1234)
853 var otherblob = myblob
854 assert_false(myblob isnot otherblob)
855 END
856 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100857enddef
858
859def RetVoid()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200860 var x = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100861enddef
862
Bram Moolenaar8294d492020-08-10 22:40:56 +0200863def Test_expr4_vim9script()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200864 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200865 var lines =<< trim END
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200866 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200867 var name = 0
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200868 < 1
Bram Moolenaar98309382020-09-27 21:58:45 +0200869 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200870 END
871 CheckScriptSuccess(lines)
872
873 lines =<< trim END
874 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200875 var name = 123
Bram Moolenaar93be1642020-10-11 21:34:41 +0200876 # comment
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200877 != 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200878 assert_equal(false, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200879 END
880 CheckScriptSuccess(lines)
881
882 lines =<< trim END
883 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +0200884 var name = 123 ==
Bram Moolenaar9215f012020-06-27 21:18:00 +0200885 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200886 assert_equal(true, name)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200887 END
888 CheckScriptSuccess(lines)
889
890 lines =<< trim END
891 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200892 var list = [1, 2, 3]
893 var name = list
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200894 is list
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200895 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200896 END
897 CheckScriptSuccess(lines)
898
899 lines =<< trim END
900 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +0200901 var list = [1, 2, 3]
902 var name = list # comment
903 # comment
904 is list
905 assert_equal(true, name)
906 END
907 CheckScriptSuccess(lines)
908
909 lines =<< trim END
910 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200911 var myblob = 0z1234
912 var name = myblob
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200913 isnot 0z11
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200914 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200915 END
916 CheckScriptSuccess(lines)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200917
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200918 # spot check mismatching types
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200919 lines =<< trim END
920 vim9script
921 echo '' == 0
922 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200923 CheckScriptFailure(lines, 'E1072:', 2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200924
925 lines =<< trim END
926 vim9script
927 echo v:true > v:false
928 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200929 CheckScriptFailure(lines, 'Cannot compare bool with bool', 2)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200930
931 lines =<< trim END
932 vim9script
933 echo 123 is 123
934 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200935 CheckScriptFailure(lines, 'Cannot use "is" with number', 2)
Bram Moolenaarc71f36a2020-07-21 21:31:00 +0200936
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200937 # check missing white space
938 lines =<< trim END
939 vim9script
940 echo 2>3
941 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100942 CheckScriptFailure(lines, 'E1004: White space required before and after ''>'' at ">3"', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200943 lines =<< trim END
944 vim9script
945 echo 2 >3
946 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200947 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200948 lines =<< trim END
949 vim9script
950 echo 2> 3
951 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200952 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200953 lines =<< trim END
954 vim9script
955 echo 2!=3
956 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200957 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200958 lines =<< trim END
959 vim9script
960 echo 2 !=3
961 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +0100962 CheckScriptFailure(lines, 'E1004: White space required before and after ''!'' at "!=3"', 2)
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200963 lines =<< trim END
964 vim9script
965 echo 2!= 3
966 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200967 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar8294d492020-08-10 22:40:56 +0200968
969 lines =<< trim END
970 vim9script
971 echo len('xxx') == 3
972 END
973 CheckScriptSuccess(lines)
Bram Moolenaarf9235712020-08-16 18:42:53 +0200974
975 lines =<< trim END
976 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200977 var line = 'abc'
Bram Moolenaarf9235712020-08-16 18:42:53 +0200978 echo line[1] =~ '\w'
979 END
980 CheckScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200981enddef
982
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100983func Test_expr4_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +0200984 let msg = "White space required before and after '>'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200985 call CheckDefFailure(["var x = 1>2"], msg, 1)
986 call CheckDefFailure(["var x = 1 >2"], msg, 1)
987 call CheckDefFailure(["var x = 1> 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100988
Bram Moolenaar77072282020-09-16 17:55:40 +0200989 let msg = "White space required before and after '=='"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200990 call CheckDefFailure(["var x = 1==2"], msg, 1)
991 call CheckDefFailure(["var x = 1 ==2"], msg, 1)
992 call CheckDefFailure(["var x = 1== 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100993
Bram Moolenaar77072282020-09-16 17:55:40 +0200994 let msg = "White space required before and after 'is'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200995 call CheckDefFailure(["var x = '1'is'2'"], msg, 1)
996 call CheckDefFailure(["var x = '1' is'2'"], msg, 1)
997 call CheckDefFailure(["var x = '1'is '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100998
Bram Moolenaar77072282020-09-16 17:55:40 +0200999 let msg = "White space required before and after 'isnot'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001000 call CheckDefFailure(["var x = '1'isnot'2'"], msg, 1)
1001 call CheckDefFailure(["var x = '1' isnot'2'"], msg, 1)
1002 call CheckDefFailure(["var x = '1'isnot '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001003
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001004 call CheckDefFailure(["var x = 1 is# 2"], 'E15:', 1)
1005 call CheckDefFailure(["var x = 1 is? 2"], 'E15:', 1)
1006 call CheckDefFailure(["var x = 1 isnot# 2"], 'E15:', 1)
1007 call CheckDefFailure(["var x = 1 isnot? 2"], 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001008
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001009 call CheckDefFailure(["var x = 1 == '2'"], 'Cannot compare number with string', 1)
1010 call CheckDefFailure(["var x = '1' == 2"], 'Cannot compare string with number', 1)
1011 call CheckDefFailure(["var x = 1 == RetVoid()"], 'Cannot compare number with void', 1)
1012 call CheckDefFailure(["var x = RetVoid() == 1"], 'Cannot compare void with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001013
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001014 call CheckDefFailure(["var x = true > false"], 'Cannot compare bool with bool', 1)
1015 call CheckDefFailure(["var x = true >= false"], 'Cannot compare bool with bool', 1)
1016 call CheckDefFailure(["var x = true < false"], 'Cannot compare bool with bool', 1)
1017 call CheckDefFailure(["var x = true <= false"], 'Cannot compare bool with bool', 1)
1018 call CheckDefFailure(["var x = true =~ false"], 'Cannot compare bool with bool', 1)
1019 call CheckDefFailure(["var x = true !~ false"], 'Cannot compare bool with bool', 1)
1020 call CheckDefFailure(["var x = true is false"], 'Cannot use "is" with bool', 1)
1021 call CheckDefFailure(["var x = true isnot false"], 'Cannot use "isnot" with bool', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001022
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001023 call CheckDefFailure(["var x = v:none is v:null"], 'Cannot use "is" with special', 1)
1024 call CheckDefFailure(["var x = v:none isnot v:null"], 'Cannot use "isnot" with special', 1)
1025 call CheckDefFailure(["var x = 123 is 123"], 'Cannot use "is" with number', 1)
1026 call CheckDefFailure(["var x = 123 isnot 123"], 'Cannot use "isnot" with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001027 if has('float')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001028 call CheckDefFailure(["var x = 1.3 is 1.3"], 'Cannot use "is" with float', 1)
1029 call CheckDefFailure(["var x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001030 endif
1031
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001032 call CheckDefFailure(["var x = 0za1 > 0z34"], 'Cannot compare blob with blob', 1)
1033 call CheckDefFailure(["var x = 0za1 >= 0z34"], 'Cannot compare blob with blob', 1)
1034 call CheckDefFailure(["var x = 0za1 < 0z34"], 'Cannot compare blob with blob', 1)
1035 call CheckDefFailure(["var x = 0za1 <= 0z34"], 'Cannot compare blob with blob', 1)
1036 call CheckDefFailure(["var x = 0za1 =~ 0z34"], 'Cannot compare blob with blob', 1)
1037 call CheckDefFailure(["var x = 0za1 !~ 0z34"], 'Cannot compare blob with blob', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001038
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001039 call CheckDefFailure(["var x = [13] > [88]"], 'Cannot compare list with list', 1)
1040 call CheckDefFailure(["var x = [13] >= [88]"], 'Cannot compare list with list', 1)
1041 call CheckDefFailure(["var x = [13] < [88]"], 'Cannot compare list with list', 1)
1042 call CheckDefFailure(["var x = [13] <= [88]"], 'Cannot compare list with list', 1)
1043 call CheckDefFailure(["var x = [13] =~ [88]"], 'Cannot compare list with list', 1)
1044 call CheckDefFailure(["var x = [13] !~ [88]"], 'Cannot compare list with list', 1)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001045
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001046 call CheckDefFailure(['var j: job', 'var chan: channel', 'var r = j == chan'], 'Cannot compare job with channel', 3)
1047 call CheckDefFailure(['var j: job', 'var x: list<any>', 'var r = j == x'], 'Cannot compare job with list', 3)
1048 call CheckDefFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
1049 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 +01001050endfunc
1051
1052" test addition, subtraction, concatenation
1053def Test_expr5()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001054 var lines =<< trim END
1055 assert_equal(66, 60 + 6)
1056 assert_equal(70, 60 +
1057 g:anint)
1058 assert_equal(9, g:thefour
1059 + 5)
1060 assert_equal(14, g:thefour + g:anint)
1061 assert_equal([1, 2, 3, 4], [1] + g:alist)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001062
Bram Moolenaar659bb222020-11-12 20:16:39 +01001063 assert_equal(54, 60 - 6)
1064 assert_equal(50, 60 -
1065 g:anint)
1066 assert_equal(-1, g:thefour
1067 - 5)
1068 assert_equal(-6, g:thefour - g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001069
Bram Moolenaar659bb222020-11-12 20:16:39 +01001070 assert_equal('hello', 'hel' .. 'lo')
1071 assert_equal('hello 123', 'hello ' ..
1072 123)
1073 assert_equal('hello 123', 'hello '
1074 .. 123)
1075 assert_equal('123 hello', 123 .. ' hello')
1076 assert_equal('123456', 123 .. 456)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001077
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001078 assert_equal('atrue', 'a' .. true)
1079 assert_equal('afalse', 'a' .. false)
Bram Moolenaar67977822021-01-03 21:53:53 +01001080 assert_equal('anull', 'a' .. v:null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001081 assert_equal('av:none', 'a' .. v:none)
1082 if has('float')
1083 assert_equal('a0.123', 'a' .. 0.123)
1084 endif
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001085
Bram Moolenaare507ff12021-01-31 21:47:42 +01001086 assert_equal(3, 1 + [2, 3, 4][0])
1087 assert_equal(5, 2 + {key: 3}['key'])
1088
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001089 set digraph
1090 assert_equal('val: true', 'val: ' .. &digraph)
1091 set nodigraph
1092 assert_equal('val: false', 'val: ' .. &digraph)
1093
Bram Moolenaar659bb222020-11-12 20:16:39 +01001094 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
1095 assert_equal(0z11223344, 0z1122 + 0z3344)
1096 assert_equal(0z112201ab, 0z1122
1097 + g:ablob)
1098 assert_equal(0z01ab3344, g:ablob + 0z3344)
1099 assert_equal(0z01ab01ab, g:ablob + g:ablob)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001100
Bram Moolenaar659bb222020-11-12 20:16:39 +01001101 # concatenate non-constant to constant
1102 var save_path = &path
1103 &path = 'b'
1104 assert_equal('ab', 'a' .. &path)
1105 &path = save_path
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001106
Bram Moolenaar659bb222020-11-12 20:16:39 +01001107 @b = 'b'
1108 assert_equal('ab', 'a' .. @b)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001109
Bram Moolenaar659bb222020-11-12 20:16:39 +01001110 $ENVVAR = 'env'
1111 assert_equal('aenv', 'a' .. $ENVVAR)
Bram Moolenaard62d87d2021-01-04 17:40:12 +01001112
1113 assert_equal('val', '' .. {key: 'val'}['key'])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001114 END
1115 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001116enddef
1117
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001118def Test_expr5_vim9script()
Bram Moolenaar696ba232020-07-29 21:20:41 +02001119 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001120 var lines =<< trim END
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001121 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001122 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001123 + 77
1124 - 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001125 assert_equal(66, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001126 END
1127 CheckScriptSuccess(lines)
1128
1129 lines =<< trim END
1130 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001131 var name = 11 +
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001132 77 -
1133 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001134 assert_equal(66, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001135 END
1136 CheckScriptSuccess(lines)
1137
1138 lines =<< trim END
1139 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +02001140 var name = 11 + # comment
1141 77 -
1142 # comment
1143 22
1144 assert_equal(66, name)
1145 END
1146 CheckScriptSuccess(lines)
1147
1148 lines =<< trim END
1149 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001150 var name = 'one'
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001151 .. 'two'
Bram Moolenaar98309382020-09-27 21:58:45 +02001152 assert_equal('onetwo', name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001153 END
1154 CheckScriptSuccess(lines)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001155
1156 lines =<< trim END
1157 vim9script
1158 echo 'abc' is# 'abc'
1159 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001160 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001161
1162 lines =<< trim END
1163 vim9script
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001164 echo {} - 22
1165 END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001166 CheckScriptFailure(lines, 'E728:', 2)
1167
1168 lines =<< trim END
1169 vim9script
1170 echo [] - 33
1171 END
1172 CheckScriptFailure(lines, 'E745:', 2)
1173
1174 lines =<< trim END
1175 vim9script
1176 echo 0z1234 - 44
1177 END
1178 CheckScriptFailure(lines, 'E974:', 2)
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001179
1180 lines =<< trim END
1181 vim9script
Bram Moolenaar696ba232020-07-29 21:20:41 +02001182 echo 'abc' is? 'abc'
1183 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001184 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001185
1186 lines =<< trim END
1187 vim9script
1188 echo 'abc' isnot# 'abc'
1189 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001190 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001191
1192 lines =<< trim END
1193 vim9script
1194 echo 'abc' isnot? 'abc'
1195 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001196 CheckScriptFailure(lines, 'E15:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001197
1198 # check white space
1199 lines =<< trim END
1200 vim9script
1201 echo 5+6
1202 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001203 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001204 lines =<< trim END
1205 vim9script
1206 echo 5 +6
1207 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001208 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001209 lines =<< trim END
1210 vim9script
1211 echo 5+ 6
1212 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001213 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001214
1215 lines =<< trim END
1216 vim9script
1217 echo 'a'..'b'
1218 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001219 CheckScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001220 lines =<< trim END
1221 vim9script
1222 echo 'a' ..'b'
1223 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001224 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001225 lines =<< trim END
1226 vim9script
1227 echo 'a'.. 'b'
1228 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001229 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001230
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001231 # check invalid string concatenation
1232 lines =<< trim END
1233 vim9script
1234 echo 'a' .. [1]
1235 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001236 CheckScriptFailure(lines, 'E730:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001237 lines =<< trim END
1238 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01001239 echo 'a' .. {a: 1}
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001240 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001241 CheckScriptFailure(lines, 'E731:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001242 lines =<< trim END
1243 vim9script
1244 echo 'a' .. test_void()
1245 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001246 CheckScriptFailure(lines, 'E908:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001247 lines =<< trim END
1248 vim9script
1249 echo 'a' .. 0z33
1250 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001251 CheckScriptFailure(lines, 'E976:', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001252 lines =<< trim END
1253 vim9script
1254 echo 'a' .. function('len')
1255 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001256 CheckScriptFailure(lines, 'E729:', 2)
Bram Moolenaara9749532021-03-06 18:18:19 +01001257
1258 lines =<< trim END
1259 vim9script
1260 new
1261 ['']->setline(1)
1262 /pattern
1263
1264 eval 0
1265 bwipe!
1266 END
1267 CheckScriptFailure(lines, "E1004: White space required before and after '/' at \"/pattern")
Bram Moolenaar79182382020-09-05 20:06:33 +02001268enddef
1269
1270def Test_expr5_vim9script_channel()
1271 if !has('channel')
1272 MissingFeature 'float'
1273 else
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001274 var lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001275 vim9script
1276 echo 'a' .. test_null_job()
1277 END
1278 CheckScriptFailure(lines, 'E908:', 2)
1279 lines =<< trim END
1280 vim9script
1281 echo 'a' .. test_null_channel()
1282 END
1283 CheckScriptFailure(lines, 'E908:', 2)
1284 endif
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001285enddef
1286
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001287def Test_expr5_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001288 if !has('float')
1289 MissingFeature 'float'
1290 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001291 var lines =<< trim END
1292 assert_equal(66.0, 60.0 + 6.0)
1293 assert_equal(66.0, 60.0 + 6)
1294 assert_equal(66.0, 60 +
1295 6.0)
1296 assert_equal(5.1, g:afloat
1297 + 5)
1298 assert_equal(8.1, 8 + g:afloat)
1299 assert_equal(10.1, g:anint + g:afloat)
1300 assert_equal(10.1, g:afloat + g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001301
Bram Moolenaar659bb222020-11-12 20:16:39 +01001302 assert_equal(54.0, 60.0 - 6.0)
1303 assert_equal(54.0, 60.0
1304 - 6)
1305 assert_equal(54.0, 60 - 6.0)
1306 assert_equal(-4.9, g:afloat - 5)
1307 assert_equal(7.9, 8 - g:afloat)
1308 assert_equal(9.9, g:anint - g:afloat)
1309 assert_equal(-9.9, g:afloat - g:anint)
1310 END
1311 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001312 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001313enddef
1314
1315func Test_expr5_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001316 let msg = "White space required before and after '+'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001317 call CheckDefFailure(["var x = 1+2"], msg, 1)
1318 call CheckDefFailure(["var x = 1 +2"], msg, 1)
1319 call CheckDefFailure(["var x = 1+ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001320
Bram Moolenaar77072282020-09-16 17:55:40 +02001321 let msg = "White space required before and after '-'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001322 call CheckDefFailure(["var x = 1-2"], msg, 1)
1323 call CheckDefFailure(["var x = 1 -2"], msg, 1)
1324 call CheckDefFailure(["var x = 1- 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001325
Bram Moolenaar77072282020-09-16 17:55:40 +02001326 let msg = "White space required before and after '..'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001327 call CheckDefFailure(["var x = '1'..'2'"], msg, 1)
1328 call CheckDefFailure(["var x = '1' ..'2'"], msg, 1)
1329 call CheckDefFailure(["var x = '1'.. '2'"], msg, 1)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001330
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001331 call CheckDefFailure(["var x = 0z1122 + 33"], 'E1051:', 1)
1332 call CheckDefFailure(["var x = 0z1122 + [3]"], 'E1051:', 1)
1333 call CheckDefFailure(["var x = 0z1122 + 'asd'"], 'E1051:', 1)
1334 call CheckDefFailure(["var x = 33 + 0z1122"], 'E1051:', 1)
1335 call CheckDefFailure(["var x = [3] + 0z1122"], 'E1051:', 1)
1336 call CheckDefFailure(["var x = 'asdf' + 0z1122"], 'E1051:', 1)
1337 call CheckDefFailure(["var x = 6 + xxx"], 'E1001:', 1)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001338
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001339 call CheckDefFailure(["var x = 'a' .. [1]"], 'E1105:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01001340 call CheckDefFailure(["var x = 'a' .. {a: 1}"], 'E1105:', 1)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001341 call CheckDefFailure(["var x = 'a' .. test_void()"], 'E1105:', 1)
1342 call CheckDefFailure(["var x = 'a' .. 0z32"], 'E1105:', 1)
1343 call CheckDefFailure(["var x = 'a' .. function('len')"], 'E1105:', 1)
1344 call CheckDefFailure(["var x = 'a' .. function('len', ['a'])"], 'E1105:', 1)
Bram Moolenaard92cc132020-11-18 17:17:15 +01001345
1346 call CheckScriptFailure(['vim9script', 'var x = 1 + v:none'], 'E611:', 2)
1347 call CheckScriptFailure(['vim9script', 'var x = 1 + v:null'], 'E611:', 2)
1348 call CheckScriptFailure(['vim9script', 'var x = 1 + v:true'], 'E1138:', 2)
1349 call CheckScriptFailure(['vim9script', 'var x = 1 + v:false'], 'E1138:', 2)
1350 call CheckScriptFailure(['vim9script', 'var x = 1 + true'], 'E1138:', 2)
1351 call CheckScriptFailure(['vim9script', 'var x = 1 + false'], 'E1138:', 2)
Bram Moolenaar79182382020-09-05 20:06:33 +02001352endfunc
1353
1354func Test_expr5_fails_channel()
1355 CheckFeature channel
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001356 call CheckDefFailure(["var x = 'a' .. test_null_job()"], 'E1105:', 1)
1357 call CheckDefFailure(["var x = 'a' .. test_null_channel()"], 'E1105:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001358endfunc
1359
Bram Moolenaar399ea812020-12-15 21:28:57 +01001360def Test_expr5_list_add()
1361 # concatenating two lists with same member types is OK
1362 var d = {}
1363 for i in ['a'] + ['b']
1364 d = {[i]: 0}
1365 endfor
1366
1367 # concatenating two lists with different member types results in "any"
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01001368 var dany = {}
1369 for i in ['a'] + [12]
1370 dany[i] = i
1371 endfor
1372 assert_equal({a: 'a', 12: 12}, dany)
Bram Moolenaard345fb92021-03-10 18:43:09 +01001373
1374 # result of glob() is "any", runtime type check
1375 var sl: list<string> = glob('*.txt', false, true) + ['']
Bram Moolenaar399ea812020-12-15 21:28:57 +01001376enddef
1377
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001378" test multiply, divide, modulo
1379def Test_expr6()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001380 var lines =<< trim END
1381 assert_equal(36, 6 * 6)
1382 assert_equal(24, 6 *
1383 g:thefour)
1384 assert_equal(24, g:thefour
1385 * 6)
1386 assert_equal(40, g:anint * g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001387
Bram Moolenaar659bb222020-11-12 20:16:39 +01001388 assert_equal(10, 60 / 6)
1389 assert_equal(6, 60 /
1390 g:anint)
1391 assert_equal(1, g:anint / 6)
1392 assert_equal(2, g:anint
1393 / g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001394
Bram Moolenaar659bb222020-11-12 20:16:39 +01001395 assert_equal(5, 11 % 6)
1396 assert_equal(4, g:anint % 6)
1397 assert_equal(3, 13 %
1398 g:anint)
1399 assert_equal(2, g:anint
1400 % g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001401
Bram Moolenaar659bb222020-11-12 20:16:39 +01001402 assert_equal(4, 6 * 4 / 6)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001403
Bram Moolenaar659bb222020-11-12 20:16:39 +01001404 var x = [2]
1405 var y = [3]
1406 assert_equal(5, x[0] + y[0])
1407 assert_equal(6, x[0] * y[0])
1408 if has('float')
1409 var xf = [2.0]
1410 var yf = [3.0]
1411 assert_equal(5.0, xf[0]
1412 + yf[0])
1413 assert_equal(6.0, xf[0]
1414 * yf[0])
1415 endif
1416 END
1417 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001418
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001419 CheckDefFailure(["var x = 6 * xxx"], 'E1001:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001420 CheckDefFailure(["var d = 6 * "], 'E1097:', 3)
Bram Moolenaar99880f92021-01-20 21:23:14 +01001421
1422 CheckDefExecAndScriptFailure(['echo 1 / 0'], 'E1154', 1)
1423 CheckDefExecAndScriptFailure(['echo 1 % 0'], 'E1154', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001424enddef
1425
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001426def Test_expr6_vim9script()
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001427 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001428 var lines =<< trim END
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001429 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001430 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001431 * 22
1432 / 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001433 assert_equal(80, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001434 END
1435 CheckScriptSuccess(lines)
1436
1437 lines =<< trim END
1438 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001439 var name = 25
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001440 % 10
Bram Moolenaar98309382020-09-27 21:58:45 +02001441 assert_equal(5, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001442 END
1443 CheckScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001444
1445 lines =<< trim END
1446 vim9script
Bram Moolenaar93be1642020-10-11 21:34:41 +02001447 var name = 25
1448 # comment
1449
1450 # comment
1451 % 10
1452 assert_equal(5, name)
1453 END
1454 CheckScriptSuccess(lines)
1455
1456 lines =<< trim END
1457 vim9script
Bram Moolenaar98309382020-09-27 21:58:45 +02001458 var name = 11 *
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001459 22 /
1460 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001461 assert_equal(80, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001462 END
1463 CheckScriptSuccess(lines)
1464
1465 # check white space
1466 lines =<< trim END
1467 vim9script
1468 echo 5*6
1469 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001470 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001471 lines =<< trim END
1472 vim9script
1473 echo 5 *6
1474 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001475 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001476 lines =<< trim END
1477 vim9script
1478 echo 5* 6
1479 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001480 CheckScriptFailure(lines, 'E1004:', 2)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001481enddef
1482
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001483def Test_expr6_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001484 if !has('float')
1485 MissingFeature 'float'
1486 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001487 var lines =<< trim END
1488 assert_equal(36.0, 6.0 * 6)
1489 assert_equal(36.0, 6 *
1490 6.0)
1491 assert_equal(36.0, 6.0 * 6.0)
1492 assert_equal(1.0, g:afloat * g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001493
Bram Moolenaar659bb222020-11-12 20:16:39 +01001494 assert_equal(10.0, 60 / 6.0)
1495 assert_equal(10.0, 60.0 /
1496 6)
1497 assert_equal(10.0, 60.0 / 6.0)
1498 assert_equal(0.01, g:afloat / g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001499
Bram Moolenaar659bb222020-11-12 20:16:39 +01001500 assert_equal(4.0, 6.0 * 4 / 6)
1501 assert_equal(4.0, 6 *
1502 4.0 /
1503 6)
1504 assert_equal(4.0, 6 * 4 / 6.0)
1505 assert_equal(4.0, 6.0 * 4.0 / 6)
1506 assert_equal(4.0, 6 * 4.0 / 6.0)
1507 assert_equal(4.0, 6.0 * 4 / 6.0)
1508 assert_equal(4.0, 6.0 * 4.0 / 6.0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001509
Bram Moolenaar659bb222020-11-12 20:16:39 +01001510 assert_equal(4.0, 6.0 * 4.0 / 6.0)
1511 END
1512 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001513 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001514enddef
1515
1516func Test_expr6_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001517 let msg = "White space required before and after '*'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001518 call CheckDefFailure(["var x = 1*2"], msg, 1)
1519 call CheckDefFailure(["var x = 1 *2"], msg, 1)
1520 call CheckDefFailure(["var x = 1* 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001521
Bram Moolenaar77072282020-09-16 17:55:40 +02001522 let msg = "White space required before and after '/'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001523 call CheckDefFailure(["var x = 1/2"], msg, 1)
1524 call CheckDefFailure(["var x = 1 /2"], msg, 1)
1525 call CheckDefFailure(["var x = 1/ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001526
Bram Moolenaar77072282020-09-16 17:55:40 +02001527 let msg = "White space required before and after '%'"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001528 call CheckDefFailure(["var x = 1%2"], msg, 1)
1529 call CheckDefFailure(["var x = 1 %2"], msg, 1)
1530 call CheckDefFailure(["var x = 1% 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001531
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001532 call CheckDefFailure(["var x = '1' * '2'"], 'E1036:', 1)
1533 call CheckDefFailure(["var x = '1' / '2'"], 'E1036:', 1)
1534 call CheckDefFailure(["var x = '1' % '2'"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001535
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001536 call CheckDefFailure(["var x = 0z01 * 0z12"], 'E1036:', 1)
1537 call CheckDefFailure(["var x = 0z01 / 0z12"], 'E1036:', 1)
1538 call CheckDefFailure(["var x = 0z01 % 0z12"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001539
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001540 call CheckDefFailure(["var x = [1] * [2]"], 'E1036:', 1)
1541 call CheckDefFailure(["var x = [1] / [2]"], 'E1036:', 1)
1542 call CheckDefFailure(["var x = [1] % [2]"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001543
Bram Moolenaare0de1712020-12-02 17:36:54 +01001544 call CheckDefFailure(["var x = {one: 1} * {two: 2}"], 'E1036:', 1)
1545 call CheckDefFailure(["var x = {one: 1} / {two: 2}"], 'E1036:', 1)
1546 call CheckDefFailure(["var x = {one: 1} % {two: 2}"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001547
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001548 call CheckDefFailure(["var x = 0xff[1]"], 'E1107:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001549 if has('float')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001550 call CheckDefFailure(["var x = 0.7[1]"], 'E1107:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001551 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001552endfunc
1553
1554func Test_expr6_float_fails()
1555 CheckFeature float
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001556 call CheckDefFailure(["var x = 1.0 % 2"], 'E1035:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001557endfunc
1558
1559" define here to use old style parsing
1560if has('float')
1561 let g:float_zero = 0.0
1562 let g:float_neg = -9.8
1563 let g:float_big = 9.9e99
1564endif
1565let g:blob_empty = 0z
1566let g:blob_one = 0z01
1567let g:blob_long = 0z0102.0304
1568
1569let g:string_empty = ''
1570let g:string_short = 'x'
1571let g:string_long = 'abcdefghijklm'
1572let g:string_special = "ab\ncd\ref\ekk"
1573
1574let g:special_true = v:true
1575let g:special_false = v:false
1576let g:special_null = v:null
1577let g:special_none = v:none
1578
1579let g:list_empty = []
1580let g:list_mixed = [1, 'b', v:false]
1581
1582let g:dict_empty = {}
1583let g:dict_one = #{one: 1}
1584
1585let $TESTVAR = 'testvar'
1586
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001587" type casts
1588def Test_expr7t()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001589 var ls: list<string> = ['a', <string>g:string_empty]
1590 var ln: list<number> = [<number>g:anint, <number>g:thefour]
1591 var nr = <number>234
Bram Moolenaard1103582020-08-14 22:44:25 +02001592 assert_equal(234, nr)
1593
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001594 CheckDefFailure(["var x = <nr>123"], 'E1010:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001595 CheckDefFailure(["var x = <number>"], 'E1097:', 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001596 CheckDefFailure(["var x = <number >123"], 'E1068:', 1)
1597 CheckDefFailure(["var x = <number 123"], 'E1104:', 1)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001598enddef
1599
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001600" test low level expression
1601def Test_expr7_number()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001602 # number constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001603 var lines =<< trim END
1604 assert_equal(0, 0)
1605 assert_equal(654, 0654)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001606
Bram Moolenaar659bb222020-11-12 20:16:39 +01001607 assert_equal(6, 0x6)
1608 assert_equal(15, 0xf)
1609 assert_equal(255, 0xff)
1610 END
1611 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001612enddef
1613
1614def Test_expr7_float()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001615 # float constant
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001616 if !has('float')
1617 MissingFeature 'float'
1618 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001619 var lines =<< trim END
1620 assert_equal(g:float_zero, .0)
1621 assert_equal(g:float_zero, 0.0)
1622 assert_equal(g:float_neg, -9.8)
1623 assert_equal(g:float_big, 9.9e99)
1624 END
1625 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001626 endif
1627enddef
1628
1629def Test_expr7_blob()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001630 # blob constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001631 var lines =<< trim END
1632 assert_equal(g:blob_empty, 0z)
1633 assert_equal(g:blob_one, 0z01)
1634 assert_equal(g:blob_long, 0z0102.0304)
1635 END
1636 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001637
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001638 CheckDefFailure(["var x = 0z123"], 'E973:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001639enddef
1640
1641def Test_expr7_string()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001642 # string constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001643 var lines =<< trim END
1644 assert_equal(g:string_empty, '')
1645 assert_equal(g:string_empty, "")
1646 assert_equal(g:string_short, 'x')
1647 assert_equal(g:string_short, "x")
1648 assert_equal(g:string_long, 'abcdefghijklm')
1649 assert_equal(g:string_long, "abcdefghijklm")
1650 assert_equal(g:string_special, "ab\ncd\ref\ekk")
1651 END
1652 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001653
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001654 CheckDefFailure(['var x = "abc'], 'E114:', 1)
1655 CheckDefFailure(["var x = 'abc"], 'E115:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001656enddef
1657
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001658def Test_expr7_vimvar()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001659 var old: list<string> = v:oldfiles
1660 var compl: dict<any> = v:completed_item
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001661
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001662 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 +02001663 new
1664 exec "normal! afoo fo\<C-N>\<Esc>"
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001665 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 +02001666 bwipe!
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001667enddef
1668
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001669def Test_expr7_special()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001670 # special constant
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001671 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001672 assert_equal(g:special_true, true)
1673 assert_equal(g:special_false, false)
1674 assert_equal(g:special_true, v:true)
1675 assert_equal(g:special_false, v:false)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001676 assert_equal(v:true, true)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001677 assert_equal(v:false, false)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001678
Bram Moolenaar6e4cfff2020-08-09 22:17:55 +02001679 assert_equal(true, !false)
1680 assert_equal(false, !true)
1681 assert_equal(true, !0)
1682 assert_equal(false, !1)
1683 assert_equal(false, !!false)
1684 assert_equal(true, !!true)
1685 assert_equal(false, !!0)
1686 assert_equal(true, !!1)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001687
1688 var t = true
1689 var f = false
1690 assert_equal(true, t)
1691 assert_equal(false, f)
1692
1693 assert_equal(g:special_null, v:null)
Bram Moolenaar67977822021-01-03 21:53:53 +01001694 assert_equal(g:special_null, null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001695 assert_equal(g:special_none, v:none)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001696 END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001697 CheckDefAndScriptSuccess(lines)
1698
1699 CheckDefFailure(['v:true = true'], 'E46:', 1)
1700 CheckDefFailure(['v:true = false'], 'E46:', 1)
1701 CheckDefFailure(['v:false = true'], 'E46:', 1)
1702 CheckDefFailure(['v:null = 11'], 'E46:', 1)
1703 CheckDefFailure(['v:none = 22'], 'E46:', 1)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001704enddef
1705
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001706def Test_expr7_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001707 # list
Bram Moolenaar659bb222020-11-12 20:16:39 +01001708 var lines =<< trim END
1709 assert_equal(g:list_empty, [])
1710 assert_equal(g:list_empty, [ ])
Bram Moolenaar127542b2020-08-09 17:22:04 +02001711
Bram Moolenaar659bb222020-11-12 20:16:39 +01001712 var numbers: list<number> = [1, 2, 3]
1713 numbers = [1]
1714 numbers = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001715
Bram Moolenaar659bb222020-11-12 20:16:39 +01001716 var strings: list<string> = ['a', 'b', 'c']
1717 strings = ['x']
1718 strings = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001719
Bram Moolenaar659bb222020-11-12 20:16:39 +01001720 var mixed: list<any> = [1, 'b', false,]
1721 assert_equal(g:list_mixed, mixed)
1722 assert_equal('b', mixed[1])
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001723
Bram Moolenaar659bb222020-11-12 20:16:39 +01001724 echo [1,
1725 2] [3,
1726 4]
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001727
Bram Moolenaar659bb222020-11-12 20:16:39 +01001728 var llstring: list<list<string>> = [['text'], []]
1729 llstring = [[], ['text']]
1730 llstring = [[], []]
1731 END
1732 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02001733
Bram Moolenaar5597ba02020-09-27 17:45:03 +02001734 var rangelist: list<number> = range(3)
1735 g:rangelist = range(3)
1736 CheckDefExecFailure(["var x: list<string> = g:rangelist"], 'E1012: Type mismatch; expected list<string> but got list<number>', 1)
1737
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001738 CheckDefFailure(["var x = 1234[3]"], 'E1107:', 1)
1739 CheckDefExecFailure(["var x = g:anint[3]"], 'E1062:', 1)
Bram Moolenaar56acb092020-08-16 14:48:19 +02001740
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001741 CheckDefFailure(["var x = g:list_mixed[xxx]"], 'E1001:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001742
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001743 CheckDefFailure(["var x = [1,2,3]"], 'E1069:', 1)
1744 CheckDefFailure(["var x = [1 ,2, 3]"], 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001745
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001746 CheckDefExecFailure(["echo 1", "var x = [][0]", "echo 3"], 'E684:', 2)
Bram Moolenaar1d634542020-08-18 13:41:50 +02001747
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001748 CheckDefExecFailure(["var x = g:list_mixed['xx']"], 'E1012:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001749 CheckDefFailure(["var x = g:list_mixed["], 'E1097:', 3)
1750 CheckDefFailure(["var x = g:list_mixed[0"], 'E1097:', 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001751 CheckDefExecFailure(["var x = g:list_empty[3]"], 'E684:', 1)
1752 CheckDefExecFailure(["var l: list<number> = [234, 'x']"], 'E1012:', 1)
1753 CheckDefExecFailure(["var l: list<number> = ['x', 234]"], 'E1012:', 1)
1754 CheckDefExecFailure(["var l: list<string> = [234, 'x']"], 'E1012:', 1)
1755 CheckDefExecFailure(["var l: list<string> = ['x', 123]"], 'E1012:', 1)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001756
Bram Moolenaar659bb222020-11-12 20:16:39 +01001757 lines =<< trim END
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001758 vim9script
1759 var datalist: list<string>
1760 def Main()
1761 datalist += ['x'.
1762 enddef
1763 Main()
1764 END
1765 CheckScriptFailure(lines, 'E1127:')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001766
1767 lines =<< trim END
1768 var numbers = [1, 2, 3, 4]
1769 var a = 1
1770 var b = 2
1771 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001772 CheckDefAndScriptFailure(lines + ['echo numbers[1:b]'],
1773 'E1004: White space required before and after '':'' at ":b]"', 4)
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001774 CheckDefAndScriptFailure(lines + ['echo numbers[1: b]'], 'E1004:', 4)
1775 CheckDefAndScriptFailure(lines + ['echo numbers[a :b]'], 'E1004:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001776enddef
1777
Bram Moolenaar71478202020-06-26 22:46:27 +02001778def Test_expr7_list_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001779 var lines =<< trim END
Bram Moolenaar71478202020-06-26 22:46:27 +02001780 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001781 var l = [
Bram Moolenaar71478202020-06-26 22:46:27 +02001782 11,
1783 22,
1784 ]
1785 assert_equal([11, 22], l)
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001786
1787 echo [1,
1788 2] [3,
1789 4]
Bram Moolenaar93be1642020-10-11 21:34:41 +02001790
1791 echo [1, # comment
1792 # comment
1793 2] [3,
1794 # comment
1795 4]
Bram Moolenaar71478202020-06-26 22:46:27 +02001796 END
1797 CheckScriptSuccess(lines)
1798
1799 lines =<< trim END
1800 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001801 var l = [11,
Bram Moolenaar71478202020-06-26 22:46:27 +02001802 22]
1803 assert_equal([11, 22], l)
1804 END
1805 CheckScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001806
1807 lines =<< trim END
1808 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001809 var l = [11,22]
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001810 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001811 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02001812
1813 lines =<< trim END
1814 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001815 var l = [11 , 22]
Bram Moolenaardb199212020-08-12 18:01:53 +02001816 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001817 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001818
1819 lines =<< trim END
1820 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001821 var l: list<number> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001822 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001823 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001824 lines =<< trim END
1825 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001826 var l: list<number> = ['x', 234]
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001827 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001828 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001829 lines =<< trim END
1830 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001831 var l: list<string> = ['x', 234]
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001832 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001833 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001834 lines =<< trim END
1835 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001836 var l: list<string> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001837 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001838 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01001839
1840 lines =<< trim END
1841 vim9script
1842 def Failing()
1843 job_stop()
1844 enddef
1845 var list = [Failing]
1846 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001847 if has('channel')
1848 CheckScriptFailure(lines, 'E119:', 1)
1849 else
1850 CheckScriptFailure(lines, 'E117:', 1)
1851 endif
Bram Moolenaar71478202020-06-26 22:46:27 +02001852enddef
1853
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001854def LambdaWithComments(): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001855 return (x) =>
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001856 # some comment
1857 x == 1
1858 # some comment
1859 ||
1860 x == 2
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001861enddef
1862
Bram Moolenaarfd777482020-08-12 19:42:01 +02001863def LambdaUsingArg(x: number): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001864 return () =>
Bram Moolenaarfd777482020-08-12 19:42:01 +02001865 # some comment
1866 x == 1
1867 # some comment
1868 ||
1869 x == 2
Bram Moolenaarfd777482020-08-12 19:42:01 +02001870enddef
1871
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001872def Test_expr7_lambda()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001873 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001874 var La = () => 'result'
Bram Moolenaar659bb222020-11-12 20:16:39 +01001875 assert_equal('result', La())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001876 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02001877
Bram Moolenaar659bb222020-11-12 20:16:39 +01001878 # line continuation inside lambda with "cond ? expr : expr" works
1879 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001880 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaare0de1712020-12-02 17:36:54 +01001881 ['111']: 111 } : {}
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001882 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001883 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001884
Bram Moolenaar659bb222020-11-12 20:16:39 +01001885 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001886 map(ll, (k, v) => v == 8 || v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001887 == 9
1888 || v % 2 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001889 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001890 assert_equal([222, 111, 222], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001891
Bram Moolenaar659bb222020-11-12 20:16:39 +01001892 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001893 map(ll, (k, v) => v != 8 && v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001894 != 9
1895 && v % 2 == 0 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001896 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001897 assert_equal([111, 222, 111], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001898
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001899 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
Bram Moolenaare0de1712020-12-02 17:36:54 +01001900 assert_equal([{key: 22}], dl)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02001901
Bram Moolenaare0de1712020-12-02 17:36:54 +01001902 dl = [{key: 12}, {['foo']: 34}]
1903 assert_equal([{key: 12}], filter(dl,
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001904 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
Bram Moolenaar7892b952020-07-20 22:09:34 +02001905
Bram Moolenaar659bb222020-11-12 20:16:39 +01001906 assert_equal(false, LambdaWithComments()(0))
1907 assert_equal(true, LambdaWithComments()(1))
1908 assert_equal(true, LambdaWithComments()(2))
1909 assert_equal(false, LambdaWithComments()(3))
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001910
Bram Moolenaar659bb222020-11-12 20:16:39 +01001911 assert_equal(false, LambdaUsingArg(0)())
1912 assert_equal(true, LambdaUsingArg(1)())
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001913
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001914 var res = map([1, 2, 3], (i: number, v: number) => i + v)
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001915 assert_equal([1, 3, 5], res)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001916 END
1917 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfd777482020-08-12 19:42:01 +02001918
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001919 CheckDefFailure(["var Ref = (a)=>a + 1"], 'E1004:')
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001920 CheckDefFailure(["var Ref = (a)=> a + 1"], 'E1004: White space required before and after ''=>'' at "=> a + 1"')
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001921 CheckDefFailure(["var Ref = (a) =>a + 1"], 'E1004:')
Bram Moolenaar27bf7af2020-12-23 20:27:31 +01001922
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001923 CheckDefFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02001924 # error is in first line of the lambda
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001925 CheckDefFailure(["var L = (a) => a + b"], 'E1001:', 0)
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001926
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001927 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar79e8db92020-08-14 22:16:33 +02001928
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001929 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"], 'E118:')
1930 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"], 'E118:')
1931 CheckDefFailure(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 1)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02001932
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001933 CheckDefSuccess(['var Fx = (a) => ({k1: 0,', ' k2: 1})'])
1934 CheckDefFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
1935 CheckDefFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02001936
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001937 CheckDefSuccess(['var Fx = (a) => [0,', ' 1]'])
1938 CheckDefFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01001939
1940 # no error for existing script variable when checking for lambda
1941 lines =<< trim END
1942 vim9script
1943 var name = 0
1944 eval (name + 2) / 3
1945 END
1946 CheckScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001947enddef
1948
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01001949def Test_expr7_lambda_block()
1950 var lines =<< trim END
1951 var Func = (s: string): string => {
1952 return 'hello ' .. s
1953 }
1954 assert_equal('hello there', Func('there'))
1955
1956 var ll = range(3)
1957 var dll = mapnew(ll, (k, v): string => {
1958 if v % 2
1959 return 'yes'
1960 endif
1961 return 'no'
1962 })
1963 assert_equal(['no', 'yes', 'no'], dll)
1964 END
1965 CheckDefAndScriptSuccess(lines)
Bram Moolenaare98f60a2021-03-22 18:22:30 +01001966
1967 lines =<< trim END
1968 map([1, 2], (k, v) => { redrawt })
1969 END
1970 CheckDefAndScriptFailure(lines, 'E488')
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01001971enddef
1972
Bram Moolenaar65c44152020-12-24 15:14:01 +01001973def NewLambdaWithComments(): func
1974 return (x) =>
1975 # some comment
1976 x == 1
1977 # some comment
1978 ||
1979 x == 2
1980enddef
1981
1982def NewLambdaUsingArg(x: number): func
1983 return () =>
1984 # some comment
1985 x == 1
1986 # some comment
1987 ||
1988 x == 2
1989enddef
1990
1991def Test_expr7_new_lambda()
1992 var lines =<< trim END
1993 var La = () => 'result'
1994 assert_equal('result', La())
1995 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
1996
1997 # line continuation inside lambda with "cond ? expr : expr" works
1998 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001999 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaar65c44152020-12-24 15:14:01 +01002000 ['111']: 111 } : {}
2001 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002002 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002003
2004 ll = range(3)
2005 map(ll, (k, v) => v == 8 || v
2006 == 9
2007 || v % 2 ? 111 : 222
2008 )
2009 assert_equal([222, 111, 222], ll)
2010
2011 ll = range(3)
2012 map(ll, (k, v) => v != 8 && v
2013 != 9
2014 && v % 2 == 0 ? 111 : 222
2015 )
2016 assert_equal([111, 222, 111], ll)
2017
2018 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
2019 assert_equal([{key: 22}], dl)
2020
2021 dl = [{key: 12}, {['foo']: 34}]
2022 assert_equal([{key: 12}], filter(dl,
2023 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
2024
2025 assert_equal(false, NewLambdaWithComments()(0))
2026 assert_equal(true, NewLambdaWithComments()(1))
2027 assert_equal(true, NewLambdaWithComments()(2))
2028 assert_equal(false, NewLambdaWithComments()(3))
2029
2030 assert_equal(false, NewLambdaUsingArg(0)())
2031 assert_equal(true, NewLambdaUsingArg(1)())
2032
2033 var res = map([1, 2, 3], (i: number, v: number) => i + v)
2034 assert_equal([1, 3, 5], res)
2035
2036 # Lambda returning a dict
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002037 var Lmb = () => ({key: 42})
Bram Moolenaar65c44152020-12-24 15:14:01 +01002038 assert_equal({key: 42}, Lmb())
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002039
2040 var RefOne: func(number): string = (a: number): string => 'x'
2041 var RefTwo: func(number): any = (a: number): any => 'x'
2042
2043 var Fx = (a) => ({k1: 0,
2044 k2: 1})
2045 var Fy = (a) => [0,
2046 1]
Bram Moolenaar65c44152020-12-24 15:14:01 +01002047 END
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002048 CheckDefAndScriptSuccess(lines)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002049
Bram Moolenaare462f522020-12-27 14:43:30 +01002050 CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2051 CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004:')
Bram Moolenaare7a73e02021-01-01 19:17:55 +01002052 CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"],
2053 'E1004: White space required before and after ''=>'' at " =>a + 1"')
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002054
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002055 CheckDefFailure(["var Ref: func(number): number = (a: number): string => 'x'"], 'E1012:')
2056 CheckDefFailure(["var Ref: func(number): string = (a: number): string => 99"], 'E1012:')
2057
Bram Moolenaar65c44152020-12-24 15:14:01 +01002058 CheckDefFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
2059 # error is in first line of the lambda
2060 CheckDefFailure(["var L = (a) -> a + b"], 'E1001:', 1)
2061
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002062# TODO: ->(lambda)() doesn't work yet
Bram Moolenaar65c44152020-12-24 15:14:01 +01002063# assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
2064
2065# CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x')"],
2066# 'E1106: One argument too many')
2067# CheckDefExecFailure(["var s = 'asdf'->{a -> a}('x', 'y')"],
2068# 'E1106: 2 arguments too many')
2069# CheckDefFailure(["echo 'asdf'->{a -> a}(x)"], 'E1001:', 1)
2070
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002071 CheckDefFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2072 CheckDefFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002073
Bram Moolenaar65c44152020-12-24 15:14:01 +01002074 CheckDefFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
2075enddef
2076
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002077def Test_expr7_lambda_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002078 var lines =<< trim END
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002079 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002080 var v = 10->((a) =>
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002081 a
2082 + 2
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002083 )()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002084 assert_equal(12, v)
2085 END
2086 CheckScriptSuccess(lines)
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002087
2088 # nested lambda with line breaks
2089 lines =<< trim END
2090 vim9script
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002091 search('"', 'cW', 0, 0, () =>
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002092 synstack('.', col('.'))
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002093 ->map((_, v) => synIDattr(v, 'name'))->len())
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002094 END
2095 CheckScriptSuccess(lines)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002096enddef
2097
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002098def Test_epxr7_funcref()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002099 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002100 def RetNumber(): number
2101 return 123
2102 enddef
2103 var FuncRef = RetNumber
2104 assert_equal(123, FuncRef())
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002105 END
2106 CheckDefAndScriptSuccess(lines)
2107enddef
2108
Bram Moolenaar2bede172020-11-19 18:53:18 +01002109let g:test_space_dict = {'': 'empty', ' ': 'space'}
2110let g:test_hash_dict = #{one: 1, two: 2}
2111
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002112def Test_expr7_dict()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002113 # dictionary
Bram Moolenaar659bb222020-11-12 20:16:39 +01002114 var lines =<< trim END
2115 assert_equal(g:dict_empty, {})
2116 assert_equal(g:dict_empty, { })
Bram Moolenaare0de1712020-12-02 17:36:54 +01002117 assert_equal(g:dict_one, {['one']: 1})
Bram Moolenaar659bb222020-11-12 20:16:39 +01002118 var key = 'one'
2119 var val = 1
Bram Moolenaar2bede172020-11-19 18:53:18 +01002120 assert_equal(g:dict_one, {[key]: val})
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002121
Bram Moolenaar2bede172020-11-19 18:53:18 +01002122 var numbers: dict<number> = {a: 1, b: 2, c: 3}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002123 numbers = {a: 1}
2124 numbers = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002125
Bram Moolenaar2bede172020-11-19 18:53:18 +01002126 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002127 strings = {a: 'x'}
2128 strings = {}
2129
2130 var dash = {xx-x: 8}
2131 assert_equal({['xx-x']: 8}, dash)
2132
2133 var dnr = {8: 8}
2134 assert_equal({['8']: 8}, dnr)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002135
Bram Moolenaar2bede172020-11-19 18:53:18 +01002136 var mixed: dict<any> = {a: 'a', b: 42}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002137 mixed = {a: 'x'}
2138 mixed = {a: 234}
2139 mixed = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002140
Bram Moolenaare0de1712020-12-02 17:36:54 +01002141 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
2142 dictlist = {absent: ['hi'], present: []}
2143 dictlist = {absent: [], present: []}
Bram Moolenaar77b20972020-09-19 14:12:34 +02002144
Bram Moolenaare0de1712020-12-02 17:36:54 +01002145 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
2146 dictdict = {one: {}, two: {a: 'text'}}
2147 dictdict = {one: {}, two: {}}
Bram Moolenaarc7f7f6d2020-11-04 13:38:28 +01002148
Bram Moolenaare0de1712020-12-02 17:36:54 +01002149 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
Bram Moolenaar2bede172020-11-19 18:53:18 +01002150
2151 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
2152 assert_equal(g:test_hash_dict, {one: 1, two: 2})
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01002153
2154 assert_equal({['a a']: 1, ['b/c']: 2}, {'a a': 1, "b/c": 2})
Bram Moolenaar6b553772020-12-31 13:31:23 +01002155
2156 var d = {a: () => 3, b: () => 7}
2157 assert_equal(3, d.a())
2158 assert_equal(7, d.b())
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002159
2160 var cd = { # comment
2161 key: 'val' # comment
2162 }
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002163
2164 # different types used for the key
2165 var dkeys = {['key']: 'string',
2166 [12]: 'numberexpr',
2167 34: 'number',
2168 [true]: 'bool'}
2169 assert_equal('string', dkeys['key'])
2170 assert_equal('numberexpr', dkeys[12])
2171 assert_equal('number', dkeys[34])
2172 assert_equal('bool', dkeys[true])
2173 if has('float')
2174 dkeys = {[1.2]: 'floatexpr', [3.4]: 'float'}
2175 assert_equal('floatexpr', dkeys[1.2])
2176 assert_equal('float', dkeys[3.4])
2177 endif
2178
2179 # automatic conversion from number to string
2180 var n = 123
2181 var dictnr = {[n]: 1}
Bram Moolenaara0399ef2021-03-20 15:00:01 +01002182
2183 # comment to start fold is OK
2184 var x1: number #{{ fold
2185 var x2 = 9 #{{ fold
Bram Moolenaar659bb222020-11-12 20:16:39 +01002186 END
2187 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002188
Bram Moolenaare0de1712020-12-02 17:36:54 +01002189 # legacy syntax doesn't work
Bram Moolenaar5c7a2992021-03-20 13:29:38 +01002190 CheckDefAndScriptFailure(["var x = #{key: 8}"], 'E1170:', 1)
2191 CheckDefAndScriptFailure(["var x = 'a' #{a: 1}"], 'E1170:', 1)
2192 CheckDefAndScriptFailure(["var x = 'a' .. #{a: 1}"], 'E1170:', 1)
2193 CheckDefAndScriptFailure(["var x = true ? #{a: 1}"], 'E1170:', 1)
Bram Moolenaar17a836c2020-08-12 17:35:58 +02002194
Bram Moolenaare0de1712020-12-02 17:36:54 +01002195 CheckDefFailure(["var x = {a:8}"], 'E1069:', 1)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002196 CheckDefFailure(["var x = {a : 8}"], 'E1068:', 1)
2197 CheckDefFailure(["var x = {a :8}"], 'E1068:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002198 CheckDefFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
2199 CheckDefFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
2200
2201 CheckDefFailure(["var x = {xxx}"], 'E720:', 1)
2202 CheckDefFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
2203 CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
2204 CheckDefFailure(["var x = {['a']: xxx}"], 'E1001:', 1)
2205 CheckDefFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002206 CheckDefExecFailure(["var x = g:anint.member"], 'E715:', 1)
2207 CheckDefExecFailure(["var x = g:dict_empty.member"], 'E716:', 1)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002208
Bram Moolenaare0de1712020-12-02 17:36:54 +01002209 CheckDefExecFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
2210 CheckDefExecFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
2211 CheckDefExecFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
2212 CheckDefExecFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002213
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002214 # invalid types for the key
2215 CheckDefFailure(["var x = {[[1, 2]]: 0}"], 'E1105:', 1)
2216
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002217 CheckDefFailure(['var x = ({'], 'E723:', 2)
Bram Moolenaar7bb4e742020-12-09 12:41:50 +01002218 CheckDefExecFailure(['{}[getftype("file")]'], 'E716: Key not present in Dictionary: ""', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002219enddef
2220
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002221def Test_expr7_dict_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002222 var lines =<< trim END
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002223 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002224 var d = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002225 ['one']:
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002226 1,
Bram Moolenaare0de1712020-12-02 17:36:54 +01002227 ['two']: 2,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002228 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002229 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar93be1642020-10-11 21:34:41 +02002230
2231 d = { # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002232 ['one']:
Bram Moolenaar93be1642020-10-11 21:34:41 +02002233 # comment
2234
2235 1,
2236 # comment
2237 # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002238 ['two']: 2,
Bram Moolenaar93be1642020-10-11 21:34:41 +02002239 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002240 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002241
2242 var dd = {k: 123->len()}
2243 assert_equal(3, dd.k)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002244 END
2245 CheckScriptSuccess(lines)
2246
2247 lines =<< trim END
2248 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002249 var d = { ["one"]: "one", ["two"]: "two", }
2250 assert_equal({one: 'one', two: 'two'}, d)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002251 END
2252 CheckScriptSuccess(lines)
2253
2254 lines =<< trim END
2255 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002256 var d = {one: 1,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002257 two: 2,
2258 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002259 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002260 END
2261 CheckScriptSuccess(lines)
2262
2263 lines =<< trim END
2264 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002265 var d = {one:1, two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002266 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002267 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002268
2269 lines =<< trim END
2270 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002271 var d = {one: 1,two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002272 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002273 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02002274
2275 lines =<< trim END
2276 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002277 var d = {one : 1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002278 END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002279 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaardb199212020-08-12 18:01:53 +02002280
2281 lines =<< trim END
2282 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002283 var d = {one:1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002284 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002285 CheckScriptFailure(lines, 'E1069:', 2)
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002286
2287 lines =<< trim END
2288 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002289 var d = {one: 1 , two: 2}
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002290 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002291 CheckScriptFailure(lines, 'E1068:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002292
2293 lines =<< trim END
2294 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002295 var l: dict<number> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002296 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002297 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002298 lines =<< trim END
2299 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002300 var l: dict<number> = {a: 'x', b: 234}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002301 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002302 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002303 lines =<< trim END
2304 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002305 var l: dict<string> = {a: 'x', b: 234}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002306 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002307 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002308 lines =<< trim END
2309 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002310 var l: dict<string> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002311 END
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002312 CheckScriptFailure(lines, 'E1012:', 2)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002313
2314 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002315 vim9script
2316 var d = {['a']: 234, ['b': 'x'}
2317 END
2318 CheckScriptFailure(lines, 'E1139:', 2)
2319 lines =<< trim END
2320 vim9script
2321 def Func()
2322 var d = {['a']: 234, ['b': 'x'}
2323 enddef
2324 defcompile
2325 END
2326 CheckScriptFailure(lines, 'E1139:', 1)
2327 lines =<< trim END
2328 vim9script
2329 var d = {'a':
2330 END
2331 CheckScriptFailure(lines, 'E15:', 2)
2332 lines =<< trim END
2333 vim9script
2334 def Func()
2335 var d = {'a':
2336 enddef
2337 defcompile
2338 END
2339 CheckScriptFailure(lines, 'E723:', 1)
2340
2341 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002342 vim9script
2343 def Failing()
2344 job_stop()
2345 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002346 var dict = {name: Failing}
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002347 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002348 if has('channel')
2349 CheckScriptFailure(lines, 'E119:', 1)
2350 else
2351 CheckScriptFailure(lines, 'E117:', 1)
2352 endif
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002353enddef
2354
Bram Moolenaar50788ef2020-07-05 16:51:26 +02002355let g:oneString = 'one'
2356
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002357def Test_expr_member()
2358 assert_equal(1, g:dict_one.one)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002359 var d: dict<number> = g:dict_one
Bram Moolenaar4dac32c2020-05-15 21:44:19 +02002360 assert_equal(1, d['one'])
Bram Moolenaara7eedf32020-07-10 21:50:41 +02002361 assert_equal(1, d[
2362 'one'
2363 ])
2364 assert_equal(1, d
2365 .one)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002366 d = {1: 1, _: 2}
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002367 assert_equal(1, d
2368 .1)
2369 assert_equal(2, d
2370 ._)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002371
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002372 # getting the one member should clear the dict after getting the item
Bram Moolenaare0de1712020-12-02 17:36:54 +01002373 assert_equal('one', {one: 'one'}.one)
2374 assert_equal('one', {one: 'one'}[g:oneString])
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002375
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002376 CheckDefFailure(["var x = g:dict_one.#$!"], 'E1002:', 1)
2377 CheckDefExecFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2378 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 +02002379enddef
2380
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002381def Test_expr7_any_index_slice()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002382 var lines =<< trim END
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002383 # getting the one member should clear the list only after getting the item
2384 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
2385
2386 # string is permissive, index out of range accepted
2387 g:teststring = 'abcdef'
2388 assert_equal('b', g:teststring[1])
Bram Moolenaare7525c52021-01-09 13:20:37 +01002389 assert_equal('f', g:teststring[-1])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002390 assert_equal('', g:teststring[99])
2391
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002392 assert_equal('b', g:teststring[1 : 1])
2393 assert_equal('bcdef', g:teststring[1 :])
2394 assert_equal('abcd', g:teststring[: 3])
2395 assert_equal('cdef', g:teststring[-4 :])
2396 assert_equal('abcdef', g:teststring[-9 :])
2397 assert_equal('abcd', g:teststring[: -3])
2398 assert_equal('', g:teststring[: -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002399
Bram Moolenaar0289a092021-03-14 18:40:19 +01002400 # composing characters are included
2401 g:teststring = 'àéû'
2402 assert_equal('à', g:teststring[0])
2403 assert_equal('é', g:teststring[1])
2404 assert_equal('û', g:teststring[2])
2405 assert_equal('', g:teststring[3])
2406 assert_equal('', g:teststring[4])
2407
2408 assert_equal('û', g:teststring[-1])
2409 assert_equal('é', g:teststring[-2])
2410 assert_equal('à', g:teststring[-3])
2411 assert_equal('', g:teststring[-4])
2412 assert_equal('', g:teststring[-5])
2413
2414 assert_equal('à', g:teststring[0 : 0])
2415 assert_equal('é', g:teststring[1 : 1])
2416 assert_equal('àé', g:teststring[0 : 1])
2417 assert_equal('àéû', g:teststring[0 : -1])
2418 assert_equal('àé', g:teststring[0 : -2])
2419 assert_equal('à', g:teststring[0 : -3])
2420 assert_equal('', g:teststring[0 : -4])
2421 assert_equal('', g:teststring[0 : -5])
2422 assert_equal('àéû', g:teststring[ : ])
2423 assert_equal('àéû', g:teststring[0 : ])
2424 assert_equal('éû', g:teststring[1 : ])
2425 assert_equal('û', g:teststring[2 : ])
2426 assert_equal('', g:teststring[3 : ])
2427 assert_equal('', g:teststring[4 : ])
2428
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002429 # blob index cannot be out of range
2430 g:testblob = 0z01ab
2431 assert_equal(0x01, g:testblob[0])
2432 assert_equal(0xab, g:testblob[1])
2433 assert_equal(0xab, g:testblob[-1])
2434 assert_equal(0x01, g:testblob[-2])
2435
2436 # blob slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002437 assert_equal(0z01ab, g:testblob[0 : 1])
2438 assert_equal(0z01, g:testblob[0 : 0])
2439 assert_equal(0z01, g:testblob[-2 : -2])
2440 assert_equal(0zab, g:testblob[1 : 1])
2441 assert_equal(0zab, g:testblob[-1 : -1])
2442 assert_equal(0z, g:testblob[2 : 2])
2443 assert_equal(0z, g:testblob[0 : -3])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002444
2445 # list index cannot be out of range
2446 g:testlist = [0, 1, 2, 3]
2447 assert_equal(0, g:testlist[0])
2448 assert_equal(1, g:testlist[1])
2449 assert_equal(3, g:testlist[3])
2450 assert_equal(3, g:testlist[-1])
2451 assert_equal(0, g:testlist[-4])
2452 assert_equal(1, g:testlist[g:theone])
2453
2454 # list slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002455 assert_equal([0], g:testlist[0 : 0])
2456 assert_equal([3], g:testlist[3 : 3])
2457 assert_equal([0, 1], g:testlist[0 : 1])
2458 assert_equal([0, 1, 2, 3], g:testlist[0 : 3])
2459 assert_equal([0, 1, 2, 3], g:testlist[0 : 9])
2460 assert_equal([], g:testlist[-1 : 1])
2461 assert_equal([1], g:testlist[-3 : 1])
2462 assert_equal([0, 1], g:testlist[-4 : 1])
2463 assert_equal([0, 1], g:testlist[-9 : 1])
2464 assert_equal([1, 2, 3], g:testlist[1 : -1])
2465 assert_equal([1], g:testlist[1 : -3])
2466 assert_equal([], g:testlist[1 : -4])
2467 assert_equal([], g:testlist[1 : -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002468
Bram Moolenaare0de1712020-12-02 17:36:54 +01002469 g:testdict = {a: 1, b: 2}
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002470 assert_equal(1, g:testdict['a'])
2471 assert_equal(2, g:testdict['b'])
2472 END
2473
2474 CheckDefSuccess(lines)
2475 CheckScriptSuccess(['vim9script'] + lines)
2476
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002477 CheckDefExecFailure(['echo g:testblob[2]'], 'E979:', 1)
2478 CheckScriptFailure(['vim9script', 'echo g:testblob[2]'], 'E979:', 2)
2479 CheckDefExecFailure(['echo g:testblob[-3]'], 'E979:', 1)
2480 CheckScriptFailure(['vim9script', 'echo g:testblob[-3]'], 'E979:', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002481
Bram Moolenaare7525c52021-01-09 13:20:37 +01002482 CheckDefExecFailure(['echo g:testlist[4]'], 'E684: list index out of range: 4', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002483 CheckScriptFailure(['vim9script', 'echo g:testlist[4]'], 'E684:', 2)
2484 CheckDefExecFailure(['echo g:testlist[-5]'], 'E684:', 1)
Bram Moolenaare7525c52021-01-09 13:20:37 +01002485 CheckScriptFailure(['vim9script', 'echo g:testlist[-5]'], 'E684: list index out of range: -5', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002486
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002487 CheckDefExecFailure(['echo g:testdict["a" : "b"]'], 'E719:', 1)
2488 CheckScriptFailure(['vim9script', 'echo g:testdict["a" : "b"]'], 'E719:', 2)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002489 CheckDefExecFailure(['echo g:testdict[1]'], 'E716:', 1)
2490 CheckScriptFailure(['vim9script', 'echo g:testdict[1]'], 'E716:', 2)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002491
2492 unlet g:teststring
2493 unlet g:testblob
2494 unlet g:testlist
Bram Moolenaar435d8972020-07-05 16:42:13 +02002495enddef
2496
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002497def Test_expr_member_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002498 var lines =<< trim END
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002499 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01002500 var d = {one:
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002501 'one',
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002502 two: 'two',
2503 1: 1,
2504 _: 2}
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002505 assert_equal('one', d.one)
2506 assert_equal('one', d
2507 .one)
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002508 assert_equal(1, d
2509 .1)
2510 assert_equal(2, d
2511 ._)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002512 assert_equal('one', d[
2513 'one'
2514 ])
2515 END
2516 CheckScriptSuccess(lines)
2517
2518 lines =<< trim END
2519 vim9script
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002520 var l = [1,
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002521 2,
2522 3, 4
2523 ]
2524 assert_equal(2, l[
2525 1
2526 ])
2527 assert_equal([2, 3], l[1 : 2])
2528 assert_equal([1, 2, 3], l[
2529 :
2530 2
2531 ])
2532 assert_equal([3, 4], l[
2533 2
2534 :
2535 ])
2536 END
2537 CheckScriptSuccess(lines)
2538enddef
2539
Bram Moolenaara79925a2021-01-05 17:50:28 +01002540def SetSomeVar()
2541 b:someVar = &fdm
2542enddef
2543
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002544def Test_expr7_option()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002545 # option
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002546 set ts=11
2547 assert_equal(11, &ts)
Bram Moolenaar401d9ff2020-02-19 18:14:44 +01002548 &ts = 9
2549 assert_equal(9, &ts)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002550 set ts=8
2551 set grepprg=some\ text
2552 assert_equal('some text', &grepprg)
Bram Moolenaar97a2af32020-01-28 22:52:48 +01002553 &grepprg = test_null_string()
2554 assert_equal('', &grepprg)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002555 set grepprg&
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01002556
2557 # check matching type
2558 var bval: bool = &tgc
2559 var nval: number = &ts
2560 var sval: string = &path
Bram Moolenaara79925a2021-01-05 17:50:28 +01002561
2562 # check v_lock is cleared (requires using valgrind, doesn't always show)
2563 SetSomeVar()
2564 b:someVar = 0
2565 unlet b:someVar
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002566enddef
2567
2568def Test_expr7_environment()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002569 # environment variable
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002570 assert_equal('testvar', $TESTVAR)
2571 assert_equal('', $ASDF_ASD_XXX)
Bram Moolenaarc58164c2020-03-29 18:40:30 +02002572
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002573 CheckDefFailure(["var x = $$$"], 'E1002:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002574enddef
2575
2576def Test_expr7_register()
Bram Moolenaar401d9ff2020-02-19 18:14:44 +01002577 @a = 'register a'
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002578 assert_equal('register a', @a)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002579
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002580 var fname = expand('%')
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002581 assert_equal(fname, @%)
2582
2583 feedkeys(":echo 'some'\<CR>", "xt")
2584 assert_equal("echo 'some'", @:)
2585
2586 normal axyz
2587 assert_equal("xyz", @.)
Bram Moolenaard2c61702020-09-06 15:58:36 +02002588 CheckDefFailure(["@. = 'yes'"], 'E354:', 1)
Bram Moolenaar65821722020-08-02 18:58:54 +02002589
2590 @/ = 'slash'
2591 assert_equal('slash', @/)
2592
2593 @= = 'equal'
2594 assert_equal('equal', @=)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002595enddef
2596
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002597def Test_expr7_namespace()
2598 g:some_var = 'some'
2599 assert_equal('some', get(g:, 'some_var'))
2600 assert_equal('some', get(g:, 'some_var', 'xxx'))
2601 assert_equal('xxx', get(g:, 'no_var', 'xxx'))
2602 unlet g:some_var
2603
2604 b:some_var = 'some'
2605 assert_equal('some', get(b:, 'some_var'))
2606 assert_equal('some', get(b:, 'some_var', 'xxx'))
2607 assert_equal('xxx', get(b:, 'no_var', 'xxx'))
2608 unlet b:some_var
2609
2610 w:some_var = 'some'
2611 assert_equal('some', get(w:, 'some_var'))
2612 assert_equal('some', get(w:, 'some_var', 'xxx'))
2613 assert_equal('xxx', get(w:, 'no_var', 'xxx'))
2614 unlet w:some_var
2615
2616 t:some_var = 'some'
2617 assert_equal('some', get(t:, 'some_var'))
2618 assert_equal('some', get(t:, 'some_var', 'xxx'))
2619 assert_equal('xxx', get(t:, 'no_var', 'xxx'))
2620 unlet t:some_var
Bram Moolenaar1bd3cb22021-02-24 12:27:31 +01002621
2622 # check using g: in a for loop more than DO_NOT_FREE_CNT times
2623 for i in range(100000)
2624 if has_key(g:, 'does-not-exist')
2625 endif
2626 endfor
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002627enddef
2628
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002629def Test_expr7_parens()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002630 # (expr)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002631 var lines =<< trim END
Bram Moolenaar24156692021-01-14 20:35:49 +01002632 assert_equal(4, (6 * 4) / 6)
2633 assert_equal(0, 6 * ( 4 / 6 ))
2634
2635 assert_equal(6, +6)
2636 assert_equal(-6, -6)
2637 assert_equal(false, !-3)
2638 assert_equal(true, !+0)
2639
2640 assert_equal(7, 5 + (
2641 2))
2642 assert_equal(7, 5 + (
2643 2
2644 ))
2645 assert_equal(7, 5 + ( # comment
2646 2))
2647 assert_equal(7, 5 + ( # comment
2648 # comment
2649 2))
2650
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002651 var s = (
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002652 'one'
2653 ..
2654 'two'
2655 )
2656 assert_equal('onetwo', s)
2657 END
Bram Moolenaar24156692021-01-14 20:35:49 +01002658 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002659enddef
2660
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002661def Test_expr7_negate_add()
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002662 assert_equal(-99, -99)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002663 assert_equal(-99, - 99)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002664 assert_equal(99, +99)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002665
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002666 var nr = 88
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002667 assert_equal(-88, -nr)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002668 assert_equal(-88, - nr)
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002669 assert_equal(88, + nr)
Bram Moolenaarb23279d2021-01-05 22:08:20 +01002670
2671 var lines =<< trim END
2672 var n = 12
2673 echo ++n
2674 END
2675 CheckDefAndScriptFailure(lines, 'E15:')
2676 lines =<< trim END
2677 var n = 12
2678 echo --n
2679 END
2680 CheckDefAndScriptFailure(lines, 'E15:')
2681 lines =<< trim END
2682 var n = 12
2683 echo +-n
2684 END
2685 CheckDefAndScriptFailure(lines, 'E15:')
2686 lines =<< trim END
2687 var n = 12
2688 echo -+n
2689 END
2690 CheckDefAndScriptFailure(lines, 'E15:')
2691 lines =<< trim END
2692 var n = 12
2693 echo - -n
2694 END
2695 CheckDefAndScriptFailure(lines, 'E15:')
2696 lines =<< trim END
2697 var n = 12
2698 echo + +n
2699 END
2700 CheckDefAndScriptFailure(lines, 'E15:')
2701
2702 lines =<< trim END
2703 var n = 12
2704 :1
2705 ++n
2706 END
2707 CheckDefAndScriptFailure(lines, 'E1050:')
2708 lines =<< trim END
2709 var n = 12
2710 :1
2711 --n
2712 END
2713 CheckDefAndScriptFailure(lines, 'E1050:')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002714enddef
2715
Bram Moolenaar6e949782020-04-13 17:21:00 +02002716def Echo(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002717 return arg
2718enddef
2719
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02002720def s:Echo4Arg(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002721 return arg
2722enddef
2723
2724def Test_expr7_call()
Bram Moolenaar659bb222020-11-12 20:16:39 +01002725 var lines =<< trim END
2726 assert_equal('yes', 'yes'->Echo())
2727 assert_equal(true, !range(5)->empty())
Bram Moolenaarb23279d2021-01-05 22:08:20 +01002728 assert_equal([0, 1, 2], 3->range())
Bram Moolenaar659bb222020-11-12 20:16:39 +01002729 END
2730 CheckDefAndScriptSuccess(lines)
2731
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002732 assert_equal('yes', 'yes'
Bram Moolenaar659bb222020-11-12 20:16:39 +01002733 ->s:Echo4Arg())
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002734
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002735 CheckDefFailure(["var x = 'yes'->Echo"], 'E107:', 1)
Bram Moolenaard2c61702020-09-06 15:58:36 +02002736 CheckScriptFailure([
2737 "vim9script",
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002738 "var x = substitute ('x', 'x', 'x', 'x')"
Bram Moolenaard2c61702020-09-06 15:58:36 +02002739 ], 'E121:', 2)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002740 CheckDefFailure(["var Ref = function('len' [1, 2])"], 'E1123:', 1)
Bram Moolenaara1773442020-08-12 15:21:22 +02002741
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002742 var auto_lines =<< trim END
Bram Moolenaara1773442020-08-12 15:21:22 +02002743 def g:some#func(): string
2744 return 'found'
2745 enddef
2746 END
2747 mkdir('Xruntime/autoload', 'p')
2748 writefile(auto_lines, 'Xruntime/autoload/some.vim')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002749 var save_rtp = &rtp
Bram Moolenaara1773442020-08-12 15:21:22 +02002750 &rtp = getcwd() .. '/Xruntime,' .. &rtp
2751 assert_equal('found', g:some#func())
2752 assert_equal('found', some#func())
2753
2754 &rtp = save_rtp
2755 delete('Xruntime', 'rf')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002756enddef
2757
Bram Moolenaar7e368202020-12-25 21:56:57 +01002758def Test_expr7_method_call()
2759 new
2760 setline(1, ['first', 'last'])
2761 'second'->append(1)
2762 "third"->append(2)
2763 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
2764 bwipe!
2765
2766 var bufnr = bufnr()
2767 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
2768 loclist->setloclist(0)
2769 assert_equal([{bufnr: bufnr,
2770 lnum: 42,
2771 col: 17,
2772 text: 'wrong',
2773 pattern: '',
2774 valid: 1,
2775 vcol: 0,
2776 nr: 0,
2777 type: '',
2778 module: ''}
2779 ], getloclist(0))
2780
2781 var result: bool = get({n: 0}, 'n', 0)
2782 assert_equal(false, result)
2783
2784 assert_equal('+string+', 'string'->((s) => '+' .. s .. '+')())
2785 assert_equal('-text-', 'text'->((s, c) => c .. s .. c)('-'))
2786
2787 var Join = (l) => join(l, 'x')
2788 assert_equal('axb', ['a', 'b']->(Join)())
2789enddef
2790
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002791
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002792def Test_expr7_not()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002793 var lines =<< trim END
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002794 assert_equal(true, !'')
2795 assert_equal(true, ![])
2796 assert_equal(false, !'asdf')
2797 assert_equal(false, ![2])
2798 assert_equal(true, !!'asdf')
2799 assert_equal(true, !![2])
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002800
Bram Moolenaar27491cd2020-10-15 21:54:56 +02002801 assert_equal(true, ! false)
2802 assert_equal(true, !! true)
2803 assert_equal(true, ! ! true)
2804 assert_equal(true, !!! false)
2805 assert_equal(true, ! ! ! false)
2806
2807 g:true = true
2808 g:false = false
2809 assert_equal(true, ! g:false)
2810 assert_equal(true, !! g:true)
2811 assert_equal(true, ! ! g:true)
2812 assert_equal(true, !!! g:false)
2813 assert_equal(true, ! ! ! g:false)
2814 unlet g:true
2815 unlet g:false
2816
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002817 assert_equal(true, !test_null_partial())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002818 assert_equal(false, !() => 'yes')
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002819
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002820 assert_equal(true, !test_null_dict())
2821 assert_equal(true, !{})
Bram Moolenaare0de1712020-12-02 17:36:54 +01002822 assert_equal(false, !{yes: 'no'})
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002823
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002824 if has('channel')
2825 assert_equal(true, !test_null_job())
2826 assert_equal(true, !test_null_channel())
2827 endif
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002828
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002829 assert_equal(true, !test_null_blob())
2830 assert_equal(true, !0z)
2831 assert_equal(false, !0z01)
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002832
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002833 assert_equal(true, !test_void())
2834 assert_equal(true, !test_unknown())
Bram Moolenaar59eccb92020-08-10 23:09:37 +02002835
2836 assert_equal(false, ![1, 2, 3]->reverse())
2837 assert_equal(true, ![]->reverse())
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002838 END
Bram Moolenaar27491cd2020-10-15 21:54:56 +02002839 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002840enddef
2841
2842func Test_expr7_fails()
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002843 call CheckDefFailure(["var x = (12"], "E1097:", 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002844
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002845 call CheckDefFailure(["var x = -'xx'"], "E1030:", 1)
2846 call CheckDefFailure(["var x = +'xx'"], "E1030:", 1)
2847 call CheckDefFailure(["var x = -0z12"], "E974:", 1)
2848 call CheckDefExecFailure(["var x = -[8]"], "E39:", 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002849 call CheckDefExecFailure(["var x = -{a: 1}"], "E39:", 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002850
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002851 call CheckDefFailure(["var x = @"], "E1002:", 1)
2852 call CheckDefFailure(["var x = @<"], "E354:", 1)
Bram Moolenaar58ceca52020-01-28 22:46:22 +01002853
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002854 call CheckDefFailure(["var x = [1, 2"], "E697:", 2)
2855 call CheckDefFailure(["var x = [notfound]"], "E1001:", 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01002856
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002857 call CheckDefFailure(["var X = () => 123)"], "E488:", 1)
2858 call CheckDefFailure(["var x = 123->((x) => x + 5)"], "E107:", 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01002859
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002860 call CheckDefFailure(["var x = &notexist"], 'E113:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002861 call CheckDefFailure(["&grepprg = [343]"], 'E1012:', 1)
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01002862
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002863 call CheckDefExecFailure(["echo s:doesnt_exist"], 'E121:', 1)
2864 call CheckDefExecFailure(["echo g:doesnt_exist"], 'E121:', 1)
Bram Moolenaar09f28f42020-02-20 23:08:34 +01002865
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002866 call CheckDefFailure(["echo a:somevar"], 'E1075:', 1)
2867 call CheckDefFailure(["echo l:somevar"], 'E1075:', 1)
2868 call CheckDefFailure(["echo x:somevar"], 'E1075:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002869
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002870 call CheckDefExecFailure(["var x = +g:astring"], 'E1030:', 1)
2871 call CheckDefExecFailure(["var x = +g:ablob"], 'E974:', 1)
2872 call CheckDefExecFailure(["var x = +g:alist"], 'E745:', 1)
2873 call CheckDefExecFailure(["var x = +g:adict"], 'E728:', 1)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01002874
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002875 call CheckDefFailure(["var x = ''", "var y = x.memb"], 'E715:', 2)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01002876
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002877 call CheckDefFailure(["'yes'->", "Echo()"], 'E488: Trailing characters: ->', 1)
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002878
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002879 call CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002880 call CheckDefExecFailure(["{a: 1->len()"], 'E723:', 2)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002881 call CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002882endfunc
2883
2884let g:Funcrefs = [function('add')]
2885
2886func CallMe(arg)
2887 return a:arg
2888endfunc
2889
Bram Moolenaar38a5f512020-02-19 12:40:39 +01002890func CallMe2(one, two)
2891 return a:one .. a:two
2892endfunc
2893
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002894def Test_expr7_trailing()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002895 # user function call
Bram Moolenaar4c17ad92020-04-27 22:47:51 +02002896 assert_equal(123, g:CallMe(123))
2897 assert_equal(123, g:CallMe( 123))
2898 assert_equal(123, g:CallMe(123 ))
2899 assert_equal('yesno', g:CallMe2('yes', 'no'))
2900 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
2901 assert_equal('nothing', g:CallMe('nothing'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002902
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002903 # partial call
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002904 var Part = function('g:CallMe')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002905 assert_equal('yes', Part('yes'))
2906
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002907 # funcref call, using list index
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002908 var l = []
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002909 g:Funcrefs[0](l, 2)
2910 assert_equal([2], l)
2911
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002912 # method call
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002913 l = [2, 5, 6]
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002914 l->map((k, v) => k + v)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002915 assert_equal([2, 6, 8], l)
2916
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002917 # lambda method call
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002918 l = [2, 5]
Bram Moolenaar057e84a2021-02-28 16:55:11 +01002919 l->((ll) => add(ll, 8))()
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002920 assert_equal([2, 5, 8], l)
2921
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002922 # dict member
Bram Moolenaare0de1712020-12-02 17:36:54 +01002923 var d = {key: 123}
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002924 assert_equal(123, d.key)
2925enddef
2926
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002927def Test_expr7_string_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002928 var lines =<< trim END
2929 var text = 'abcdef'
Bram Moolenaare7525c52021-01-09 13:20:37 +01002930 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002931 assert_equal('a', text[0])
2932 assert_equal('e', text[4])
2933 assert_equal('f', text[5])
2934 assert_equal('', text[6])
2935
Bram Moolenaare7525c52021-01-09 13:20:37 +01002936 text = 'ábçdë'
2937 assert_equal('ë', text[-1])
2938 assert_equal('d', text[-2])
2939 assert_equal('ç', text[-3])
2940 assert_equal('b', text[-4])
2941 assert_equal('á', text[-5])
2942 assert_equal('', text[-6])
2943
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002944 text = 'ábçdëf'
2945 assert_equal('', text[-999])
Bram Moolenaare7525c52021-01-09 13:20:37 +01002946 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002947 assert_equal('á', text[0])
2948 assert_equal('b', text[1])
2949 assert_equal('ç', text[2])
2950 assert_equal('d', text[3])
2951 assert_equal('ë', text[4])
2952 assert_equal('f', text[5])
2953 assert_equal('', text[6])
2954 assert_equal('', text[999])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002955
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002956 assert_equal('ábçdëf', text[0 : -1])
2957 assert_equal('ábçdëf', text[0 : -1])
2958 assert_equal('ábçdëf', text[0 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002959 assert_equal('ábçdëf', text[0 : -1])
2960 assert_equal('ábçdëf', text[0
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002961 : -1])
2962 assert_equal('ábçdëf', text[0 :
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002963 -1])
2964 assert_equal('ábçdëf', text[0 : -1
2965 ])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002966 assert_equal('bçdëf', text[1 : -1])
2967 assert_equal('çdëf', text[2 : -1])
2968 assert_equal('dëf', text[3 : -1])
2969 assert_equal('ëf', text[4 : -1])
2970 assert_equal('f', text[5 : -1])
2971 assert_equal('', text[6 : -1])
2972 assert_equal('', text[999 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002973
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002974 assert_equal('ábçd', text[: 3])
2975 assert_equal('bçdëf', text[1 :])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02002976 assert_equal('ábçdëf', text[:])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02002977 END
2978 CheckDefSuccess(lines)
2979 CheckScriptSuccess(['vim9script'] + lines)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002980
2981 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002982 var d = 'asdf'[1 :
Bram Moolenaar918a4242020-12-06 14:37:08 +01002983 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002984 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002985 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002986 var d = 'asdf'[1 : xxx]
Bram Moolenaar918a4242020-12-06 14:37:08 +01002987 END
2988 CheckDefFailure(lines, 'E1001:', 1)
2989 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002990 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01002991 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01002992 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002993 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002994 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01002995 echo d
2996 END
2997 CheckDefFailure(lines, 'E111:', 2)
2998 lines =<< trim END
2999 var d = 'asdf'['1']
3000 echo d
3001 END
3002 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
3003 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003004 var d = 'asdf'['1' : 2]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003005 echo d
3006 END
3007 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
3008 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003009 var d = 'asdf'[1 : '2']
Bram Moolenaar918a4242020-12-06 14:37:08 +01003010 echo d
3011 END
3012 CheckDefFailure(lines, 'E1012: Type mismatch; expected number but got string', 1)
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02003013enddef
3014
Bram Moolenaared591872020-08-15 22:14:53 +02003015def Test_expr7_list_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003016 var lines =<< trim END
3017 var list = [0, 1, 2, 3, 4]
Bram Moolenaared591872020-08-15 22:14:53 +02003018 assert_equal(0, list[0])
3019 assert_equal(4, list[4])
3020 assert_equal(4, list[-1])
3021 assert_equal(0, list[-5])
3022
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003023 assert_equal([0, 1, 2, 3, 4], list[0 : 4])
Bram Moolenaared591872020-08-15 22:14:53 +02003024 assert_equal([0, 1, 2, 3, 4], list[:])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003025 assert_equal([1, 2, 3, 4], list[1 :])
3026 assert_equal([2, 3, 4], list[2 : -1])
3027 assert_equal([4], list[4 : -1])
3028 assert_equal([], list[5 : -1])
3029 assert_equal([], list[999 : -1])
3030 assert_equal([1, 2, 3, 4], list[g:theone : g:thefour])
Bram Moolenaared591872020-08-15 22:14:53 +02003031
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003032 assert_equal([0, 1, 2, 3], list[0 : 3])
3033 assert_equal([0], list[0 : 0])
3034 assert_equal([0, 1, 2, 3, 4], list[0 : -1])
3035 assert_equal([0, 1, 2], list[0 : -3])
3036 assert_equal([0], list[0 : -5])
3037 assert_equal([], list[0 : -6])
3038 assert_equal([], list[0 : -99])
Bram Moolenaared591872020-08-15 22:14:53 +02003039 END
Bram Moolenaare7525c52021-01-09 13:20:37 +01003040 CheckDefAndScriptSuccess(lines)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003041
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003042 lines = ['var l = [0, 1, 2]', 'echo l[g:astring : g:theone]']
Bram Moolenaar5e654232020-09-16 15:22:00 +02003043 CheckDefExecFailure(lines, 'E1012:')
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003044 CheckScriptFailure(['vim9script'] + lines, 'E1030:', 3)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003045
3046 lines =<< trim END
3047 vim9script
3048 var ld = []
3049 def Func()
3050 eval ld[0].key
3051 enddef
3052 defcompile
3053 END
3054 CheckScriptSuccess(lines)
Bram Moolenaared591872020-08-15 22:14:53 +02003055enddef
3056
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003057def Test_expr7_dict_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003058 var lines =<< trim END
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003059 vim9script
Bram Moolenaare0de1712020-12-02 17:36:54 +01003060 var l = [{lnum: 2}, {lnum: 1}]
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003061 var res = l[0].lnum > l[1].lnum
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003062 assert_true(res)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003063
3064 var dd = {}
3065 def Func1()
3066 eval dd.key1.key2
3067 enddef
3068 def Func2()
3069 eval dd['key1'].key2
3070 enddef
3071 defcompile
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003072 END
3073 CheckScriptSuccess(lines)
3074enddef
3075
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003076def Test_expr7_subscript_linebreak()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003077 var range = range(
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003078 3)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003079 var l = range
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003080 ->mapnew('string(v:key)')
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003081 assert_equal(['0', '1', '2'], l)
3082
Bram Moolenaar23c55272020-06-21 16:58:13 +02003083 l = range
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003084 ->mapnew('string(v:key)')
Bram Moolenaar23c55272020-06-21 16:58:13 +02003085 assert_equal(['0', '1', '2'], l)
3086
3087 l = range # comment
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003088 ->mapnew('string(v:key)')
Bram Moolenaar23c55272020-06-21 16:58:13 +02003089 assert_equal(['0', '1', '2'], l)
3090
3091 l = range
3092
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003093 ->mapnew('string(v:key)')
Bram Moolenaar23c55272020-06-21 16:58:13 +02003094 assert_equal(['0', '1', '2'], l)
3095
3096 l = range
3097 # comment
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01003098 ->mapnew('string(v:key)')
Bram Moolenaar23c55272020-06-21 16:58:13 +02003099 assert_equal(['0', '1', '2'], l)
3100
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003101 assert_equal('1', l[
3102 1])
3103
Bram Moolenaare0de1712020-12-02 17:36:54 +01003104 var d = {one: 33}
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003105 assert_equal(33, d.
3106 one)
3107enddef
3108
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003109func Test_expr7_trailing_fails()
Bram Moolenaar057e84a2021-02-28 16:55:11 +01003110 call CheckDefFailure(['var l = [2]', 'l->((ll) => add(ll, 8))'], 'E107:', 2)
3111 call CheckDefFailure(['var l = [2]', 'l->((ll) => add(ll, 8)) ()'], 'E274:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003112endfunc
3113
3114func Test_expr_fails()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003115 call CheckDefFailure(["var x = '1'is2"], 'E488:', 1)
3116 call CheckDefFailure(["var x = '1'isnot2"], 'E488:', 1)
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003117
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003118 call CheckDefFailure(["CallMe ('yes')"], 'E476:', 1)
Bram Moolenaar7cb6fc22020-08-21 22:36:47 +02003119 call CheckScriptFailure(["CallMe ('yes')"], 'E492:', 1)
Bram Moolenaarba7c0d72020-09-09 18:54:42 +02003120 call CheckDefAndScriptFailure(["CallMe2('yes','no')"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003121 call CheckDefFailure(["CallMe2('yes' , 'no')"], 'E1068:', 1)
Bram Moolenaar0c2ca582020-02-25 22:58:29 +01003122
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003123 call CheckDefFailure(["v:nosuch += 3"], 'E1001:', 1)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003124 call CheckDefFailure(["var v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:', 1)
3125 call CheckDefFailure(["var asdf = v:nosuch"], 'E1001:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003126
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003127 call CheckDefFailure(["echo len('asdf'"], 'E110:', 2)
3128 call CheckDefFailure(["echo Func0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], 'E1011:', 1)
3129 call CheckDefFailure(["echo doesnotexist()"], 'E117:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003130endfunc
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02003131
3132" vim: shiftwidth=2 sts=2 expandtab