blob: dc6858fc78286cca2a29cc4aae840e4d9e76b217 [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 Moolenaar98309382020-09-27 21:58:45 +020075 var name = 1
Bram Moolenaar793648f2020-06-26 21:28:25 +020076 ? 'yes'
77 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020078 assert_equal('yes', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020079 END
Bram Moolenaar90193e62021-04-04 20:49:50 +020080 CheckDefAndScriptSuccess(lines)
Bram Moolenaar793648f2020-06-26 21:28:25 +020081
82 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +020083 var name = v:false
Bram Moolenaar793648f2020-06-26 21:28:25 +020084 ? 'yes'
85 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020086 assert_equal('no', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020087 END
Bram Moolenaar90193e62021-04-04 20:49:50 +020088 CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +020089
90 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +020091 var name = v:false ?
Bram Moolenaar9215f012020-06-27 21:18:00 +020092 'yes' :
93 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020094 assert_equal('no', name)
Bram Moolenaar9215f012020-06-27 21:18:00 +020095 END
Bram Moolenaar90193e62021-04-04 20:49:50 +020096 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +020097
Bram Moolenaar93be1642020-10-11 21:34:41 +020098 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +020099 var name = v:false ? # comment
100 'yes' :
101 # comment
102 'no' # comment
103 assert_equal('no', name)
104 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200105 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200106
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200107 # check white space
108 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200109 var name = v:true?1:2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200110 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200111 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''?'' at "?1:2"', 1)
112
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200113 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200114 var name = v:true? 1 : 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200115 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200116 CheckDefAndScriptFailure(lines, 'E1004:', 1)
117
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200118 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200119 var name = v:true ?1 : 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200120 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200121 CheckDefAndScriptFailure(lines, 'E1004:', 1)
122
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200123 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200124 var name = v:true ? 1: 2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200125 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200126 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after '':'' at ": 2"', 1)
127
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200128 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200129 var name = v:true ? 1 :2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200130 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200131 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar69e445522020-08-22 22:37:20 +0200132
Bram Moolenaar13106602020-10-04 16:06:05 +0200133 lines =<< trim END
Bram Moolenaar13106602020-10-04 16:06:05 +0200134 var name = 'x' ? 1 : 2
135 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200136 CheckDefAndScriptFailure(lines, 'E1135:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200137
138 lines =<< trim END
Bram Moolenaar13106602020-10-04 16:06:05 +0200139 var name = [] ? 1 : 2
140 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200141 CheckDefExecAndScriptFailure(lines, 'E745:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200142
143 lines =<< trim END
Bram Moolenaar13106602020-10-04 16:06:05 +0200144 var name = {} ? 1 : 2
145 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200146 CheckDefExecAndScriptFailure(lines, 'E728:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200147
Bram Moolenaar69e445522020-08-22 22:37:20 +0200148 # check after failure eval_flags is reset
149 lines =<< trim END
Bram Moolenaar69e445522020-08-22 22:37:20 +0200150 try
Bram Moolenaard2c61702020-09-06 15:58:36 +0200151 eval('0 ? 1: 2')
Bram Moolenaar69e445522020-08-22 22:37:20 +0200152 catch
153 endtry
154 assert_equal(v:true, eval(string(v:true)))
155 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200156 CheckDefAndScriptSuccess(lines)
Bram Moolenaar69e445522020-08-22 22:37:20 +0200157
158 lines =<< trim END
Bram Moolenaar69e445522020-08-22 22:37:20 +0200159 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
Bram Moolenaar90193e62021-04-04 20:49:50 +0200165 CheckDefAndScriptSuccess(lines)
Bram Moolenaar793648f2020-06-26 21:28:25 +0200166enddef
167
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200168func Test_expr1_trinary_fails()
Bram Moolenaar90193e62021-04-04 20:49:50 +0200169 call CheckDefAndScriptFailure(["var x = 1 ? 'one'"], "Missing ':' after '?'", 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100170
Bram Moolenaar77072282020-09-16 17:55:40 +0200171 let msg = "White space required before and after '?'"
Bram Moolenaar90193e62021-04-04 20:49:50 +0200172 call CheckDefAndScriptFailure(["var x = 1? 'one' : 'two'"], msg, 1)
173 call CheckDefAndScriptFailure(["var x = 1 ?'one' : 'two'"], msg, 1)
174 call CheckDefAndScriptFailure(["var x = 1?'one' : 'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200175 let lines =<< trim END
176 var x = 1
177 ?'one' : 'two'
178 # comment
179 END
180 call CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''?'' at "?''one'' : ''two''"', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100181
Bram Moolenaar77072282020-09-16 17:55:40 +0200182 let msg = "White space required before and after ':'"
Bram Moolenaar90193e62021-04-04 20:49:50 +0200183 call CheckDefAndScriptFailure(["var x = 1 ? 'one': 'two'"], msg, 1)
184 call CheckDefAndScriptFailure(["var x = 1 ? 'one' :'two'"], msg, 1)
185 call CheckDefAndScriptFailure(["var x = 1 ? 'one':'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200186 let lines =<< trim END
187 var x = 1 ? 'one'
188 :'two'
189 # Comment
190 END
191 call CheckDefAndScriptFailure(lines, 'E1004: White space required before and after '':'' at ":''two''"', 2)
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200192
Bram Moolenaar90193e62021-04-04 20:49:50 +0200193 call CheckDefAndScriptFailure(["var x = 'x' ? 'one' : 'two'"], 'E1135:', 1)
194 call CheckDefAndScriptFailure(["var x = 0z1234 ? 'one' : 'two'"], 'E974:', 1)
195 call CheckDefExecAndScriptFailure(["var x = [] ? 'one' : 'two'"], 'E745:', 1)
196 call CheckDefExecAndScriptFailure(["var x = {} ? 'one' : 'two'"], 'E728:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200197
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100198 call CheckDefExecFailure(["var x = false ? "], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200199 call CheckScriptFailure(['vim9script', "var x = false ? "], 'E15:', 2)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100200 call CheckDefExecFailure(["var x = false ? 'one' : "], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200201 call CheckScriptFailure(['vim9script', "var x = false ? 'one' : "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100202
Bram Moolenaar90193e62021-04-04 20:49:50 +0200203 call CheckDefExecAndScriptFailure2(["var x = true ? xxx : 'foo'"], 'E1001:', 'E121:', 1)
204 call CheckDefExecAndScriptFailure2(["var x = false ? 'foo' : xxx"], 'E1001:', 'E121:', 1)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100205
Bram Moolenaar13106602020-10-04 16:06:05 +0200206 if has('float')
Bram Moolenaar90193e62021-04-04 20:49:50 +0200207 call CheckDefAndScriptFailure(["var x = 0.1 ? 'one' : 'two'"], 'E805:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200208 endif
209
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200210 " missing argument detected even when common type is used
Bram Moolenaar90193e62021-04-04 20:49:50 +0200211 call CheckDefAndScriptFailure([
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200212 \ 'var X = FuncOne',
213 \ 'var Y = FuncTwo',
214 \ 'var Z = g:cond ? FuncOne : FuncTwo',
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200215 \ 'Z()'], 'E119:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100216endfunc
217
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200218def Test_expr1_falsy()
219 var lines =<< trim END
220 assert_equal(v:true, v:true ?? 456)
221 assert_equal(123, 123 ?? 456)
222 assert_equal('yes', 'yes' ?? 456)
223 assert_equal([1], [1] ?? 456)
Bram Moolenaare0de1712020-12-02 17:36:54 +0100224 assert_equal({one: 1}, {one: 1} ?? 456)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200225 if has('float')
226 assert_equal(0.1, 0.1 ?? 456)
227 endif
228
229 assert_equal(456, v:false ?? 456)
230 assert_equal(456, 0 ?? 456)
231 assert_equal(456, '' ?? 456)
232 assert_equal(456, [] ?? 456)
233 assert_equal(456, {} ?? 456)
234 if has('float')
235 assert_equal(456, 0.0 ?? 456)
236 endif
237 END
238 CheckDefAndScriptSuccess(lines)
239
240 var msg = "White space required before and after '??'"
Bram Moolenaar90193e62021-04-04 20:49:50 +0200241 call CheckDefAndScriptFailure(["var x = 1?? 'one' : 'two'"], msg, 1)
242 call CheckDefAndScriptFailure(["var x = 1 ??'one' : 'two'"], msg, 1)
243 call CheckDefAndScriptFailure(["var x = 1??'one' : 'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200244 lines =<< trim END
245 var x = 1
246 ??'one' : 'two'
247 #comment
248 END
249 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''??'' at "??''one'' : ''two''"', 2)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200250enddef
251
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100252def Record(val: any): any
253 g:vals->add(val)
254 return val
255enddef
256
257" test ||
258def Test_expr2()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100259 var lines =<< trim END
260 assert_equal(true, 1 || 0)
261 assert_equal(true, 0 ||
262 0 ||
263 1)
264 assert_equal(true, 0 ||
265 0 ||
266 !!7)
267 assert_equal(false, 0 || 0)
268 assert_equal(false, 0
269 || 0)
270 assert_equal(false, 0 || false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100271
Bram Moolenaar659bb222020-11-12 20:16:39 +0100272 g:vals = []
273 assert_equal(true, Record(1) || Record(3))
274 assert_equal([1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100275
Bram Moolenaar659bb222020-11-12 20:16:39 +0100276 g:vals = []
277 assert_equal(true, Record(0) || Record(1))
278 assert_equal([0, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100279
Bram Moolenaar659bb222020-11-12 20:16:39 +0100280 g:vals = []
281 assert_equal(true, Record(0) || Record(true))
282 assert_equal([0, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100283
Bram Moolenaar659bb222020-11-12 20:16:39 +0100284 g:vals = []
285 assert_equal(true, Record(0)
286 || Record(1)
287 || Record(0))
288 assert_equal([0, 1], g:vals)
289
290 g:vals = []
291 assert_equal(true, Record(0)
292 || Record(true)
293 || Record(0))
294 assert_equal([0, true], g:vals)
295
296 g:vals = []
297 assert_equal(true, Record(true) || Record(false))
298 assert_equal([true], g:vals)
299
300 g:vals = []
301 assert_equal(false, Record(0) || Record(false) || Record(0))
302 assert_equal([0, false, 0], g:vals)
Bram Moolenaaraf8ea0d2021-04-11 18:24:46 +0200303
304 g:vals = []
305 var x = 1
306 if x || true
307 g:vals = [1]
308 endif
309 assert_equal([1], g:vals)
310
311 g:vals = []
312 x = 3
313 if true || x
314 g:vals = [1]
315 endif
316 assert_equal([1], g:vals)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100317 END
318 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100319enddef
320
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200321def Test_expr2_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200322 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200323 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200324 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200325 || 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200326 assert_equal(true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200327 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200328 CheckDefAndScriptSuccess(lines)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200329
330 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200331 var name = v:false
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200332 || v:true
333 || v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200334 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200335 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200336 CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200337
338 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200339 var name = v:false ||
Bram Moolenaar9215f012020-06-27 21:18:00 +0200340 v:true ||
341 v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200342 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200343 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200344 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200345
Bram Moolenaar93be1642020-10-11 21:34:41 +0200346 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200347 var name = v:false || # comment
348 # comment
349 v:true ||
350 # comment
351 v:false # comment
352 assert_equal(v:true, name)
353 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200354 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200355
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200356 # check white space
357 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200358 var name = v:true||v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200359 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200360 CheckDefExecAndScriptFailure(lines, 'E1004: White space required before and after ''||'' at "||v:true"', 1)
361
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200362 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200363 var name = v:true ||v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200364 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200365 CheckDefAndScriptFailure(lines, 'E1004:', 1)
366
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200367 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200368 var name = v:true|| v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200369 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200370 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200371enddef
372
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200373def Test_expr2_fails()
374 var msg = "White space required before and after '||'"
Bram Moolenaar90193e62021-04-04 20:49:50 +0200375 call CheckDefAndScriptFailure(["var x = 1||2"], msg, 1)
376 call CheckDefAndScriptFailure(["var x = 1 ||2"], msg, 1)
377 call CheckDefAndScriptFailure(["var x = 1|| 2"], msg, 1)
Bram Moolenaara8c17702020-04-01 21:17:24 +0200378
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100379 call CheckDefFailure(["var x = false || "], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200380 call CheckScriptFailure(['vim9script', "var x = false || "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100381
Bram Moolenaar90193e62021-04-04 20:49:50 +0200382 # script does not fail, the second expression is skipped
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200383 call CheckDefFailure(["var x = 1 || xxx"], 'E1001:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200384
385 call CheckDefAndScriptFailure2(["var x = [] || false"], 'E1012:', 'E745:', 1)
386
387 call CheckDefAndScriptFailure2(["if 'yes' || 0", 'echo 0', 'endif'], 'E1012: Type mismatch; expected bool but got string', 'E1135: Using a String as a Bool', 1)
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200388
389 # TODO: should fail at compile time
Bram Moolenaar90193e62021-04-04 20:49:50 +0200390 call CheckDefExecAndScriptFailure(["var x = 3 || 7"], 'E1023:', 1)
391
Bram Moolenaaraf8ea0d2021-04-11 18:24:46 +0200392 call CheckDefAndScriptFailure(["if 3"], 'E1023:', 1)
393 call CheckDefExecAndScriptFailure(['var x = 3', 'if x', 'endif'], 'E1023:', 2)
394
Bram Moolenaar90193e62021-04-04 20:49:50 +0200395 call CheckDefAndScriptFailure2(["var x = [] || false"], 'E1012: Type mismatch; expected bool but got list<unknown>', 'E745:', 1)
396
mityu4ac198c2021-05-28 17:52:40 +0200397 var lines =<< trim END
398 vim9script
399 echo false
400 ||true
401 # comment
402 END
403 CheckScriptFailure(lines, 'E1004: White space required before and after ''||'' at "||true"', 3)
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200404enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100405
406" test &&
407def Test_expr3()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100408 var lines =<< trim END
409 assert_equal(false, 1 && 0)
410 assert_equal(false, 0 &&
411 0 &&
412 1)
413 assert_equal(true, 1
414 && true
415 && 1)
416 assert_equal(false, 0 && 0)
417 assert_equal(false, 0 && false)
418 assert_equal(true, 1 && true)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100419
Bram Moolenaar659bb222020-11-12 20:16:39 +0100420 g:vals = []
421 assert_equal(true, Record(true) && Record(1))
422 assert_equal([true, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100423
Bram Moolenaar659bb222020-11-12 20:16:39 +0100424 g:vals = []
425 assert_equal(true, Record(1) && Record(true))
426 assert_equal([1, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100427
Bram Moolenaar659bb222020-11-12 20:16:39 +0100428 g:vals = []
429 assert_equal(false, Record(0) && Record(1))
430 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100431
Bram Moolenaar659bb222020-11-12 20:16:39 +0100432 g:vals = []
433 assert_equal(false, Record(0) && Record(1) && Record(0))
434 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100435
Bram Moolenaar659bb222020-11-12 20:16:39 +0100436 g:vals = []
437 assert_equal(false, Record(0) && Record(4) && Record(0))
438 assert_equal([0], g:vals)
439
440 g:vals = []
441 assert_equal(false, Record(1) && Record(true) && Record(0))
442 assert_equal([1, true, 0], g:vals)
443 END
444 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100445enddef
446
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200447def Test_expr3_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200448 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200449 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200450 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200451 && 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200452 assert_equal(false, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200453 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200454 CheckDefAndScriptSuccess(lines)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200455
456 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200457 var name = v:true
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200458 && v:true
459 && v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200460 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200461 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200462 CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200463
464 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200465 var name = v:true &&
Bram Moolenaar9215f012020-06-27 21:18:00 +0200466 v:true &&
467 v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200468 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200469 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200470 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200471
Bram Moolenaar93be1642020-10-11 21:34:41 +0200472 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200473 var name = v:true && # comment
474 # comment
475 v:true &&
476 # comment
477 v:true
478 assert_equal(v:true, name)
479 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200480 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200481
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200482 # check white space
483 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200484 var name = v:true&&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200485 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200486 CheckDefAndScriptFailure(lines, 'E1004:', 1)
487
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200488 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200489 var name = v:true &&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200490 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200491 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''&&'' at "&&v:true"', 1)
492
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200493 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200494 var name = v:true&& v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200495 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200496 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200497enddef
498
Bram Moolenaara7511c02021-04-03 21:47:07 +0200499def Test_expr3_fails()
500 var msg = "White space required before and after '&&'"
Bram Moolenaar90193e62021-04-04 20:49:50 +0200501 CheckDefAndScriptFailure(["var x = 1&&2"], msg, 1)
502 CheckDefAndScriptFailure(["var x = 1 &&2"], msg, 1)
503 CheckDefAndScriptFailure(["var x = 1&& 2"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200504 var lines =<< trim END
505 var x = 1
506 &&2
507 # comment
508 END
509 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''&&'' at "&&2"', 2)
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100510
Bram Moolenaar90193e62021-04-04 20:49:50 +0200511 g:vals = []
512 CheckDefAndScriptFailure2(["if 'yes' && 0", 'echo 0', 'endif'], 'E1012: Type mismatch; expected bool but got string', 'E1135: Using a String as a Bool', 1)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100513
Bram Moolenaar90193e62021-04-04 20:49:50 +0200514 CheckDefExecAndScriptFailure(['assert_equal(false, Record(1) && Record(4) && Record(0))'], 'E1023: Using a Number as a Bool: 4', 1)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200515
mityu4ac198c2021-05-28 17:52:40 +0200516 lines =<< trim END
Bram Moolenaara7511c02021-04-03 21:47:07 +0200517 if 3
518 && true
519 endif
520 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200521 CheckDefExecAndScriptFailure(lines, 'E1023:', 1)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200522
523 lines =<< trim END
524 if 'yes'
525 && true
526 endif
527 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200528 CheckDefAndScriptFailure2(lines, 'E1012:', 'E1135: Using a String as a Bool', 1)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200529enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100530
Bram Moolenaar56acb092020-08-16 14:48:19 +0200531" global variables to use for tests with the "any" type
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100532let atrue = v:true
533let afalse = v:false
534let anone = v:none
535let anull = v:null
536let anint = 10
Bram Moolenaar56acb092020-08-16 14:48:19 +0200537let theone = 1
538let thefour = 4
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100539if has('float')
540 let afloat = 0.1
541endif
542let astring = 'asdf'
543let ablob = 0z01ab
544let alist = [2, 3, 4]
545let adict = #{aaa: 2, bbb: 8}
546
547" test == comperator
548def Test_expr4_equal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100549 var lines =<< trim END
550 var trueVar = true
551 var falseVar = false
552 assert_equal(true, true == true)
553 assert_equal(false, true ==
554 false)
555 assert_equal(true, true
556 == trueVar)
557 assert_equal(false, true == falseVar)
558 assert_equal(true, true == g:atrue)
559 assert_equal(false, g:atrue == false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100560
Bram Moolenaar659bb222020-11-12 20:16:39 +0100561 assert_equal(true, v:none == v:none)
562 assert_equal(false, v:none == v:null)
563 assert_equal(true, g:anone == v:none)
Bram Moolenaar67977822021-01-03 21:53:53 +0100564 assert_equal(true, null == v:null)
565 assert_equal(true, null == g:anull)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100566 assert_equal(false, v:none == g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100567
Bram Moolenaar659bb222020-11-12 20:16:39 +0100568 var nr0 = 0
569 var nr61 = 61
570 assert_equal(false, 2 == 0)
571 assert_equal(false, 2 == nr0)
572 assert_equal(true, 61 == 61)
573 assert_equal(true, 61 == nr61)
574 assert_equal(true, g:anint == 10)
575 assert_equal(false, 61 == g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100576
Bram Moolenaar659bb222020-11-12 20:16:39 +0100577 if has('float')
578 var ff = 0.3
579 assert_equal(true, ff == 0.3)
580 assert_equal(false, 0.4 == ff)
581 assert_equal(true, 0.1 == g:afloat)
582 assert_equal(false, g:afloat == 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100583
Bram Moolenaar659bb222020-11-12 20:16:39 +0100584 ff = 3.0
585 assert_equal(true, ff == 3)
586 assert_equal(true, 3 == ff)
587 ff = 3.1
588 assert_equal(false, ff == 3)
589 assert_equal(false, 3 == ff)
590 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100591
Bram Moolenaar659bb222020-11-12 20:16:39 +0100592 assert_equal(true, 'abc' == 'abc')
593 assert_equal(false, 'xyz' == 'abc')
594 assert_equal(true, g:astring == 'asdf')
595 assert_equal(false, 'xyz' == g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100596
Bram Moolenaar659bb222020-11-12 20:16:39 +0100597 assert_equal(false, 'abc' == 'aBc')
598 assert_equal(false, 'abc' ==# 'aBc')
599 assert_equal(true, 'abc' ==? 'aBc')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200600
Bram Moolenaar659bb222020-11-12 20:16:39 +0100601 assert_equal(false, 'abc' == 'ABC')
602 set ignorecase
603 assert_equal(false, 'abc' == 'ABC')
604 assert_equal(false, 'abc' ==# 'ABC')
605 assert_equal(true, 'abc' ==? 'ABC')
606 set noignorecase
607
608 var bb = 0z3f
609 assert_equal(true, 0z3f == bb)
610 assert_equal(false, bb == 0z4f)
611 assert_equal(true, g:ablob == 0z01ab)
612 assert_equal(false, 0z3f == g:ablob)
613
614 assert_equal(true, [1, 2, 3] == [1, 2, 3])
615 assert_equal(false, [1, 2, 3] == [2, 3, 1])
616 assert_equal(true, [2, 3, 4] == g:alist)
617 assert_equal(false, g:alist == [2, 3, 1])
618 assert_equal(false, [1, 2, 3] == [])
619 assert_equal(false, [1, 2, 3] == ['1', '2', '3'])
620
Bram Moolenaare0de1712020-12-02 17:36:54 +0100621 assert_equal(true, {one: 1, two: 2} == {one: 1, two: 2})
622 assert_equal(false, {one: 1, two: 2} == {one: 2, two: 2})
623 assert_equal(false, {one: 1, two: 2} == {two: 2})
624 assert_equal(false, {one: 1, two: 2} == {})
625 assert_equal(true, g:adict == {bbb: 8, aaa: 2})
626 assert_equal(false, {ccc: 9, aaa: 2} == g:adict)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100627
628 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal'))
629 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is'))
630
631 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123]))
632 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_is', [123]))
633 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [999]))
634
Bram Moolenaara065a142020-11-14 20:57:20 +0100635 # TODO: this unexpectedly sometimes fails on Appveyor
636 if !has('win32')
637 var OneFunc: func
638 var TwoFunc: func
639 OneFunc = function('len')
640 TwoFunc = function('len')
641 assert_equal(true, OneFunc('abc') == TwoFunc('123'))
642 endif
Bram Moolenaar659bb222020-11-12 20:16:39 +0100643 END
644 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100645
Bram Moolenaar90193e62021-04-04 20:49:50 +0200646 CheckDefAndScriptFailure2(["var x = 'a' == xxx"], 'E1001:', 'E121:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +0100647 CheckDefFailure(["var x = 'a' == "], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200648 CheckScriptFailure(['vim9script', "var x = 'a' == "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100649
Bram Moolenaar90193e62021-04-04 20:49:50 +0200650 CheckDefExecAndScriptFailure2(['var items: any', 'eval 1', 'eval 2', 'if items == []', 'endif'], 'E691:', 'E1072:', 4)
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100651
Bram Moolenaar90193e62021-04-04 20:49:50 +0200652 CheckDefExecAndScriptFailure(['var x: any = "a"', 'echo x == true'], 'E1072: Cannot compare string with bool', 2)
653 CheckDefExecAndScriptFailure(["var x: any = true", 'echo x == ""'], 'E1072: Cannot compare bool with string', 2)
654 CheckDefExecAndScriptFailure2(["var x: any = 99", 'echo x == true'], 'E1138', 'E1072:', 2)
655 CheckDefExecAndScriptFailure2(["var x: any = 'a'", 'echo x == 99'], 'E1030:', 'E1072:', 2)
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100656
657 for op in ['>', '>=', '<', '<=', '=~', '!~']
Bram Moolenaar90193e62021-04-04 20:49:50 +0200658 CheckDefExecAndScriptFailure([
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100659 "var a: any = 'a'",
660 'var b: any = true',
661 'echo a ' .. op .. ' b'], 'E1072:', 3)
662 endfor
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100663enddef
664
665" test != comperator
666def Test_expr4_notequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100667 var lines =<< trim END
668 var trueVar = true
669 var falseVar = false
670 assert_equal(false, true != true)
671 assert_equal(true, true !=
672 false)
673 assert_equal(false, true
674 != trueVar)
675 assert_equal(true, true != falseVar)
676 assert_equal(false, true != g:atrue)
677 assert_equal(true, g:atrue != false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100678
Bram Moolenaar659bb222020-11-12 20:16:39 +0100679 assert_equal(false, v:none != v:none)
680 assert_equal(true, v:none != v:null)
681 assert_equal(false, g:anone != v:none)
682 assert_equal(true, v:none != g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100683
Bram Moolenaar659bb222020-11-12 20:16:39 +0100684 var nr55 = 55
685 var nr0 = 55
686 assert_equal(true, 2 != 0)
687 assert_equal(true, 2 != nr0)
688 assert_equal(false, 55 != 55)
689 assert_equal(false, 55 != nr55)
690 assert_equal(false, g:anint != 10)
691 assert_equal(true, 61 != g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100692
Bram Moolenaar659bb222020-11-12 20:16:39 +0100693 if has('float')
694 var ff = 0.3
695 assert_equal(false, 0.3 != ff)
696 assert_equal(true, 0.4 != ff)
697 assert_equal(false, 0.1 != g:afloat)
698 assert_equal(true, g:afloat != 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100699
Bram Moolenaar659bb222020-11-12 20:16:39 +0100700 ff = 3.0
701 assert_equal(false, ff != 3)
702 assert_equal(false, 3 != ff)
703 ff = 3.1
704 assert_equal(true, ff != 3)
705 assert_equal(true, 3 != ff)
706 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100707
Bram Moolenaar659bb222020-11-12 20:16:39 +0100708 assert_equal(false, 'abc' != 'abc')
709 assert_equal(true, 'xyz' != 'abc')
710 assert_equal(false, g:astring != 'asdf')
711 assert_equal(true, 'xyz' != g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100712
Bram Moolenaar659bb222020-11-12 20:16:39 +0100713 assert_equal(true, 'abc' != 'ABC')
714 set ignorecase
715 assert_equal(true, 'abc' != 'ABC')
716 assert_equal(true, 'abc' !=# 'ABC')
717 assert_equal(false, 'abc' !=? 'ABC')
718 set noignorecase
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100719
Bram Moolenaar659bb222020-11-12 20:16:39 +0100720 var bb = 0z3f
721 assert_equal(false, 0z3f != bb)
722 assert_equal(true, bb != 0z4f)
723 assert_equal(false, g:ablob != 0z01ab)
724 assert_equal(true, 0z3f != g:ablob)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100725
Bram Moolenaar659bb222020-11-12 20:16:39 +0100726 assert_equal(false, [1, 2, 3] != [1, 2, 3])
727 assert_equal(true, [1, 2, 3] != [2, 3, 1])
728 assert_equal(false, [2, 3, 4] != g:alist)
729 assert_equal(true, g:alist != [2, 3, 1])
730 assert_equal(true, [1, 2, 3] != [])
731 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100732
Bram Moolenaare0de1712020-12-02 17:36:54 +0100733 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
734 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
735 assert_equal(true, {one: 1, two: 2} != {two: 2})
736 assert_equal(true, {one: 1, two: 2} != {})
737 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
738 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100739
Bram Moolenaar659bb222020-11-12 20:16:39 +0100740 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
741 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100742
Bram Moolenaar659bb222020-11-12 20:16:39 +0100743 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
744 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
745 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
746 END
747 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100748enddef
749
750" test > comperator
751def Test_expr4_greater()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100752 var lines =<< trim END
753 assert_true(2 > 0)
754 assert_true(2 >
755 1)
756 assert_false(2 > 2)
757 assert_false(2 > 3)
758 var nr2 = 2
759 assert_true(nr2 > 0)
760 assert_true(nr2 >
761 1)
762 assert_false(nr2 > 2)
763 assert_false(nr2
764 > 3)
765 if has('float')
766 var ff = 2.0
767 assert_true(ff > 0.0)
768 assert_true(ff > 1.0)
769 assert_false(ff > 2.0)
770 assert_false(ff > 3.0)
771 endif
772 END
773 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100774enddef
775
776" test >= comperator
777def Test_expr4_greaterequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100778 var lines =<< trim END
779 assert_true(2 >= 0)
780 assert_true(2 >=
781 2)
782 assert_false(2 >= 3)
783 var nr2 = 2
784 assert_true(nr2 >= 0)
785 assert_true(nr2 >= 2)
786 assert_false(nr2 >= 3)
787 if has('float')
788 var ff = 2.0
789 assert_true(ff >= 0.0)
790 assert_true(ff >= 2.0)
791 assert_false(ff >= 3.0)
792 endif
793 END
794 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100795enddef
796
797" test < comperator
798def Test_expr4_smaller()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100799 var lines =<< trim END
800 assert_false(2 < 0)
801 assert_false(2 <
802 2)
803 assert_true(2
804 < 3)
805 var nr2 = 2
806 assert_false(nr2 < 0)
807 assert_false(nr2 < 2)
808 assert_true(nr2 < 3)
809 if has('float')
810 var ff = 2.0
811 assert_false(ff < 0.0)
812 assert_false(ff < 2.0)
813 assert_true(ff < 3.0)
814 endif
815 END
816 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100817enddef
818
819" test <= comperator
820def Test_expr4_smallerequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100821 var lines =<< trim END
822 assert_false(2 <= 0)
823 assert_false(2 <=
824 1)
825 assert_true(2
826 <= 2)
827 assert_true(2 <= 3)
828 var nr2 = 2
829 assert_false(nr2 <= 0)
830 assert_false(nr2 <= 1)
831 assert_true(nr2 <= 2)
832 assert_true(nr2 <= 3)
833 if has('float')
834 var ff = 2.0
835 assert_false(ff <= 0.0)
836 assert_false(ff <= 1.0)
837 assert_true(ff <= 2.0)
838 assert_true(ff <= 3.0)
839 endif
840 END
841 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100842enddef
843
844" test =~ comperator
845def Test_expr4_match()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100846 var lines =<< trim END
847 assert_equal(false, '2' =~ '0')
848 assert_equal(false, ''
849 =~ '0')
850 assert_equal(true, '2' =~
851 '[0-9]')
852 set ignorecase
853 assert_equal(false, 'abc' =~ 'ABC')
854 assert_equal(false, 'abc' =~# 'ABC')
855 assert_equal(true, 'abc' =~? 'ABC')
856 set noignorecase
857 END
858 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100859enddef
860
861" test !~ comperator
862def Test_expr4_nomatch()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100863 var lines =<< trim END
864 assert_equal(true, '2' !~ '0')
865 assert_equal(true, ''
866 !~ '0')
867 assert_equal(false, '2' !~
868 '[0-9]')
869 END
870 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100871enddef
872
873" test is comperator
874def Test_expr4_is()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100875 var lines =<< trim END
876 var mylist = [2]
877 assert_false(mylist is [2])
878 var other = mylist
879 assert_true(mylist is
880 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100881
Bram Moolenaar659bb222020-11-12 20:16:39 +0100882 var myblob = 0z1234
883 assert_false(myblob
884 is 0z1234)
885 var otherblob = myblob
886 assert_true(myblob is otherblob)
887 END
888 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100889enddef
890
891" test isnot comperator
892def Test_expr4_isnot()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100893 var lines =<< trim END
894 var mylist = [2]
895 assert_true('2' isnot '0')
896 assert_true(mylist isnot [2])
897 var other = mylist
898 assert_false(mylist isnot
899 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100900
Bram Moolenaar659bb222020-11-12 20:16:39 +0100901 var myblob = 0z1234
902 assert_true(myblob
903 isnot 0z1234)
904 var otherblob = myblob
905 assert_false(myblob isnot otherblob)
906 END
907 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100908enddef
909
910def RetVoid()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200911 var x = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100912enddef
913
Bram Moolenaar8294d492020-08-10 22:40:56 +0200914def Test_expr4_vim9script()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200915 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200916 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200917 var name = 0
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200918 < 1
Bram Moolenaar98309382020-09-27 21:58:45 +0200919 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200920 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200921 CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200922
923 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200924 var name = 123
Bram Moolenaar93be1642020-10-11 21:34:41 +0200925 # comment
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200926 != 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200927 assert_equal(false, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200928 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200929 CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200930
931 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200932 var name = 123 ==
Bram Moolenaar9215f012020-06-27 21:18:00 +0200933 123
Bram Moolenaar98309382020-09-27 21:58:45 +0200934 assert_equal(true, name)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200935 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200936 CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200937
938 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200939 var list = [1, 2, 3]
940 var name = list
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200941 is list
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200942 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200943 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200944 CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200945
946 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200947 var list = [1, 2, 3]
948 var name = list # comment
949 # comment
950 is list
951 assert_equal(true, name)
952 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200953 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200954
955 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200956 var myblob = 0z1234
957 var name = myblob
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200958 isnot 0z11
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200959 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200960 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200961 CheckDefAndScriptSuccess(lines)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200962
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200963 # spot check mismatching types
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200964 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200965 echo '' == 0
966 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200967 CheckDefAndScriptFailure(lines, 'E1072:', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200968
969 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200970 echo v:true > v:false
971 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200972 CheckDefAndScriptFailure(lines, 'Cannot compare bool with bool', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200973
974 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +0200975 echo 123 is 123
976 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200977 CheckDefAndScriptFailure(lines, 'Cannot use "is" with number', 1)
Bram Moolenaarc71f36a2020-07-21 21:31:00 +0200978
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200979 # check missing white space
980 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200981 echo 2>3
982 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200983 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''>'' at ">3"', 1)
984
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200985 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200986 echo 2 >3
987 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200988 CheckDefAndScriptFailure(lines, 'E1004:', 1)
989
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200990 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200991 echo 2> 3
992 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200993 CheckDefAndScriptFailure(lines, 'E1004:', 1)
994
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200995 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +0200996 echo 2!=3
997 END
Bram Moolenaar90193e62021-04-04 20:49:50 +0200998 CheckDefAndScriptFailure(lines, 'E1004:', 1)
999
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001000 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001001 echo 2 !=3
1002 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001003 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''!='' at "!=3"', 1)
1004
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001005 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001006 echo 2!= 3
1007 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001008 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar8294d492020-08-10 22:40:56 +02001009
mityu4ac198c2021-05-28 17:52:40 +02001010 for op in ['==', '>', '>=', '<', '<=', '=~', '!~', 'is', 'isnot']
1011 lines = ["echo 'aaa'", op .. "'bbb'", '# comment']
1012 var msg = printf("E1004: White space required before and after '%s'", op)
1013 CheckDefAndScriptFailure(lines, msg, 2)
1014 endfor
1015
Bram Moolenaar8294d492020-08-10 22:40:56 +02001016 lines =<< trim END
Bram Moolenaar8294d492020-08-10 22:40:56 +02001017 echo len('xxx') == 3
1018 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001019 CheckDefAndScriptSuccess(lines)
Bram Moolenaarf9235712020-08-16 18:42:53 +02001020
1021 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001022 var line = 'abc'
Bram Moolenaarf9235712020-08-16 18:42:53 +02001023 echo line[1] =~ '\w'
1024 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001025 CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001026enddef
1027
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001028func Test_expr4_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001029 let msg = "White space required before and after '>'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001030 call CheckDefAndScriptFailure(["var x = 1>2"], msg, 1)
1031 call CheckDefAndScriptFailure(["var x = 1 >2"], msg, 1)
1032 call CheckDefAndScriptFailure(["var x = 1> 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001033
Bram Moolenaar77072282020-09-16 17:55:40 +02001034 let msg = "White space required before and after '=='"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001035 call CheckDefAndScriptFailure(["var x = 1==2"], msg, 1)
1036 call CheckDefAndScriptFailure(["var x = 1 ==2"], msg, 1)
1037 call CheckDefAndScriptFailure(["var x = 1== 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001038
Bram Moolenaar77072282020-09-16 17:55:40 +02001039 let msg = "White space required before and after 'is'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001040 call CheckDefAndScriptFailure(["var x = '1'is'2'"], msg, 1)
1041 call CheckDefAndScriptFailure(["var x = '1' is'2'"], msg, 1)
1042 call CheckDefAndScriptFailure(["var x = '1'is '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001043
Bram Moolenaar77072282020-09-16 17:55:40 +02001044 let msg = "White space required before and after 'isnot'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001045 call CheckDefAndScriptFailure(["var x = '1'isnot'2'"], msg, 1)
1046 call CheckDefAndScriptFailure(["var x = '1' isnot'2'"], msg, 1)
1047 call CheckDefAndScriptFailure(["var x = '1'isnot '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001048
Bram Moolenaar90193e62021-04-04 20:49:50 +02001049 call CheckDefAndScriptFailure(["var x = 1 is# 2"], 'E15:', 1)
1050 call CheckDefAndScriptFailure(["var x = 1 is? 2"], 'E15:', 1)
1051 call CheckDefAndScriptFailure(["var x = 1 isnot# 2"], 'E15:', 1)
1052 call CheckDefAndScriptFailure(["var x = 1 isnot? 2"], 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001053
Bram Moolenaar90193e62021-04-04 20:49:50 +02001054 call CheckDefAndScriptFailure(["var x = 1 == '2'"], 'Cannot compare number with string', 1)
1055 call CheckDefAndScriptFailure(["var x = '1' == 2"], 'Cannot compare string with number', 1)
1056 call CheckDefAndScriptFailure(["var x = 1 == RetVoid()"], 'Cannot compare number with void', 1)
1057 call CheckDefAndScriptFailure(["var x = RetVoid() == 1"], 'Cannot compare void with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001058
Bram Moolenaar90193e62021-04-04 20:49:50 +02001059 call CheckDefAndScriptFailure(["var x = true > false"], 'Cannot compare bool with bool', 1)
1060 call CheckDefAndScriptFailure(["var x = true >= false"], 'Cannot compare bool with bool', 1)
1061 call CheckDefAndScriptFailure(["var x = true < false"], 'Cannot compare bool with bool', 1)
1062 call CheckDefAndScriptFailure(["var x = true <= false"], 'Cannot compare bool with bool', 1)
1063 call CheckDefAndScriptFailure(["var x = true =~ false"], 'Cannot compare bool with bool', 1)
1064 call CheckDefAndScriptFailure(["var x = true !~ false"], 'Cannot compare bool with bool', 1)
1065 call CheckDefAndScriptFailure(["var x = true is false"], 'Cannot use "is" with bool', 1)
1066 call CheckDefAndScriptFailure(["var x = true isnot false"], 'Cannot use "isnot" with bool', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001067
Bram Moolenaar90193e62021-04-04 20:49:50 +02001068 call CheckDefAndScriptFailure(["var x = v:none is v:null"], 'Cannot use "is" with special', 1)
1069 call CheckDefAndScriptFailure(["var x = v:none isnot v:null"], 'Cannot use "isnot" with special', 1)
1070 call CheckDefAndScriptFailure(["var x = 123 is 123"], 'Cannot use "is" with number', 1)
1071 call CheckDefAndScriptFailure(["var x = 123 isnot 123"], 'Cannot use "isnot" with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001072 if has('float')
Bram Moolenaar90193e62021-04-04 20:49:50 +02001073 call CheckDefAndScriptFailure(["var x = 1.3 is 1.3"], 'Cannot use "is" with float', 1)
1074 call CheckDefAndScriptFailure(["var x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001075 endif
1076
Bram Moolenaar90193e62021-04-04 20:49:50 +02001077 call CheckDefAndScriptFailure(["var x = 0za1 > 0z34"], 'Cannot compare blob with blob', 1)
1078 call CheckDefAndScriptFailure(["var x = 0za1 >= 0z34"], 'Cannot compare blob with blob', 1)
1079 call CheckDefAndScriptFailure(["var x = 0za1 < 0z34"], 'Cannot compare blob with blob', 1)
1080 call CheckDefAndScriptFailure(["var x = 0za1 <= 0z34"], 'Cannot compare blob with blob', 1)
1081 call CheckDefAndScriptFailure(["var x = 0za1 =~ 0z34"], 'Cannot compare blob with blob', 1)
1082 call CheckDefAndScriptFailure(["var x = 0za1 !~ 0z34"], 'Cannot compare blob with blob', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001083
Bram Moolenaar90193e62021-04-04 20:49:50 +02001084 call CheckDefAndScriptFailure(["var x = [13] > [88]"], 'Cannot compare list with list', 1)
1085 call CheckDefAndScriptFailure(["var x = [13] >= [88]"], 'Cannot compare list with list', 1)
1086 call CheckDefAndScriptFailure(["var x = [13] < [88]"], 'Cannot compare list with list', 1)
1087 call CheckDefAndScriptFailure(["var x = [13] <= [88]"], 'Cannot compare list with list', 1)
1088 call CheckDefAndScriptFailure(["var x = [13] =~ [88]"], 'Cannot compare list with list', 1)
1089 call CheckDefAndScriptFailure(["var x = [13] !~ [88]"], 'Cannot compare list with list', 1)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001090
Bram Moolenaar90193e62021-04-04 20:49:50 +02001091 call CheckDefAndScriptFailure(['var j: job', 'var chan: channel', 'var r = j == chan'], 'Cannot compare job with channel', 3)
1092 call CheckDefAndScriptFailure(['var j: job', 'var x: list<any>', 'var r = j == x'], 'Cannot compare job with list', 3)
1093 call CheckDefAndScriptFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
1094 call CheckDefAndScriptFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001095endfunc
1096
1097" test addition, subtraction, concatenation
1098def Test_expr5()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001099 var lines =<< trim END
1100 assert_equal(66, 60 + 6)
1101 assert_equal(70, 60 +
1102 g:anint)
1103 assert_equal(9, g:thefour
1104 + 5)
1105 assert_equal(14, g:thefour + g:anint)
1106 assert_equal([1, 2, 3, 4], [1] + g:alist)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001107
Bram Moolenaar659bb222020-11-12 20:16:39 +01001108 assert_equal(54, 60 - 6)
1109 assert_equal(50, 60 -
1110 g:anint)
1111 assert_equal(-1, g:thefour
1112 - 5)
1113 assert_equal(-6, g:thefour - g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001114
Bram Moolenaar659bb222020-11-12 20:16:39 +01001115 assert_equal('hello', 'hel' .. 'lo')
1116 assert_equal('hello 123', 'hello ' ..
1117 123)
1118 assert_equal('hello 123', 'hello '
1119 .. 123)
1120 assert_equal('123 hello', 123 .. ' hello')
1121 assert_equal('123456', 123 .. 456)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001122
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001123 assert_equal('atrue', 'a' .. true)
1124 assert_equal('afalse', 'a' .. false)
Bram Moolenaar67977822021-01-03 21:53:53 +01001125 assert_equal('anull', 'a' .. v:null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001126 assert_equal('av:none', 'a' .. v:none)
1127 if has('float')
1128 assert_equal('a0.123', 'a' .. 0.123)
1129 endif
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001130
Bram Moolenaare507ff12021-01-31 21:47:42 +01001131 assert_equal(3, 1 + [2, 3, 4][0])
1132 assert_equal(5, 2 + {key: 3}['key'])
1133
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001134 set digraph
1135 assert_equal('val: true', 'val: ' .. &digraph)
1136 set nodigraph
1137 assert_equal('val: false', 'val: ' .. &digraph)
1138
Bram Moolenaar659bb222020-11-12 20:16:39 +01001139 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
1140 assert_equal(0z11223344, 0z1122 + 0z3344)
1141 assert_equal(0z112201ab, 0z1122
1142 + g:ablob)
1143 assert_equal(0z01ab3344, g:ablob + 0z3344)
1144 assert_equal(0z01ab01ab, g:ablob + g:ablob)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001145
Bram Moolenaar659bb222020-11-12 20:16:39 +01001146 # concatenate non-constant to constant
1147 var save_path = &path
1148 &path = 'b'
1149 assert_equal('ab', 'a' .. &path)
1150 &path = save_path
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001151
Bram Moolenaar659bb222020-11-12 20:16:39 +01001152 @b = 'b'
1153 assert_equal('ab', 'a' .. @b)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001154
Bram Moolenaar659bb222020-11-12 20:16:39 +01001155 $ENVVAR = 'env'
1156 assert_equal('aenv', 'a' .. $ENVVAR)
Bram Moolenaard62d87d2021-01-04 17:40:12 +01001157
1158 assert_equal('val', '' .. {key: 'val'}['key'])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001159 END
1160 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001161enddef
1162
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001163def Test_expr5_vim9script()
Bram Moolenaar696ba232020-07-29 21:20:41 +02001164 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001165 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001166 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001167 + 77
1168 - 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001169 assert_equal(66, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001170 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001171 CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001172
1173 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001174 var name = 11 +
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001175 77 -
1176 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001177 assert_equal(66, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001178 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001179 CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001180
1181 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001182 var name = 11 + # comment
1183 77 -
1184 # comment
1185 22
1186 assert_equal(66, name)
1187 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001188 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001189
1190 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001191 var name = 'one'
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001192 .. 'two'
Bram Moolenaar98309382020-09-27 21:58:45 +02001193 assert_equal('onetwo', name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001194 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001195 CheckDefAndScriptSuccess(lines)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001196
1197 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001198 echo 'abc' is# 'abc'
1199 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001200 CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001201
1202 lines =<< trim END
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001203 echo {} - 22
1204 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001205 CheckDefAndScriptFailure2(lines, 'E1036:', 'E728:', 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001206
1207 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001208 echo [] - 33
1209 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001210 CheckDefAndScriptFailure2(lines, 'E1036:', 'E745:', 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001211
1212 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001213 echo 0z1234 - 44
1214 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001215 CheckDefAndScriptFailure2(lines, 'E1036', 'E974:', 1)
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001216
1217 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001218 echo 'abc' is? 'abc'
1219 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001220 CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001221
1222 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001223 echo 'abc' isnot# 'abc'
1224 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001225 CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001226
1227 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001228 echo 'abc' isnot? 'abc'
1229 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001230 CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001231
1232 # check white space
1233 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001234 echo 5+6
1235 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001236 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001237 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001238 echo 5 +6
1239 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001240 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001241
1242 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001243 echo 5+ 6
1244 END
1245 CheckDefAndScriptFailure(lines, 'E1004:', 1)
1246
1247 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001248 echo 'a'..'b'
1249 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001250 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 1)
1251
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001252 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001253 echo 'a' ..'b'
1254 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001255 CheckDefAndScriptFailure(lines, 'E1004:', 1)
1256
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001257 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001258 echo 'a'.. 'b'
1259 END
mityu89dcb4d2021-05-28 13:50:17 +02001260 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at ".. ''b''"', 1)
1261
1262 lines =<< trim END
1263 echo 'a'
1264 ..'b'
1265 # comment
1266 END
1267 CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001268
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001269 # check invalid string concatenation
1270 lines =<< trim END
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001271 echo 'a' .. [1]
1272 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001273 CheckDefAndScriptFailure2(lines, 'E1105:', 'E730:', 1)
Bram Moolenaara9749532021-03-06 18:18:19 +01001274
1275 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001276 echo 'a' .. {a: 1}
1277 END
1278 CheckDefAndScriptFailure2(lines, 'E1105:', 'E731:', 1)
1279
1280 lines =<< trim END
1281 echo 'a' .. test_void()
1282 END
1283 CheckDefAndScriptFailure2(lines, 'E1105:', 'E908:', 1)
1284
1285 lines =<< trim END
1286 echo 'a' .. 0z33
1287 END
1288 CheckDefAndScriptFailure2(lines, 'E1105:', 'E976:', 1)
1289
1290 lines =<< trim END
1291 echo 'a' .. function('len')
1292 END
1293 CheckDefAndScriptFailure2(lines, 'E1105:', 'E729:', 1)
1294
1295 lines =<< trim END
Bram Moolenaara9749532021-03-06 18:18:19 +01001296 new
1297 ['']->setline(1)
1298 /pattern
1299
1300 eval 0
1301 bwipe!
1302 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001303 CheckDefAndScriptFailure(lines, "E1004: White space required before and after '/' at \"/pattern", 3)
mityu4ac198c2021-05-28 17:52:40 +02001304
1305 for op in ['+', '-']
1306 lines = ['var x = 1', op .. '2', '# comment']
1307 var msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
1308 CheckDefAndScriptFailure(lines, msg, 2)
1309 endfor
Bram Moolenaar79182382020-09-05 20:06:33 +02001310enddef
1311
1312def Test_expr5_vim9script_channel()
1313 if !has('channel')
1314 MissingFeature 'float'
1315 else
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001316 var lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001317 echo 'a' .. test_null_job()
1318 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001319 CheckDefAndScriptFailure2(lines, 'E1105:', 'E908:', 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001320 lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001321 echo 'a' .. test_null_channel()
1322 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001323 CheckDefAndScriptFailure2(lines, 'E1105:', 'E908:', 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001324 endif
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001325enddef
1326
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001327def Test_expr5_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001328 if !has('float')
1329 MissingFeature 'float'
1330 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001331 var lines =<< trim END
1332 assert_equal(66.0, 60.0 + 6.0)
1333 assert_equal(66.0, 60.0 + 6)
1334 assert_equal(66.0, 60 +
1335 6.0)
1336 assert_equal(5.1, g:afloat
1337 + 5)
1338 assert_equal(8.1, 8 + g:afloat)
1339 assert_equal(10.1, g:anint + g:afloat)
1340 assert_equal(10.1, g:afloat + g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001341
Bram Moolenaar659bb222020-11-12 20:16:39 +01001342 assert_equal(54.0, 60.0 - 6.0)
1343 assert_equal(54.0, 60.0
1344 - 6)
1345 assert_equal(54.0, 60 - 6.0)
1346 assert_equal(-4.9, g:afloat - 5)
1347 assert_equal(7.9, 8 - g:afloat)
1348 assert_equal(9.9, g:anint - g:afloat)
1349 assert_equal(-9.9, g:afloat - g:anint)
1350 END
1351 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001352 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001353enddef
1354
1355func Test_expr5_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001356 let msg = "White space required before and after '+'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001357 call CheckDefAndScriptFailure(["var x = 1+2"], msg, 1)
1358 call CheckDefAndScriptFailure(["var x = 1 +2"], msg, 1)
1359 call CheckDefAndScriptFailure(["var x = 1+ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001360
Bram Moolenaar77072282020-09-16 17:55:40 +02001361 let msg = "White space required before and after '-'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001362 call CheckDefAndScriptFailure(["var x = 1-2"], msg, 1)
1363 call CheckDefAndScriptFailure(["var x = 1 -2"], msg, 1)
1364 call CheckDefAndScriptFailure(["var x = 1- 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001365
Bram Moolenaar77072282020-09-16 17:55:40 +02001366 let msg = "White space required before and after '..'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001367 call CheckDefAndScriptFailure(["var x = '1'..'2'"], msg, 1)
1368 call CheckDefAndScriptFailure(["var x = '1' ..'2'"], msg, 1)
1369 call CheckDefAndScriptFailure(["var x = '1'.. '2'"], msg, 1)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001370
Bram Moolenaar90193e62021-04-04 20:49:50 +02001371 call CheckDefAndScriptFailure2(["var x = 0z1122 + 33"], 'E1051:', 'E974:', 1)
1372 call CheckDefAndScriptFailure2(["var x = 0z1122 + [3]"], 'E1051:', 'E974:', 1)
1373 call CheckDefAndScriptFailure2(["var x = 0z1122 + 'asd'"], 'E1051:', 'E974:', 1)
1374 call CheckDefAndScriptFailure2(["var x = 33 + 0z1122"], 'E1051:', 'E974:', 1)
1375 call CheckDefAndScriptFailure2(["var x = [3] + 0z1122"], 'E1051:', 'E745:', 1)
1376 call CheckDefAndScriptFailure2(["var x = 'asdf' + 0z1122"], 'E1051:', 'E1030:', 1)
1377 call CheckDefAndScriptFailure2(["var x = 6 + xxx"], 'E1001:', 'E121:', 1)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001378
Bram Moolenaar90193e62021-04-04 20:49:50 +02001379 call CheckDefAndScriptFailure2(["var x = 'a' .. [1]"], 'E1105:', 'E730:', 1)
1380 call CheckDefAndScriptFailure2(["var x = 'a' .. {a: 1}"], 'E1105:', 'E731:', 1)
1381 call CheckDefAndScriptFailure2(["var x = 'a' .. test_void()"], 'E1105:', 'E908:', 1)
1382 call CheckDefAndScriptFailure2(["var x = 'a' .. 0z32"], 'E1105:', 'E976:', 1)
1383 call CheckDefAndScriptFailure2(["var x = 'a' .. function('len')"], 'E1105:', 'E729:', 1)
1384 call CheckDefAndScriptFailure2(["var x = 'a' .. function('len', ['a'])"], 'E1105:', 'E729:', 1)
Bram Moolenaard92cc132020-11-18 17:17:15 +01001385
Bram Moolenaar90193e62021-04-04 20:49:50 +02001386 call CheckDefAndScriptFailure2(['var x = 1 + v:none'], 'E1051:', 'E611:', 1)
1387 call CheckDefAndScriptFailure2(['var x = 1 + v:null'], 'E1051:', 'E611:', 1)
1388 call CheckDefAndScriptFailure2(['var x = 1 + v:true'], 'E1051:', 'E1138:', 1)
1389 call CheckDefAndScriptFailure2(['var x = 1 + v:false'], 'E1051:', 'E1138:', 1)
1390 call CheckDefAndScriptFailure2(['var x = 1 + true'], 'E1051:', 'E1138:', 1)
1391 call CheckDefAndScriptFailure2(['var x = 1 + false'], 'E1051:', 'E1138:', 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001392endfunc
1393
1394func Test_expr5_fails_channel()
1395 CheckFeature channel
Bram Moolenaar90193e62021-04-04 20:49:50 +02001396 call CheckDefAndScriptFailure2(["var x = 'a' .. test_null_job()"], 'E1105:', 'E908:', 1)
1397 call CheckDefAndScriptFailure2(["var x = 'a' .. test_null_channel()"], 'E1105:', 'E908:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001398endfunc
1399
Bram Moolenaar399ea812020-12-15 21:28:57 +01001400def Test_expr5_list_add()
Bram Moolenaar90193e62021-04-04 20:49:50 +02001401 var lines =<< trim END
1402 # concatenating two lists with same member types is OK
1403 var d = {}
1404 for i in ['a'] + ['b']
1405 d = {[i]: 0}
1406 endfor
Bram Moolenaar399ea812020-12-15 21:28:57 +01001407
Bram Moolenaar90193e62021-04-04 20:49:50 +02001408 # concatenating two lists with different member types results in "any"
1409 var dany = {}
1410 for i in ['a'] + [12]
1411 dany[i] = i
1412 endfor
1413 assert_equal({a: 'a', 12: 12}, dany)
Bram Moolenaard345fb92021-03-10 18:43:09 +01001414
Bram Moolenaar90193e62021-04-04 20:49:50 +02001415 # result of glob() is "any", runtime type check
1416 var sl: list<string> = glob('*.txt', false, true) + ['']
1417 END
1418 CheckDefAndScriptSuccess(lines)
Bram Moolenaar399ea812020-12-15 21:28:57 +01001419enddef
1420
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001421" test multiply, divide, modulo
1422def Test_expr6()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001423 var lines =<< trim END
1424 assert_equal(36, 6 * 6)
1425 assert_equal(24, 6 *
1426 g:thefour)
1427 assert_equal(24, g:thefour
1428 * 6)
1429 assert_equal(40, g:anint * g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001430
Bram Moolenaar659bb222020-11-12 20:16:39 +01001431 assert_equal(10, 60 / 6)
1432 assert_equal(6, 60 /
1433 g:anint)
1434 assert_equal(1, g:anint / 6)
1435 assert_equal(2, g:anint
1436 / g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001437
Bram Moolenaar659bb222020-11-12 20:16:39 +01001438 assert_equal(5, 11 % 6)
1439 assert_equal(4, g:anint % 6)
1440 assert_equal(3, 13 %
1441 g:anint)
1442 assert_equal(2, g:anint
1443 % g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001444
Bram Moolenaar659bb222020-11-12 20:16:39 +01001445 assert_equal(4, 6 * 4 / 6)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001446
Bram Moolenaar659bb222020-11-12 20:16:39 +01001447 var x = [2]
1448 var y = [3]
1449 assert_equal(5, x[0] + y[0])
1450 assert_equal(6, x[0] * y[0])
1451 if has('float')
1452 var xf = [2.0]
1453 var yf = [3.0]
1454 assert_equal(5.0, xf[0]
1455 + yf[0])
1456 assert_equal(6.0, xf[0]
1457 * yf[0])
1458 endif
1459 END
1460 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001461
Bram Moolenaar90193e62021-04-04 20:49:50 +02001462 CheckDefAndScriptFailure2(["var x = 6 * xxx"], 'E1001:', 'E121:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001463 CheckDefFailure(["var d = 6 * "], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001464 CheckScriptFailure(['vim9script', "var d = 6 * "], 'E15:', 2)
Bram Moolenaar99880f92021-01-20 21:23:14 +01001465
1466 CheckDefExecAndScriptFailure(['echo 1 / 0'], 'E1154', 1)
1467 CheckDefExecAndScriptFailure(['echo 1 % 0'], 'E1154', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001468enddef
1469
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001470def Test_expr6_vim9script()
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001471 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001472 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001473 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001474 * 22
1475 / 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001476 assert_equal(80, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001477 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001478 CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001479
1480 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001481 var name = 25
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001482 % 10
Bram Moolenaar98309382020-09-27 21:58:45 +02001483 assert_equal(5, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001484 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001485 CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001486
1487 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001488 var name = 25
1489 # comment
1490
1491 # comment
1492 % 10
1493 assert_equal(5, name)
1494 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001495 CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001496
1497 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001498 var name = 11 *
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001499 22 /
1500 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001501 assert_equal(80, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001502 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001503 CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001504
1505 # check white space
1506 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001507 echo 5*6
1508 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001509 CheckDefAndScriptFailure(lines, 'E1004:', 1)
1510
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001511 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001512 echo 5 *6
1513 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001514 CheckDefAndScriptFailure(lines, 'E1004:', 1)
1515
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001516 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001517 echo 5* 6
1518 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001519 CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001520enddef
1521
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001522def Test_expr6_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001523 if !has('float')
1524 MissingFeature 'float'
1525 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001526 var lines =<< trim END
1527 assert_equal(36.0, 6.0 * 6)
1528 assert_equal(36.0, 6 *
1529 6.0)
1530 assert_equal(36.0, 6.0 * 6.0)
1531 assert_equal(1.0, g:afloat * g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001532
Bram Moolenaar659bb222020-11-12 20:16:39 +01001533 assert_equal(10.0, 60 / 6.0)
1534 assert_equal(10.0, 60.0 /
1535 6)
1536 assert_equal(10.0, 60.0 / 6.0)
1537 assert_equal(0.01, g:afloat / g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001538
Bram Moolenaar659bb222020-11-12 20:16:39 +01001539 assert_equal(4.0, 6.0 * 4 / 6)
1540 assert_equal(4.0, 6 *
1541 4.0 /
1542 6)
1543 assert_equal(4.0, 6 * 4 / 6.0)
1544 assert_equal(4.0, 6.0 * 4.0 / 6)
1545 assert_equal(4.0, 6 * 4.0 / 6.0)
1546 assert_equal(4.0, 6.0 * 4 / 6.0)
1547 assert_equal(4.0, 6.0 * 4.0 / 6.0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001548
Bram Moolenaar659bb222020-11-12 20:16:39 +01001549 assert_equal(4.0, 6.0 * 4.0 / 6.0)
1550 END
1551 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001552 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001553enddef
1554
1555func Test_expr6_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001556 let msg = "White space required before and after '*'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001557 call CheckDefAndScriptFailure(["var x = 1*2"], msg, 1)
1558 call CheckDefAndScriptFailure(["var x = 1 *2"], msg, 1)
1559 call CheckDefAndScriptFailure(["var x = 1* 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001560
Bram Moolenaar77072282020-09-16 17:55:40 +02001561 let msg = "White space required before and after '/'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001562 call CheckDefAndScriptFailure(["var x = 1/2"], msg, 1)
1563 call CheckDefAndScriptFailure(["var x = 1 /2"], msg, 1)
1564 call CheckDefAndScriptFailure(["var x = 1/ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001565
Bram Moolenaar77072282020-09-16 17:55:40 +02001566 let msg = "White space required before and after '%'"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001567 call CheckDefAndScriptFailure(["var x = 1%2"], msg, 1)
1568 call CheckDefAndScriptFailure(["var x = 1 %2"], msg, 1)
1569 call CheckDefAndScriptFailure(["var x = 1% 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001570
Bram Moolenaar90193e62021-04-04 20:49:50 +02001571 call CheckDefAndScriptFailure2(["var x = '1' * '2'"], 'E1036:', 'E1030:', 1)
1572 call CheckDefAndScriptFailure2(["var x = '1' / '2'"], 'E1036:', 'E1030:', 1)
1573 call CheckDefAndScriptFailure2(["var x = '1' % '2'"], 'E1035:', 'E1030:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001574
Bram Moolenaar90193e62021-04-04 20:49:50 +02001575 call CheckDefAndScriptFailure2(["var x = 0z01 * 0z12"], 'E1036:', 'E974:', 1)
1576 call CheckDefAndScriptFailure2(["var x = 0z01 / 0z12"], 'E1036:', 'E974:', 1)
1577 call CheckDefAndScriptFailure2(["var x = 0z01 % 0z12"], 'E1035:', 'E974:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001578
Bram Moolenaar90193e62021-04-04 20:49:50 +02001579 call CheckDefAndScriptFailure2(["var x = [1] * [2]"], 'E1036:', 'E745:', 1)
1580 call CheckDefAndScriptFailure2(["var x = [1] / [2]"], 'E1036:', 'E745:', 1)
1581 call CheckDefAndScriptFailure2(["var x = [1] % [2]"], 'E1035:', 'E745:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001582
Bram Moolenaar90193e62021-04-04 20:49:50 +02001583 call CheckDefAndScriptFailure2(["var x = {one: 1} * {two: 2}"], 'E1036:', 'E728:', 1)
1584 call CheckDefAndScriptFailure2(["var x = {one: 1} / {two: 2}"], 'E1036:', 'E728:', 1)
1585 call CheckDefAndScriptFailure2(["var x = {one: 1} % {two: 2}"], 'E1035:', 'E728:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001586
Bram Moolenaar90193e62021-04-04 20:49:50 +02001587 call CheckDefAndScriptFailure2(["var x = 0xff[1]"], 'E1107:', 'E1062:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001588 if has('float')
Bram Moolenaar90193e62021-04-04 20:49:50 +02001589 call CheckDefAndScriptFailure2(["var x = 0.7[1]"], 'E1107:', 'E806:', 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001590 endif
mityu4ac198c2021-05-28 17:52:40 +02001591
1592 for op in ['*', '/', '%']
1593 let lines = ['var x = 1', op .. '2', '# comment']
1594 let msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
1595 call CheckDefAndScriptFailure(lines, msg, 2)
1596 endfor
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001597endfunc
1598
1599func Test_expr6_float_fails()
1600 CheckFeature float
Bram Moolenaar90193e62021-04-04 20:49:50 +02001601 call CheckDefAndScriptFailure2(["var x = 1.0 % 2"], 'E1035:', 'E804:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001602endfunc
1603
1604" define here to use old style parsing
1605if has('float')
1606 let g:float_zero = 0.0
1607 let g:float_neg = -9.8
1608 let g:float_big = 9.9e99
1609endif
1610let g:blob_empty = 0z
1611let g:blob_one = 0z01
1612let g:blob_long = 0z0102.0304
1613
1614let g:string_empty = ''
1615let g:string_short = 'x'
1616let g:string_long = 'abcdefghijklm'
1617let g:string_special = "ab\ncd\ref\ekk"
1618
1619let g:special_true = v:true
1620let g:special_false = v:false
1621let g:special_null = v:null
1622let g:special_none = v:none
1623
1624let g:list_empty = []
1625let g:list_mixed = [1, 'b', v:false]
1626
1627let g:dict_empty = {}
1628let g:dict_one = #{one: 1}
1629
1630let $TESTVAR = 'testvar'
1631
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001632" type casts
1633def Test_expr7t()
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001634 var lines =<< trim END
1635 var ls: list<string> = ['a', <string>g:string_empty]
1636 var ln: list<number> = [<number>g:anint, <number>g:thefour]
1637 var nr = <number>234
1638 assert_equal(234, nr)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02001639 var b: bool = <bool>1
1640 assert_equal(true, b)
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001641 var text =
1642 <string>
1643 'text'
1644 if false
1645 text = <number>'xxx'
1646 endif
1647 END
1648 CheckDefAndScriptSuccess(lines)
Bram Moolenaard1103582020-08-14 22:44:25 +02001649
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001650 CheckDefAndScriptFailure(["var x = <nr>123"], 'E1010:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001651 CheckDefFailure(["var x = <number>"], 'E1097:', 3)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02001652 CheckDefFailure(["var x = <number>string(1)"], 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001653 CheckScriptFailure(['vim9script', "var x = <number>"], 'E15:', 2)
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001654 CheckDefAndScriptFailure(["var x = <number >123"], 'E1068:', 1)
1655 CheckDefAndScriptFailure(["var x = <number 123"], 'E1104:', 1)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001656enddef
1657
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001658" test low level expression
1659def Test_expr7_number()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001660 # number constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001661 var lines =<< trim END
1662 assert_equal(0, 0)
1663 assert_equal(654, 0654)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001664
Bram Moolenaar659bb222020-11-12 20:16:39 +01001665 assert_equal(6, 0x6)
1666 assert_equal(15, 0xf)
1667 assert_equal(255, 0xff)
1668 END
1669 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001670enddef
1671
1672def Test_expr7_float()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001673 # float constant
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001674 if !has('float')
1675 MissingFeature 'float'
1676 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001677 var lines =<< trim END
1678 assert_equal(g:float_zero, .0)
1679 assert_equal(g:float_zero, 0.0)
1680 assert_equal(g:float_neg, -9.8)
1681 assert_equal(g:float_big, 9.9e99)
1682 END
1683 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001684 endif
1685enddef
1686
1687def Test_expr7_blob()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001688 # blob constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001689 var lines =<< trim END
1690 assert_equal(g:blob_empty, 0z)
1691 assert_equal(g:blob_one, 0z01)
1692 assert_equal(g:blob_long, 0z0102.0304)
Bram Moolenaarcfc30232021-04-11 20:26:34 +02001693
1694 var testblob = 0z010203
1695 assert_equal(0x01, testblob[0])
1696 assert_equal(0x02, testblob[1])
1697 assert_equal(0x03, testblob[-1])
1698 assert_equal(0x02, testblob[-2])
1699
1700 assert_equal(0z01, testblob[0 : 0])
1701 assert_equal(0z0102, testblob[0 : 1])
1702 assert_equal(0z010203, testblob[0 : 2])
1703 assert_equal(0z010203, testblob[0 : ])
1704 assert_equal(0z0203, testblob[1 : ])
1705 assert_equal(0z0203, testblob[1 : 2])
1706 assert_equal(0z0203, testblob[1 : -1])
1707 assert_equal(0z03, testblob[-1 : -1])
1708 assert_equal(0z02, testblob[-2 : -2])
1709
1710 # blob slice accepts out of range
1711 assert_equal(0z, testblob[3 : 3])
1712 assert_equal(0z, testblob[0 : -4])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001713 END
1714 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001715
Bram Moolenaar90193e62021-04-04 20:49:50 +02001716 CheckDefAndScriptFailure(["var x = 0z123"], 'E973:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001717enddef
1718
1719def Test_expr7_string()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001720 # string constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001721 var lines =<< trim END
1722 assert_equal(g:string_empty, '')
1723 assert_equal(g:string_empty, "")
1724 assert_equal(g:string_short, 'x')
1725 assert_equal(g:string_short, "x")
1726 assert_equal(g:string_long, 'abcdefghijklm')
1727 assert_equal(g:string_long, "abcdefghijklm")
1728 assert_equal(g:string_special, "ab\ncd\ref\ekk")
1729 END
1730 CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001731
Bram Moolenaar90193e62021-04-04 20:49:50 +02001732 CheckDefAndScriptFailure(['var x = "abc'], 'E114:', 1)
1733 CheckDefAndScriptFailure(["var x = 'abc"], 'E115:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001734enddef
1735
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001736def Test_expr7_vimvar()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001737 var old: list<string> = v:oldfiles
1738 var compl: dict<any> = v:completed_item
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001739
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001740 CheckDefFailure(["var old: list<number> = v:oldfiles"], 'E1012: Type mismatch; expected list<number> but got list<string>', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001741 CheckScriptFailure(['vim9script', 'v:oldfiles = ["foo"]', "var old: list<number> = v:oldfiles"], 'E1012: Type mismatch; expected list<number> but got list<string>', 3)
Bram Moolenaar5e654232020-09-16 15:22:00 +02001742 new
1743 exec "normal! afoo fo\<C-N>\<Esc>"
Bram Moolenaar90193e62021-04-04 20:49:50 +02001744 CheckDefExecAndScriptFailure(["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 +02001745 bwipe!
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001746enddef
1747
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001748def Test_expr7_special()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001749 # special constant
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001750 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001751 assert_equal(g:special_true, true)
1752 assert_equal(g:special_false, false)
1753 assert_equal(g:special_true, v:true)
1754 assert_equal(g:special_false, v:false)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001755 assert_equal(v:true, true)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001756 assert_equal(v:false, false)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001757
Bram Moolenaar6e4cfff2020-08-09 22:17:55 +02001758 assert_equal(true, !false)
1759 assert_equal(false, !true)
1760 assert_equal(true, !0)
1761 assert_equal(false, !1)
1762 assert_equal(false, !!false)
1763 assert_equal(true, !!true)
1764 assert_equal(false, !!0)
1765 assert_equal(true, !!1)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001766
1767 var t = true
1768 var f = false
1769 assert_equal(true, t)
1770 assert_equal(false, f)
1771
1772 assert_equal(g:special_null, v:null)
Bram Moolenaar67977822021-01-03 21:53:53 +01001773 assert_equal(g:special_null, null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001774 assert_equal(g:special_none, v:none)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001775 END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001776 CheckDefAndScriptSuccess(lines)
1777
Bram Moolenaar90193e62021-04-04 20:49:50 +02001778 CheckDefAndScriptFailure(['v:true = true'], 'E46:', 1)
1779 CheckDefAndScriptFailure(['v:true = false'], 'E46:', 1)
1780 CheckDefAndScriptFailure(['v:false = true'], 'E46:', 1)
1781 CheckDefAndScriptFailure(['v:null = 11'], 'E46:', 1)
1782 CheckDefAndScriptFailure(['v:none = 22'], 'E46:', 1)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001783enddef
1784
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001785def Test_expr7_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001786 # list
Bram Moolenaar659bb222020-11-12 20:16:39 +01001787 var lines =<< trim END
1788 assert_equal(g:list_empty, [])
1789 assert_equal(g:list_empty, [ ])
Bram Moolenaar127542b2020-08-09 17:22:04 +02001790
Bram Moolenaar659bb222020-11-12 20:16:39 +01001791 var numbers: list<number> = [1, 2, 3]
1792 numbers = [1]
1793 numbers = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001794
Bram Moolenaar659bb222020-11-12 20:16:39 +01001795 var strings: list<string> = ['a', 'b', 'c']
1796 strings = ['x']
1797 strings = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001798
Bram Moolenaar659bb222020-11-12 20:16:39 +01001799 var mixed: list<any> = [1, 'b', false,]
1800 assert_equal(g:list_mixed, mixed)
1801 assert_equal('b', mixed[1])
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001802
Bram Moolenaar659bb222020-11-12 20:16:39 +01001803 echo [1,
1804 2] [3,
1805 4]
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001806
Bram Moolenaar659bb222020-11-12 20:16:39 +01001807 var llstring: list<list<string>> = [['text'], []]
1808 llstring = [[], ['text']]
1809 llstring = [[], []]
1810 END
1811 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02001812
Bram Moolenaar5597ba02020-09-27 17:45:03 +02001813 var rangelist: list<number> = range(3)
1814 g:rangelist = range(3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001815 CheckDefExecAndScriptFailure(["var x: list<string> = g:rangelist"], 'E1012: Type mismatch; expected list<string> but got list<number>', 1)
Bram Moolenaar5597ba02020-09-27 17:45:03 +02001816
Bram Moolenaar90193e62021-04-04 20:49:50 +02001817 CheckDefAndScriptFailure2(["var x = 1234[3]"], 'E1107:', 'E1062:', 1)
1818 CheckDefExecAndScriptFailure(["var x = g:anint[3]"], 'E1062:', 1)
Bram Moolenaar56acb092020-08-16 14:48:19 +02001819
Bram Moolenaar90193e62021-04-04 20:49:50 +02001820 CheckDefAndScriptFailure2(["var x = g:list_mixed[xxx]"], 'E1001:', 'E121:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001821
Bram Moolenaar90193e62021-04-04 20:49:50 +02001822 CheckDefAndScriptFailure(["var x = [1,2,3]"], 'E1069:', 1)
1823 CheckDefAndScriptFailure(["var x = [1 ,2, 3]"], 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001824
Bram Moolenaar90193e62021-04-04 20:49:50 +02001825 CheckDefExecAndScriptFailure(["echo 1", "var x = [][0]", "echo 3"], 'E684:', 2)
Bram Moolenaar1d634542020-08-18 13:41:50 +02001826
Bram Moolenaar90193e62021-04-04 20:49:50 +02001827 CheckDefExecAndScriptFailure2(["var x = g:list_mixed['xx']"], 'E1012:', 'E1030:', 1)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001828 CheckDefFailure(["var x = g:list_mixed["], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001829 CheckScriptFailure(['vim9script', "var x = g:list_mixed["], 'E15:', 2)
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01001830 CheckDefFailure(["var x = g:list_mixed[0"], 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001831 CheckScriptFailure(['vim9script', "var x = g:list_mixed[0"], 'E111:', 2)
1832 CheckDefExecAndScriptFailure(["var x = g:list_empty[3]"], 'E684:', 1)
1833 CheckDefExecAndScriptFailure(["var l: list<number> = [234, 'x']"], 'E1012:', 1)
1834 CheckDefExecAndScriptFailure(["var l: list<number> = ['x', 234]"], 'E1012:', 1)
1835 CheckDefExecAndScriptFailure(["var l: list<string> = [234, 'x']"], 'E1012:', 1)
1836 CheckDefExecAndScriptFailure(["var l: list<string> = ['x', 123]"], 'E1012:', 1)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001837
Bram Moolenaar659bb222020-11-12 20:16:39 +01001838 lines =<< trim END
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001839 var datalist: list<string>
1840 def Main()
1841 datalist += ['x'.
1842 enddef
1843 Main()
1844 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001845 CheckDefAndScriptFailure(lines, 'E1127:')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001846
1847 lines =<< trim END
1848 var numbers = [1, 2, 3, 4]
1849 var a = 1
1850 var b = 2
1851 END
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001852 CheckDefAndScriptFailure(lines + ['echo numbers[1:b]'],
1853 'E1004: White space required before and after '':'' at ":b]"', 4)
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001854 CheckDefAndScriptFailure(lines + ['echo numbers[1: b]'], 'E1004:', 4)
1855 CheckDefAndScriptFailure(lines + ['echo numbers[a :b]'], 'E1004:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001856enddef
1857
Bram Moolenaar71478202020-06-26 22:46:27 +02001858def Test_expr7_list_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001859 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001860 var l = [
Bram Moolenaar71478202020-06-26 22:46:27 +02001861 11,
1862 22,
1863 ]
1864 assert_equal([11, 22], l)
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001865
1866 echo [1,
1867 2] [3,
1868 4]
Bram Moolenaar93be1642020-10-11 21:34:41 +02001869
1870 echo [1, # comment
1871 # comment
1872 2] [3,
1873 # comment
1874 4]
Bram Moolenaar71478202020-06-26 22:46:27 +02001875 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001876 CheckDefAndScriptSuccess(lines)
Bram Moolenaar71478202020-06-26 22:46:27 +02001877
1878 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001879 var l = [11,
Bram Moolenaar71478202020-06-26 22:46:27 +02001880 22]
1881 assert_equal([11, 22], l)
1882 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001883 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001884
1885 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001886 var l = [11,22]
Bram Moolenaar8ea93902020-06-27 14:11:53 +02001887 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001888 CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001889
1890 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001891 var l = [11 , 22]
Bram Moolenaardb199212020-08-12 18:01:53 +02001892 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001893 CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001894
1895 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001896 var l: list<number> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02001897 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001898 CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01001899
1900 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001901 var l: list<number> = ['x', 234]
1902 END
1903 CheckDefAndScriptFailure(lines, 'E1012:', 1)
1904
1905 lines =<< trim END
1906 var l: list<string> = ['x', 234]
1907 END
1908 CheckDefAndScriptFailure(lines, 'E1012:', 1)
1909
1910 lines =<< trim END
1911 var l: list<string> = [234, 'x']
1912 END
1913 CheckDefAndScriptFailure(lines, 'E1012:', 1)
1914
1915 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01001916 def Failing()
1917 job_stop()
1918 enddef
1919 var list = [Failing]
1920 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001921 if has('channel')
Bram Moolenaar90193e62021-04-04 20:49:50 +02001922 CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001923 else
Bram Moolenaar90193e62021-04-04 20:49:50 +02001924 CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01001925 endif
Bram Moolenaar71478202020-06-26 22:46:27 +02001926enddef
1927
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001928def LambdaWithComments(): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001929 return (x) =>
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001930 # some comment
1931 x == 1
1932 # some comment
1933 ||
1934 x == 2
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001935enddef
1936
Bram Moolenaarfd777482020-08-12 19:42:01 +02001937def LambdaUsingArg(x: number): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001938 return () =>
Bram Moolenaarfd777482020-08-12 19:42:01 +02001939 # some comment
1940 x == 1
1941 # some comment
1942 ||
1943 x == 2
Bram Moolenaarfd777482020-08-12 19:42:01 +02001944enddef
1945
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001946def Test_expr7_lambda()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001947 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001948 var La = () => 'result'
Bram Moolenaar03717bf2021-04-28 20:00:40 +02001949 # comment
Bram Moolenaar659bb222020-11-12 20:16:39 +01001950 assert_equal('result', La())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001951 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02001952
Bram Moolenaar659bb222020-11-12 20:16:39 +01001953 # line continuation inside lambda with "cond ? expr : expr" works
1954 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001955 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaare0de1712020-12-02 17:36:54 +01001956 ['111']: 111 } : {}
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001957 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01001958 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001959
Bram Moolenaar03717bf2021-04-28 20:00:40 +02001960 # comment halfway an expression
1961 var Ref = () => 4
1962 # comment
1963 + 6
1964 assert_equal(10, Ref())
1965
Bram Moolenaar659bb222020-11-12 20:16:39 +01001966 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001967 map(ll, (k, v) => v == 8 || v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001968 == 9
1969 || v % 2 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001970 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001971 assert_equal([222, 111, 222], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001972
Bram Moolenaar659bb222020-11-12 20:16:39 +01001973 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001974 map(ll, (k, v) => v != 8 && v
Bram Moolenaar659bb222020-11-12 20:16:39 +01001975 != 9
1976 && v % 2 == 0 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001977 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01001978 assert_equal([111, 222, 111], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02001979
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001980 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
Bram Moolenaare0de1712020-12-02 17:36:54 +01001981 assert_equal([{key: 22}], dl)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02001982
Bram Moolenaare0de1712020-12-02 17:36:54 +01001983 dl = [{key: 12}, {['foo']: 34}]
1984 assert_equal([{key: 12}], filter(dl,
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001985 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
Bram Moolenaar7892b952020-07-20 22:09:34 +02001986
Bram Moolenaar659bb222020-11-12 20:16:39 +01001987 assert_equal(false, LambdaWithComments()(0))
1988 assert_equal(true, LambdaWithComments()(1))
1989 assert_equal(true, LambdaWithComments()(2))
1990 assert_equal(false, LambdaWithComments()(3))
Bram Moolenaarba60cc42020-08-12 19:15:33 +02001991
Bram Moolenaar659bb222020-11-12 20:16:39 +01001992 assert_equal(false, LambdaUsingArg(0)())
1993 assert_equal(true, LambdaUsingArg(1)())
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001994
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01001995 var res = map([1, 2, 3], (i: number, v: number) => i + v)
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01001996 assert_equal([1, 3, 5], res)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001997 END
1998 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfd777482020-08-12 19:42:01 +02001999
Bram Moolenaar90193e62021-04-04 20:49:50 +02002000 CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2001 CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004: White space required before and after ''=>'' at "=> a + 1"')
2002 CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"], 'E1004:')
Yegappan Lakshmanan611728f2021-05-24 15:15:47 +02002003 CheckDefAndScriptFailure2(["var Ref = (a) =< a + 1"], 'E1001:', 'E121:')
2004 CheckDefAndScriptFailure(["var Ref = (a: int) => a + 1"], 'E1010:')
2005 CheckDefAndScriptFailure(["var Ref = (a): int => a + 1"], 'E1010:')
Bram Moolenaar27bf7af2020-12-23 20:27:31 +01002006
Bram Moolenaar90193e62021-04-04 20:49:50 +02002007 CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002008 # error is in first line of the lambda
Bram Moolenaar90193e62021-04-04 20:49:50 +02002009 CheckDefAndScriptFailure(["var L = (a) => a + b"], 'E1001:', 0)
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002010
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002011 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002012
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002013 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"], 'E118:')
2014 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"], 'E118:')
Bram Moolenaar90193e62021-04-04 20:49:50 +02002015 CheckDefAndScriptFailure2(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 'E121:', 1)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002016
Bram Moolenaar90193e62021-04-04 20:49:50 +02002017 CheckDefAndScriptSuccess(['var Fx = (a) => ({k1: 0,', ' k2: 1})'])
2018 CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2019 CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002020
Bram Moolenaar90193e62021-04-04 20:49:50 +02002021 CheckDefAndScriptSuccess(['var Fx = (a) => [0,', ' 1]'])
2022 CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002023
2024 # no error for existing script variable when checking for lambda
2025 lines =<< trim END
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002026 var name = 0
2027 eval (name + 2) / 3
2028 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002029 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002030enddef
2031
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002032def Test_expr7_lambda_block()
2033 var lines =<< trim END
2034 var Func = (s: string): string => {
2035 return 'hello ' .. s
2036 }
2037 assert_equal('hello there', Func('there'))
2038
2039 var ll = range(3)
2040 var dll = mapnew(ll, (k, v): string => {
2041 if v % 2
2042 return 'yes'
2043 endif
2044 return 'no'
2045 })
2046 assert_equal(['no', 'yes', 'no'], dll)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002047
2048 sandbox var Safe = (nr: number): number => {
2049 return nr + 7
2050 }
2051 assert_equal(10, Safe(3))
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002052 END
2053 CheckDefAndScriptSuccess(lines)
Bram Moolenaare98f60a2021-03-22 18:22:30 +01002054
2055 lines =<< trim END
2056 map([1, 2], (k, v) => { redrawt })
2057 END
2058 CheckDefAndScriptFailure(lines, 'E488')
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002059
2060 lines =<< trim END
2061 var Func = (nr: int) => {
2062 echo nr
2063 }
2064 END
2065 CheckDefAndScriptFailure(lines, 'E1010', 1)
2066
2067 lines =<< trim END
2068 var Func = (nr: number): int => {
2069 return nr
2070 }
2071 END
2072 CheckDefAndScriptFailure(lines, 'E1010', 1)
2073
2074 lines =<< trim END
2075 var Func = (nr: number): int => {
2076 return nr
2077 END
2078 CheckDefAndScriptFailure(lines, 'E1171', 1) # line nr is function start
2079
2080 lines =<< trim END
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002081 var Func = (nr: number): int => {
2082 var ll =<< ENDIT
2083 nothing
2084 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002085 CheckDefFailure(lines, 'E1145: Missing heredoc end marker: ENDIT', 0)
2086 CheckScriptFailure(['vim9script'] + lines, 'E1145: Missing heredoc end marker: ENDIT', 2)
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002087enddef
2088
Bram Moolenaar65c44152020-12-24 15:14:01 +01002089def NewLambdaWithComments(): func
2090 return (x) =>
2091 # some comment
2092 x == 1
2093 # some comment
2094 ||
2095 x == 2
2096enddef
2097
2098def NewLambdaUsingArg(x: number): func
2099 return () =>
2100 # some comment
2101 x == 1
2102 # some comment
2103 ||
2104 x == 2
2105enddef
2106
2107def Test_expr7_new_lambda()
2108 var lines =<< trim END
2109 var La = () => 'result'
2110 assert_equal('result', La())
2111 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
2112
2113 # line continuation inside lambda with "cond ? expr : expr" works
2114 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002115 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaar65c44152020-12-24 15:14:01 +01002116 ['111']: 111 } : {}
2117 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002118 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002119
2120 ll = range(3)
2121 map(ll, (k, v) => v == 8 || v
2122 == 9
2123 || v % 2 ? 111 : 222
2124 )
2125 assert_equal([222, 111, 222], ll)
2126
2127 ll = range(3)
2128 map(ll, (k, v) => v != 8 && v
2129 != 9
2130 && v % 2 == 0 ? 111 : 222
2131 )
2132 assert_equal([111, 222, 111], ll)
2133
2134 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => v['key'] )
2135 assert_equal([{key: 22}], dl)
2136
2137 dl = [{key: 12}, {['foo']: 34}]
2138 assert_equal([{key: 12}], filter(dl,
2139 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
2140
2141 assert_equal(false, NewLambdaWithComments()(0))
2142 assert_equal(true, NewLambdaWithComments()(1))
2143 assert_equal(true, NewLambdaWithComments()(2))
2144 assert_equal(false, NewLambdaWithComments()(3))
2145
2146 assert_equal(false, NewLambdaUsingArg(0)())
2147 assert_equal(true, NewLambdaUsingArg(1)())
2148
2149 var res = map([1, 2, 3], (i: number, v: number) => i + v)
2150 assert_equal([1, 3, 5], res)
2151
2152 # Lambda returning a dict
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002153 var Lmb = () => ({key: 42})
Bram Moolenaar65c44152020-12-24 15:14:01 +01002154 assert_equal({key: 42}, Lmb())
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002155
2156 var RefOne: func(number): string = (a: number): string => 'x'
2157 var RefTwo: func(number): any = (a: number): any => 'x'
2158
2159 var Fx = (a) => ({k1: 0,
2160 k2: 1})
2161 var Fy = (a) => [0,
2162 1]
Bram Moolenaar65c44152020-12-24 15:14:01 +01002163 END
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002164 CheckDefAndScriptSuccess(lines)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002165
Bram Moolenaare462f522020-12-27 14:43:30 +01002166 CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2167 CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004:')
Bram Moolenaare7a73e02021-01-01 19:17:55 +01002168 CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"],
2169 'E1004: White space required before and after ''=>'' at " =>a + 1"')
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002170
Bram Moolenaar90193e62021-04-04 20:49:50 +02002171 CheckDefAndScriptFailure(["var Ref: func(number): number = (a: number): string => 'x'"], 'E1012:')
2172 CheckDefAndScriptFailure(["var Ref: func(number): string = (a: number): string => 99"], 'E1012:')
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002173
Bram Moolenaar90193e62021-04-04 20:49:50 +02002174 CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002175 # error is in first line of the lambda
Bram Moolenaar90193e62021-04-04 20:49:50 +02002176 CheckDefAndScriptFailure2(["var L = (a) -> a + b"], 'E1001:', 'E121:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002177
Bram Moolenaar90193e62021-04-04 20:49:50 +02002178 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar65c44152020-12-24 15:14:01 +01002179
Bram Moolenaar90193e62021-04-04 20:49:50 +02002180 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"],
2181 'E118: Too many arguments for function:')
2182 CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"],
2183 'E118: Too many arguments for function:')
2184 CheckDefFailure(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002185
Bram Moolenaar90193e62021-04-04 20:49:50 +02002186 CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2187 CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002188
Bram Moolenaar90193e62021-04-04 20:49:50 +02002189 CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002190enddef
2191
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002192def Test_expr7_lambda_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002193 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002194 var v = 10->((a) =>
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002195 a
2196 + 2
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002197 )()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002198 assert_equal(12, v)
2199 END
Bram Moolenaar2927c072021-04-05 19:41:21 +02002200 CheckDefAndScriptSuccess(lines)
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002201
2202 # nested lambda with line breaks
2203 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002204 search('"', 'cW', 0, 0, () =>
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002205 synstack('.', col('.'))
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002206 ->map((_, v) => synIDattr(v, 'name'))->len())
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002207 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002208 CheckDefAndScriptSuccess(lines)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002209enddef
2210
Bram Moolenaar90193e62021-04-04 20:49:50 +02002211def Test_expr7_funcref()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002212 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002213 def RetNumber(): number
2214 return 123
2215 enddef
2216 var FuncRef = RetNumber
2217 assert_equal(123, FuncRef())
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002218 END
2219 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfa596382021-04-07 21:58:16 +02002220
2221 lines =<< trim END
2222 vim9script
2223 func g:GlobalFunc()
2224 return 'global'
2225 endfunc
2226 func s:ScriptFunc()
2227 return 'script'
2228 endfunc
2229 def Test()
2230 var Ref = g:GlobalFunc
2231 assert_equal('global', Ref())
2232 Ref = GlobalFunc
2233 assert_equal('global', Ref())
2234
2235 Ref = s:ScriptFunc
2236 assert_equal('script', Ref())
2237 Ref = ScriptFunc
2238 assert_equal('script', Ref())
2239 enddef
2240 Test()
2241 END
2242 CheckScriptSuccess(lines)
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002243enddef
2244
Bram Moolenaar2bede172020-11-19 18:53:18 +01002245let g:test_space_dict = {'': 'empty', ' ': 'space'}
2246let g:test_hash_dict = #{one: 1, two: 2}
2247
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002248def Test_expr7_dict()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002249 # dictionary
Bram Moolenaar659bb222020-11-12 20:16:39 +01002250 var lines =<< trim END
2251 assert_equal(g:dict_empty, {})
2252 assert_equal(g:dict_empty, { })
Bram Moolenaare0de1712020-12-02 17:36:54 +01002253 assert_equal(g:dict_one, {['one']: 1})
Bram Moolenaar659bb222020-11-12 20:16:39 +01002254 var key = 'one'
2255 var val = 1
Bram Moolenaar2bede172020-11-19 18:53:18 +01002256 assert_equal(g:dict_one, {[key]: val})
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002257
Bram Moolenaar2bede172020-11-19 18:53:18 +01002258 var numbers: dict<number> = {a: 1, b: 2, c: 3}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002259 numbers = {a: 1}
2260 numbers = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002261
Bram Moolenaar2bede172020-11-19 18:53:18 +01002262 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002263 strings = {a: 'x'}
2264 strings = {}
2265
2266 var dash = {xx-x: 8}
2267 assert_equal({['xx-x']: 8}, dash)
2268
2269 var dnr = {8: 8}
2270 assert_equal({['8']: 8}, dnr)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002271
Bram Moolenaar2bede172020-11-19 18:53:18 +01002272 var mixed: dict<any> = {a: 'a', b: 42}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002273 mixed = {a: 'x'}
2274 mixed = {a: 234}
2275 mixed = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002276
Bram Moolenaare0de1712020-12-02 17:36:54 +01002277 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
2278 dictlist = {absent: ['hi'], present: []}
2279 dictlist = {absent: [], present: []}
Bram Moolenaar77b20972020-09-19 14:12:34 +02002280
Bram Moolenaare0de1712020-12-02 17:36:54 +01002281 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
2282 dictdict = {one: {}, two: {a: 'text'}}
2283 dictdict = {one: {}, two: {}}
Bram Moolenaarc7f7f6d2020-11-04 13:38:28 +01002284
Bram Moolenaare0de1712020-12-02 17:36:54 +01002285 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
Bram Moolenaar2bede172020-11-19 18:53:18 +01002286
2287 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
2288 assert_equal(g:test_hash_dict, {one: 1, two: 2})
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01002289
2290 assert_equal({['a a']: 1, ['b/c']: 2}, {'a a': 1, "b/c": 2})
Bram Moolenaar6b553772020-12-31 13:31:23 +01002291
2292 var d = {a: () => 3, b: () => 7}
2293 assert_equal(3, d.a())
2294 assert_equal(7, d.b())
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002295
2296 var cd = { # comment
2297 key: 'val' # comment
2298 }
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002299
2300 # different types used for the key
2301 var dkeys = {['key']: 'string',
2302 [12]: 'numberexpr',
2303 34: 'number',
2304 [true]: 'bool'}
2305 assert_equal('string', dkeys['key'])
2306 assert_equal('numberexpr', dkeys[12])
2307 assert_equal('number', dkeys[34])
2308 assert_equal('bool', dkeys[true])
2309 if has('float')
2310 dkeys = {[1.2]: 'floatexpr', [3.4]: 'float'}
2311 assert_equal('floatexpr', dkeys[1.2])
2312 assert_equal('float', dkeys[3.4])
2313 endif
2314
2315 # automatic conversion from number to string
2316 var n = 123
2317 var dictnr = {[n]: 1}
Bram Moolenaara0399ef2021-03-20 15:00:01 +01002318
2319 # comment to start fold is OK
2320 var x1: number #{{ fold
2321 var x2 = 9 #{{ fold
Bram Moolenaar659bb222020-11-12 20:16:39 +01002322 END
2323 CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002324
Bram Moolenaare0de1712020-12-02 17:36:54 +01002325 # legacy syntax doesn't work
Bram Moolenaar5c7a2992021-03-20 13:29:38 +01002326 CheckDefAndScriptFailure(["var x = #{key: 8}"], 'E1170:', 1)
2327 CheckDefAndScriptFailure(["var x = 'a' #{a: 1}"], 'E1170:', 1)
2328 CheckDefAndScriptFailure(["var x = 'a' .. #{a: 1}"], 'E1170:', 1)
2329 CheckDefAndScriptFailure(["var x = true ? #{a: 1}"], 'E1170:', 1)
Bram Moolenaar17a836c2020-08-12 17:35:58 +02002330
Bram Moolenaar90193e62021-04-04 20:49:50 +02002331 CheckDefAndScriptFailure(["var x = {a:8}"], 'E1069:', 1)
2332 CheckDefAndScriptFailure(["var x = {a : 8}"], 'E1068:', 1)
2333 CheckDefAndScriptFailure(["var x = {a :8}"], 'E1068:', 1)
2334 CheckDefAndScriptFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
2335 CheckDefAndScriptFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002336
Bram Moolenaar90193e62021-04-04 20:49:50 +02002337 CheckDefAndScriptFailure(["var x = {xxx}"], 'E720:', 1)
2338 CheckDefAndScriptFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002339 CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002340 CheckScriptFailure(['vim9script', "var x = {xxx: 1,"], 'E723:', 2)
2341 CheckDefAndScriptFailure2(["var x = {['a']: xxx}"], 'E1001:', 'E121:', 1)
2342 CheckDefAndScriptFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
2343 CheckDefExecAndScriptFailure2(["var x = g:anint.member"], 'E715:', 'E15:', 1)
2344 CheckDefExecAndScriptFailure(["var x = g:dict_empty.member"], 'E716:', 1)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002345
Bram Moolenaar90193e62021-04-04 20:49:50 +02002346 CheckDefExecAndScriptFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
2347 CheckDefExecAndScriptFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
2348 CheckDefExecAndScriptFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
2349 CheckDefExecAndScriptFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002350
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002351 # invalid types for the key
Bram Moolenaar90193e62021-04-04 20:49:50 +02002352 CheckDefAndScriptFailure2(["var x = {[[1, 2]]: 0}"], 'E1105:', 'E730:', 1)
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002353
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002354 CheckDefFailure(['var x = ({'], 'E723:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002355 CheckScriptFailure(['vim9script', 'var x = ({'], 'E723:', 2)
2356 CheckDefExecAndScriptFailure(['{}[getftype("file")]'], 'E716: Key not present in Dictionary: ""', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002357enddef
2358
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002359def Test_expr7_dict_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002360 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002361 var d = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002362 ['one']:
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002363 1,
Bram Moolenaare0de1712020-12-02 17:36:54 +01002364 ['two']: 2,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002365 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002366 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar93be1642020-10-11 21:34:41 +02002367
2368 d = { # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002369 ['one']:
Bram Moolenaar93be1642020-10-11 21:34:41 +02002370 # comment
2371
2372 1,
2373 # comment
2374 # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002375 ['two']: 2,
Bram Moolenaar93be1642020-10-11 21:34:41 +02002376 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002377 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002378
2379 var dd = {k: 123->len()}
2380 assert_equal(3, dd.k)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002381 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002382 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002383
2384 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002385 var d = { ["one"]: "one", ["two"]: "two", }
2386 assert_equal({one: 'one', two: 'two'}, d)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002387 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002388 CheckDefAndScriptSuccess(lines)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002389
2390 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002391 var d = {one: 1,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002392 two: 2,
2393 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002394 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002395 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002396 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002397
2398 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002399 var d = {one:1, two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002400 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002401 CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002402
2403 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002404 var d = {one: 1,two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002405 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002406 CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002407
2408 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002409 var d = {one : 1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002410 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002411 CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002412
2413 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002414 var d = {one:1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002415 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002416 CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002417
2418 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002419 var d = {one: 1 , two: 2}
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002420 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002421 CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002422
2423 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002424 var l: dict<number> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002425 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002426 CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002427
2428 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002429 var l: dict<number> = {a: 'x', b: 234}
2430 END
2431 CheckDefAndScriptFailure(lines, 'E1012:', 1)
2432
2433 lines =<< trim END
2434 var l: dict<string> = {a: 'x', b: 234}
2435 END
2436 CheckDefAndScriptFailure(lines, 'E1012:', 1)
2437
2438 lines =<< trim END
2439 var l: dict<string> = {a: 234, b: 'x'}
2440 END
2441 CheckDefAndScriptFailure(lines, 'E1012:', 1)
2442
2443 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002444 var d = {['a']: 234, ['b': 'x'}
2445 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002446 CheckDefAndScriptFailure(lines, 'E1139:', 1)
2447
Bram Moolenaar918a4242020-12-06 14:37:08 +01002448 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002449 def Func()
2450 var d = {['a']: 234, ['b': 'x'}
2451 enddef
2452 defcompile
2453 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002454 CheckDefAndScriptFailure(lines, 'E1139:', 0)
2455
Bram Moolenaar918a4242020-12-06 14:37:08 +01002456 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002457 var d = {'a':
2458 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002459 CheckDefFailure(lines, 'E723:', 2)
2460 CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
2461
Bram Moolenaar918a4242020-12-06 14:37:08 +01002462 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002463 def Func()
2464 var d = {'a':
2465 enddef
2466 defcompile
2467 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002468 CheckDefAndScriptFailure(lines, 'E723:', 0)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002469
2470 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002471 def Failing()
2472 job_stop()
2473 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002474 var dict = {name: Failing}
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002475 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002476 if has('channel')
Bram Moolenaar90193e62021-04-04 20:49:50 +02002477 CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002478 else
Bram Moolenaar886e5e72021-04-05 13:36:34 +02002479 CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002480 endif
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002481enddef
2482
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002483def Test_expr7_call_2bool()
2484 var lines =<< trim END
2485 vim9script
2486
2487 def BrokenCall(nr: number, mode: bool, use: string): void
2488 assert_equal(3, nr)
2489 assert_equal(false, mode)
2490 assert_equal('ab', use)
2491 enddef
2492
2493 def TestBrokenCall(): void
2494 BrokenCall(3, 0, 'ab')
2495 enddef
2496
2497 TestBrokenCall()
2498 END
2499 CheckScriptSuccess(lines)
2500enddef
2501
Bram Moolenaar50788ef2020-07-05 16:51:26 +02002502let g:oneString = 'one'
2503
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002504def Test_expr_member()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002505 var lines =<< trim END
2506 assert_equal(1, g:dict_one.one)
2507 var d: dict<number> = g:dict_one
2508 assert_equal(1, d['one'])
2509 assert_equal(1, d[
2510 'one'
2511 ])
2512 assert_equal(1, d
2513 .one)
2514 d = {1: 1, _: 2}
2515 assert_equal(1, d
2516 .1)
2517 assert_equal(2, d
2518 ._)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002519
Bram Moolenaar90193e62021-04-04 20:49:50 +02002520 # getting the one member should clear the dict after getting the item
2521 assert_equal('one', {one: 'one'}.one)
2522 assert_equal('one', {one: 'one'}[g:oneString])
2523 END
2524 CheckDefAndScriptSuccess(lines)
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002525
Bram Moolenaar90193e62021-04-04 20:49:50 +02002526 CheckDefAndScriptFailure2(["var x = g:dict_one.#$!"], 'E1002:', 'E15:', 1)
2527 CheckDefExecAndScriptFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2528 CheckDefExecAndScriptFailure(["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 +02002529enddef
2530
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002531def Test_expr7_any_index_slice()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002532 var lines =<< trim END
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002533 # getting the one member should clear the list only after getting the item
2534 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
2535
2536 # string is permissive, index out of range accepted
2537 g:teststring = 'abcdef'
2538 assert_equal('b', g:teststring[1])
Bram Moolenaare7525c52021-01-09 13:20:37 +01002539 assert_equal('f', g:teststring[-1])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002540 assert_equal('', g:teststring[99])
2541
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002542 assert_equal('b', g:teststring[1 : 1])
2543 assert_equal('bcdef', g:teststring[1 :])
2544 assert_equal('abcd', g:teststring[: 3])
2545 assert_equal('cdef', g:teststring[-4 :])
2546 assert_equal('abcdef', g:teststring[-9 :])
2547 assert_equal('abcd', g:teststring[: -3])
2548 assert_equal('', g:teststring[: -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002549
Bram Moolenaar0289a092021-03-14 18:40:19 +01002550 # composing characters are included
2551 g:teststring = 'àéû'
2552 assert_equal('à', g:teststring[0])
2553 assert_equal('é', g:teststring[1])
2554 assert_equal('û', g:teststring[2])
2555 assert_equal('', g:teststring[3])
2556 assert_equal('', g:teststring[4])
2557
2558 assert_equal('û', g:teststring[-1])
2559 assert_equal('é', g:teststring[-2])
2560 assert_equal('à', g:teststring[-3])
2561 assert_equal('', g:teststring[-4])
2562 assert_equal('', g:teststring[-5])
2563
2564 assert_equal('à', g:teststring[0 : 0])
2565 assert_equal('é', g:teststring[1 : 1])
2566 assert_equal('àé', g:teststring[0 : 1])
2567 assert_equal('àéû', g:teststring[0 : -1])
2568 assert_equal('àé', g:teststring[0 : -2])
2569 assert_equal('à', g:teststring[0 : -3])
2570 assert_equal('', g:teststring[0 : -4])
2571 assert_equal('', g:teststring[0 : -5])
2572 assert_equal('àéû', g:teststring[ : ])
2573 assert_equal('àéû', g:teststring[0 : ])
2574 assert_equal('éû', g:teststring[1 : ])
2575 assert_equal('û', g:teststring[2 : ])
2576 assert_equal('', g:teststring[3 : ])
2577 assert_equal('', g:teststring[4 : ])
2578
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002579 # blob index cannot be out of range
2580 g:testblob = 0z01ab
2581 assert_equal(0x01, g:testblob[0])
2582 assert_equal(0xab, g:testblob[1])
2583 assert_equal(0xab, g:testblob[-1])
2584 assert_equal(0x01, g:testblob[-2])
2585
2586 # blob slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002587 assert_equal(0z01ab, g:testblob[0 : 1])
2588 assert_equal(0z01, g:testblob[0 : 0])
2589 assert_equal(0z01, g:testblob[-2 : -2])
2590 assert_equal(0zab, g:testblob[1 : 1])
2591 assert_equal(0zab, g:testblob[-1 : -1])
2592 assert_equal(0z, g:testblob[2 : 2])
2593 assert_equal(0z, g:testblob[0 : -3])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002594
2595 # list index cannot be out of range
2596 g:testlist = [0, 1, 2, 3]
2597 assert_equal(0, g:testlist[0])
2598 assert_equal(1, g:testlist[1])
2599 assert_equal(3, g:testlist[3])
2600 assert_equal(3, g:testlist[-1])
2601 assert_equal(0, g:testlist[-4])
2602 assert_equal(1, g:testlist[g:theone])
2603
2604 # list slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002605 assert_equal([0], g:testlist[0 : 0])
2606 assert_equal([3], g:testlist[3 : 3])
2607 assert_equal([0, 1], g:testlist[0 : 1])
2608 assert_equal([0, 1, 2, 3], g:testlist[0 : 3])
2609 assert_equal([0, 1, 2, 3], g:testlist[0 : 9])
2610 assert_equal([], g:testlist[-1 : 1])
2611 assert_equal([1], g:testlist[-3 : 1])
2612 assert_equal([0, 1], g:testlist[-4 : 1])
2613 assert_equal([0, 1], g:testlist[-9 : 1])
2614 assert_equal([1, 2, 3], g:testlist[1 : -1])
2615 assert_equal([1], g:testlist[1 : -3])
2616 assert_equal([], g:testlist[1 : -4])
2617 assert_equal([], g:testlist[1 : -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002618
Bram Moolenaare0de1712020-12-02 17:36:54 +01002619 g:testdict = {a: 1, b: 2}
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002620 assert_equal(1, g:testdict['a'])
2621 assert_equal(2, g:testdict['b'])
2622 END
2623
Bram Moolenaar90193e62021-04-04 20:49:50 +02002624 CheckDefAndScriptSuccess(lines)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002625
Bram Moolenaar90193e62021-04-04 20:49:50 +02002626 CheckDefExecAndScriptFailure(['echo g:testblob[2]'], 'E979:', 1)
2627 CheckDefExecAndScriptFailure(['echo g:testblob[-3]'], 'E979:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002628
Bram Moolenaar90193e62021-04-04 20:49:50 +02002629 CheckDefExecAndScriptFailure(['echo g:testlist[4]'], 'E684: list index out of range: 4', 1)
2630 CheckDefExecAndScriptFailure(['echo g:testlist[-5]'], 'E684:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002631
Bram Moolenaar90193e62021-04-04 20:49:50 +02002632 CheckDefExecAndScriptFailure(['echo g:testdict["a" : "b"]'], 'E719:', 1)
2633 CheckDefExecAndScriptFailure(['echo g:testdict[1]'], 'E716:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002634
2635 unlet g:teststring
2636 unlet g:testblob
2637 unlet g:testlist
Bram Moolenaar435d8972020-07-05 16:42:13 +02002638enddef
2639
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002640def Test_expr_member_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002641 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002642 var d = {one:
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002643 'one',
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002644 two: 'two',
2645 1: 1,
2646 _: 2}
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002647 assert_equal('one', d.one)
2648 assert_equal('one', d
2649 .one)
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002650 assert_equal(1, d
2651 .1)
2652 assert_equal(2, d
2653 ._)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002654 assert_equal('one', d[
2655 'one'
2656 ])
2657 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002658 CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002659
2660 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002661 var l = [1,
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002662 2,
2663 3, 4
2664 ]
2665 assert_equal(2, l[
2666 1
2667 ])
2668 assert_equal([2, 3], l[1 : 2])
2669 assert_equal([1, 2, 3], l[
2670 :
2671 2
2672 ])
2673 assert_equal([3, 4], l[
2674 2
2675 :
2676 ])
2677 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002678 CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002679enddef
2680
Bram Moolenaara79925a2021-01-05 17:50:28 +01002681def SetSomeVar()
2682 b:someVar = &fdm
2683enddef
2684
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002685def Test_expr7_option()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002686 var lines =<< trim END
2687 # option
2688 set ts=11
2689 assert_equal(11, &ts)
2690 &ts = 9
2691 assert_equal(9, &ts)
2692 set ts=8
2693 set grepprg=some\ text
2694 assert_equal('some text', &grepprg)
2695 &grepprg = test_null_string()
2696 assert_equal('', &grepprg)
2697 set grepprg&
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01002698
Bram Moolenaar90193e62021-04-04 20:49:50 +02002699 # check matching type
2700 var bval: bool = &tgc
2701 var nval: number = &ts
2702 var sval: string = &path
Bram Moolenaara79925a2021-01-05 17:50:28 +01002703
Bram Moolenaar90193e62021-04-04 20:49:50 +02002704 # check v_lock is cleared (requires using valgrind, doesn't always show)
2705 SetSomeVar()
2706 b:someVar = 0
2707 unlet b:someVar
2708 END
2709 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002710enddef
2711
2712def Test_expr7_environment()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002713 var lines =<< trim END
2714 # environment variable
2715 assert_equal('testvar', $TESTVAR)
2716 assert_equal('', $ASDF_ASD_XXX)
2717 END
2718 CheckDefAndScriptSuccess(lines)
Bram Moolenaarc58164c2020-03-29 18:40:30 +02002719
Bram Moolenaar90193e62021-04-04 20:49:50 +02002720 CheckDefAndScriptFailure2(["var x = $$$"], 'E1002:', 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002721enddef
2722
2723def Test_expr7_register()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002724 var lines =<< trim END
2725 @a = 'register a'
2726 assert_equal('register a', @a)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002727
Bram Moolenaar90193e62021-04-04 20:49:50 +02002728 var fname = expand('%')
2729 assert_equal(fname, @%)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002730
Bram Moolenaar90193e62021-04-04 20:49:50 +02002731 feedkeys(":echo 'some'\<CR>", "xt")
2732 assert_equal("echo 'some'", @:)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002733
Bram Moolenaar90193e62021-04-04 20:49:50 +02002734 normal axyz
2735 assert_equal("xyz", @.)
Bram Moolenaar65821722020-08-02 18:58:54 +02002736
Bram Moolenaar90193e62021-04-04 20:49:50 +02002737 @/ = 'slash'
2738 assert_equal('slash', @/)
Bram Moolenaar65821722020-08-02 18:58:54 +02002739
Bram Moolenaar90193e62021-04-04 20:49:50 +02002740 @= = 'equal'
2741 assert_equal('equal', @=)
2742 END
2743 CheckDefAndScriptSuccess(lines)
2744
2745 CheckDefAndScriptFailure2(["@. = 'yes'"], 'E354:', 'E488:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002746enddef
2747
Bram Moolenaar886e5e72021-04-05 13:36:34 +02002748" This is slow when run under valgrind.
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002749def Test_expr7_namespace()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002750 var lines =<< trim END
2751 g:some_var = 'some'
2752 assert_equal('some', get(g:, 'some_var'))
2753 assert_equal('some', get(g:, 'some_var', 'xxx'))
2754 assert_equal('xxx', get(g:, 'no_var', 'xxx'))
2755 unlet g:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002756
Bram Moolenaar90193e62021-04-04 20:49:50 +02002757 b:some_var = 'some'
2758 assert_equal('some', get(b:, 'some_var'))
2759 assert_equal('some', get(b:, 'some_var', 'xxx'))
2760 assert_equal('xxx', get(b:, 'no_var', 'xxx'))
2761 unlet b:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002762
Bram Moolenaar90193e62021-04-04 20:49:50 +02002763 w:some_var = 'some'
2764 assert_equal('some', get(w:, 'some_var'))
2765 assert_equal('some', get(w:, 'some_var', 'xxx'))
2766 assert_equal('xxx', get(w:, 'no_var', 'xxx'))
2767 unlet w:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002768
Bram Moolenaar90193e62021-04-04 20:49:50 +02002769 t:some_var = 'some'
2770 assert_equal('some', get(t:, 'some_var'))
2771 assert_equal('some', get(t:, 'some_var', 'xxx'))
2772 assert_equal('xxx', get(t:, 'no_var', 'xxx'))
2773 unlet t:some_var
Bram Moolenaar1bd3cb22021-02-24 12:27:31 +01002774
Bram Moolenaar90193e62021-04-04 20:49:50 +02002775 # check using g: in a for loop more than DO_NOT_FREE_CNT times
2776 for i in range(100000)
2777 if has_key(g:, 'does-not-exist')
2778 endif
2779 endfor
2780 END
2781 CheckDefAndScriptSuccess(lines)
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002782enddef
2783
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002784def Test_expr7_parens()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002785 # (expr)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002786 var lines =<< trim END
Bram Moolenaar24156692021-01-14 20:35:49 +01002787 assert_equal(4, (6 * 4) / 6)
2788 assert_equal(0, 6 * ( 4 / 6 ))
2789
2790 assert_equal(6, +6)
2791 assert_equal(-6, -6)
2792 assert_equal(false, !-3)
2793 assert_equal(true, !+0)
2794
2795 assert_equal(7, 5 + (
2796 2))
2797 assert_equal(7, 5 + (
2798 2
2799 ))
2800 assert_equal(7, 5 + ( # comment
2801 2))
2802 assert_equal(7, 5 + ( # comment
2803 # comment
2804 2))
2805
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002806 var s = (
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002807 'one'
2808 ..
2809 'two'
2810 )
2811 assert_equal('onetwo', s)
2812 END
Bram Moolenaar24156692021-01-14 20:35:49 +01002813 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002814enddef
2815
Bram Moolenaar79cdf802020-11-18 17:39:05 +01002816def Test_expr7_negate_add()
Bram Moolenaarb23279d2021-01-05 22:08:20 +01002817 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002818 assert_equal(-99, -99)
2819 assert_equal(-99, - 99)
2820 assert_equal(99, +99)
2821
2822 var nr = 88
2823 assert_equal(-88, -nr)
2824 assert_equal(-88, - nr)
2825 assert_equal(88, + nr)
2826 END
2827 CheckDefAndScriptSuccess(lines)
2828
2829 lines =<< trim END
Bram Moolenaarb23279d2021-01-05 22:08:20 +01002830 var n = 12
2831 echo ++n
2832 END
2833 CheckDefAndScriptFailure(lines, 'E15:')
2834 lines =<< trim END
2835 var n = 12
2836 echo --n
2837 END
2838 CheckDefAndScriptFailure(lines, 'E15:')
2839 lines =<< trim END
2840 var n = 12
2841 echo +-n
2842 END
2843 CheckDefAndScriptFailure(lines, 'E15:')
2844 lines =<< trim END
2845 var n = 12
2846 echo -+n
2847 END
2848 CheckDefAndScriptFailure(lines, 'E15:')
2849 lines =<< trim END
2850 var n = 12
2851 echo - -n
2852 END
2853 CheckDefAndScriptFailure(lines, 'E15:')
2854 lines =<< trim END
2855 var n = 12
2856 echo + +n
2857 END
2858 CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002859enddef
2860
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002861def LegacyReturn(): string
2862 legacy return #{key: 'ok'}.key
2863enddef
2864
Bram Moolenaar15e5e532021-04-07 21:21:13 +02002865def Test_expr7_legacy_script()
2866 var lines =<< trim END
2867 let s:legacy = 'legacy'
2868 def GetLocal(): string
2869 return legacy
2870 enddef
2871 def GetLocalPrefix(): string
2872 return s:legacy
2873 enddef
2874 call assert_equal('legacy', GetLocal())
2875 call assert_equal('legacy', GetLocalPrefix())
2876 END
2877 CheckScriptSuccess(lines)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02002878
2879 assert_equal('ok', LegacyReturn())
2880
2881 lines =<< trim END
2882 vim9script
2883 def GetNumber(): number
2884 legacy return range(3)->map('v:val + 1')
2885 enddef
2886 echo GetNumber()
2887 END
2888 CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<number>')
Bram Moolenaar15e5e532021-04-07 21:21:13 +02002889enddef
2890
Bram Moolenaar6e949782020-04-13 17:21:00 +02002891def Echo(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002892 return arg
2893enddef
2894
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02002895def s:Echo4Arg(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002896 return arg
2897enddef
2898
2899def Test_expr7_call()
Bram Moolenaar659bb222020-11-12 20:16:39 +01002900 var lines =<< trim END
2901 assert_equal('yes', 'yes'->Echo())
2902 assert_equal(true, !range(5)->empty())
Bram Moolenaarb23279d2021-01-05 22:08:20 +01002903 assert_equal([0, 1, 2], 3->range())
Bram Moolenaar659bb222020-11-12 20:16:39 +01002904 END
2905 CheckDefAndScriptSuccess(lines)
2906
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02002907 assert_equal('yes', 'yes'
Bram Moolenaar659bb222020-11-12 20:16:39 +01002908 ->s:Echo4Arg())
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002909
Bram Moolenaar90193e62021-04-04 20:49:50 +02002910 CheckDefAndScriptFailure(["var x = 'yes'->Echo"], 'E107:', 1)
2911 CheckDefAndScriptFailure2([
2912 "var x = substitute ('x', 'x', 'x', 'x')"
2913 ], 'E1001:', 'E121:', 1)
2914 CheckDefAndScriptFailure2(["var Ref = function('len' [1, 2])"], 'E1123:', 'E116:', 1)
Bram Moolenaara1773442020-08-12 15:21:22 +02002915
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002916 var auto_lines =<< trim END
Bram Moolenaara1773442020-08-12 15:21:22 +02002917 def g:some#func(): string
2918 return 'found'
2919 enddef
2920 END
2921 mkdir('Xruntime/autoload', 'p')
2922 writefile(auto_lines, 'Xruntime/autoload/some.vim')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002923 var save_rtp = &rtp
Bram Moolenaara1773442020-08-12 15:21:22 +02002924 &rtp = getcwd() .. '/Xruntime,' .. &rtp
2925 assert_equal('found', g:some#func())
2926 assert_equal('found', some#func())
2927
2928 &rtp = save_rtp
2929 delete('Xruntime', 'rf')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002930enddef
2931
Bram Moolenaar7e368202020-12-25 21:56:57 +01002932def Test_expr7_method_call()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002933 var lines =<< trim END
2934 new
2935 setline(1, ['first', 'last'])
2936 'second'->append(1)
2937 "third"->append(2)
2938 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
2939 bwipe!
Bram Moolenaar7e368202020-12-25 21:56:57 +01002940
Bram Moolenaar90193e62021-04-04 20:49:50 +02002941 var bufnr = bufnr()
2942 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
2943 loclist->setloclist(0)
2944 assert_equal([{bufnr: bufnr,
2945 lnum: 42,
2946 col: 17,
2947 text: 'wrong',
2948 pattern: '',
2949 valid: 1,
2950 vcol: 0,
2951 nr: 0,
2952 type: '',
2953 module: ''}
2954 ], getloclist(0))
Bram Moolenaar7e368202020-12-25 21:56:57 +01002955
Bram Moolenaar90193e62021-04-04 20:49:50 +02002956 var result: bool = get({n: 0}, 'n', 0)
2957 assert_equal(false, result)
Bram Moolenaar7e368202020-12-25 21:56:57 +01002958
Bram Moolenaar90193e62021-04-04 20:49:50 +02002959 assert_equal('+string+', 'string'->((s) => '+' .. s .. '+')())
2960 assert_equal('-text-', 'text'->((s, c) => c .. s .. c)('-'))
Bram Moolenaar7e368202020-12-25 21:56:57 +01002961
Bram Moolenaar90193e62021-04-04 20:49:50 +02002962 var Join = (l) => join(l, 'x')
2963 assert_equal('axb', ['a', 'b']->(Join)())
2964 END
2965 CheckDefAndScriptSuccess(lines)
Bram Moolenaar7e368202020-12-25 21:56:57 +01002966enddef
2967
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002968
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002969def Test_expr7_not()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002970 var lines =<< trim END
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002971 assert_equal(true, !'')
2972 assert_equal(true, ![])
2973 assert_equal(false, !'asdf')
2974 assert_equal(false, ![2])
2975 assert_equal(true, !!'asdf')
2976 assert_equal(true, !![2])
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002977
Bram Moolenaar27491cd2020-10-15 21:54:56 +02002978 assert_equal(true, ! false)
2979 assert_equal(true, !! true)
2980 assert_equal(true, ! ! true)
2981 assert_equal(true, !!! false)
2982 assert_equal(true, ! ! ! false)
2983
2984 g:true = true
2985 g:false = false
2986 assert_equal(true, ! g:false)
2987 assert_equal(true, !! g:true)
2988 assert_equal(true, ! ! g:true)
2989 assert_equal(true, !!! g:false)
2990 assert_equal(true, ! ! ! g:false)
2991 unlet g:true
2992 unlet g:false
2993
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002994 assert_equal(true, !test_null_partial())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002995 assert_equal(false, !() => 'yes')
Bram Moolenaar8ed04582020-02-22 19:07:28 +01002996
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02002997 assert_equal(true, !test_null_dict())
2998 assert_equal(true, !{})
Bram Moolenaare0de1712020-12-02 17:36:54 +01002999 assert_equal(false, !{yes: 'no'})
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003000
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003001 if has('channel')
3002 assert_equal(true, !test_null_job())
3003 assert_equal(true, !test_null_channel())
3004 endif
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003005
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003006 assert_equal(true, !test_null_blob())
3007 assert_equal(true, !0z)
3008 assert_equal(false, !0z01)
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003009
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003010 assert_equal(true, !test_void())
3011 assert_equal(true, !test_unknown())
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003012
3013 assert_equal(false, ![1, 2, 3]->reverse())
3014 assert_equal(true, ![]->reverse())
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003015 END
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003016 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003017enddef
3018
3019func Test_expr7_fails()
Bram Moolenaar5afd0812021-01-03 18:33:13 +01003020 call CheckDefFailure(["var x = (12"], "E1097:", 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003021 call CheckScriptFailure(['vim9script', "var x = (12"], 'E110:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003022
Bram Moolenaar90193e62021-04-04 20:49:50 +02003023 call CheckDefAndScriptFailure(["var x = -'xx'"], "E1030:", 1)
3024 call CheckDefAndScriptFailure(["var x = +'xx'"], "E1030:", 1)
3025 call CheckDefAndScriptFailure(["var x = -0z12"], "E974:", 1)
3026 call CheckDefExecAndScriptFailure2(["var x = -[8]"], "E39:", 'E745:', 1)
3027 call CheckDefExecAndScriptFailure2(["var x = -{a: 1}"], "E39:", 'E728:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003028
Bram Moolenaar90193e62021-04-04 20:49:50 +02003029 call CheckDefAndScriptFailure(["var x = @"], "E1002:", 1)
3030 call CheckDefAndScriptFailure(["var x = @<"], "E354:", 1)
Bram Moolenaar58ceca52020-01-28 22:46:22 +01003031
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003032 call CheckDefFailure(["var x = [1, 2"], "E697:", 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003033 call CheckScriptFailure(['vim9script', "var x = [1, 2"], 'E696:', 2)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003034
Bram Moolenaar90193e62021-04-04 20:49:50 +02003035 call CheckDefAndScriptFailure2(["var x = [notfound]"], "E1001:", 'E121:', 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003036
Bram Moolenaar90193e62021-04-04 20:49:50 +02003037 call CheckDefAndScriptFailure2(["var X = () => 123)"], "E488:", 'E15:', 1)
3038 call CheckDefAndScriptFailure(["var x = 123->((x) => x + 5)"], "E107:", 1)
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01003039
Bram Moolenaar90193e62021-04-04 20:49:50 +02003040 call CheckDefAndScriptFailure(["var x = &notexist"], 'E113:', 1)
3041 call CheckDefAndScriptFailure2(["&grepprg = [343]"], 'E1012:', 'E730:', 1)
Bram Moolenaar09f28f42020-02-20 23:08:34 +01003042
Bram Moolenaar90193e62021-04-04 20:49:50 +02003043 call CheckDefExecAndScriptFailure(["echo s:doesnt_exist"], 'E121:', 1)
3044 call CheckDefExecAndScriptFailure(["echo g:doesnt_exist"], 'E121:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003045
Bram Moolenaar90193e62021-04-04 20:49:50 +02003046 call CheckDefAndScriptFailure2(["echo a:somevar"], 'E1075:', 'E121:', 1)
3047 call CheckDefAndScriptFailure2(["echo l:somevar"], 'E1075:', 'E121:', 1)
3048 call CheckDefAndScriptFailure2(["echo x:somevar"], 'E1075:', 'E121:', 1)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01003049
Bram Moolenaar90193e62021-04-04 20:49:50 +02003050 call CheckDefExecAndScriptFailure(["var x = +g:astring"], 'E1030:', 1)
3051 call CheckDefExecAndScriptFailure(["var x = +g:ablob"], 'E974:', 1)
3052 call CheckDefExecAndScriptFailure(["var x = +g:alist"], 'E745:', 1)
3053 call CheckDefExecAndScriptFailure(["var x = +g:adict"], 'E728:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003054
Bram Moolenaar90193e62021-04-04 20:49:50 +02003055 call CheckDefAndScriptFailure2(["var x = ''", "var y = x.memb"], 'E715:', 'E15:', 2)
3056
3057 call CheckDefAndScriptFailure2(["'yes'->", "Echo()"], 'E488: Trailing characters: ->', 'E260: Missing name after ->', 1)
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003058
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003059 call CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003060 call CheckScriptFailure(['vim9script', "[1, 2->len()"], 'E696:', 2)
3061
3062 call CheckDefFailure(["{a: 1->len()"], 'E723:', 2)
3063 call CheckScriptFailure(['vim9script', "{a: 1->len()"], 'E722:', 2)
3064
Bram Moolenaare0de1712020-12-02 17:36:54 +01003065 call CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003066 call CheckScriptFailure(['vim9script', "{['a']: 1->len()"], 'E722:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003067endfunc
3068
3069let g:Funcrefs = [function('add')]
3070
3071func CallMe(arg)
3072 return a:arg
3073endfunc
3074
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003075func CallMe2(one, two)
3076 return a:one .. a:two
3077endfunc
3078
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003079def Test_expr7_trailing()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003080 var lines =<< trim END
3081 # user function call
3082 assert_equal(123, g:CallMe(123))
3083 assert_equal(123, g:CallMe( 123))
3084 assert_equal(123, g:CallMe(123 ))
3085 assert_equal('yesno', g:CallMe2('yes', 'no'))
3086 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
3087 assert_equal('nothing', g:CallMe('nothing'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003088
Bram Moolenaar90193e62021-04-04 20:49:50 +02003089 # partial call
3090 var Part = function('g:CallMe')
3091 assert_equal('yes', Part('yes'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003092
Bram Moolenaar90193e62021-04-04 20:49:50 +02003093 # funcref call, using list index
3094 var l = []
3095 g:Funcrefs[0](l, 2)
3096 assert_equal([2], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003097
Bram Moolenaar90193e62021-04-04 20:49:50 +02003098 # method call
3099 l = [2, 5, 6]
3100 l->map((k, v) => k + v)
3101 assert_equal([2, 6, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003102
Bram Moolenaar90193e62021-04-04 20:49:50 +02003103 # lambda method call
3104 l = [2, 5]
3105 l->((ll) => add(ll, 8))()
3106 assert_equal([2, 5, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003107
Bram Moolenaar90193e62021-04-04 20:49:50 +02003108 # dict member
3109 var d = {key: 123}
3110 assert_equal(123, d.key)
3111 END
3112 CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003113enddef
3114
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003115def Test_expr7_string_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003116 var lines =<< trim END
3117 var text = 'abcdef'
Bram Moolenaare7525c52021-01-09 13:20:37 +01003118 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003119 assert_equal('a', text[0])
3120 assert_equal('e', text[4])
3121 assert_equal('f', text[5])
3122 assert_equal('', text[6])
3123
Bram Moolenaare7525c52021-01-09 13:20:37 +01003124 text = 'ábçdë'
3125 assert_equal('ë', text[-1])
3126 assert_equal('d', text[-2])
3127 assert_equal('ç', text[-3])
3128 assert_equal('b', text[-4])
3129 assert_equal('á', text[-5])
3130 assert_equal('', text[-6])
3131
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003132 text = 'ábçdëf'
3133 assert_equal('', text[-999])
Bram Moolenaare7525c52021-01-09 13:20:37 +01003134 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003135 assert_equal('á', text[0])
3136 assert_equal('b', text[1])
3137 assert_equal('ç', text[2])
3138 assert_equal('d', text[3])
3139 assert_equal('ë', text[4])
3140 assert_equal('f', text[5])
3141 assert_equal('', text[6])
3142 assert_equal('', text[999])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003143
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003144 assert_equal('ábçdëf', text[0 : -1])
3145 assert_equal('ábçdëf', text[0 : -1])
3146 assert_equal('ábçdëf', text[0 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003147 assert_equal('ábçdëf', text[0 : -1])
3148 assert_equal('ábçdëf', text[0
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003149 : -1])
3150 assert_equal('ábçdëf', text[0 :
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003151 -1])
3152 assert_equal('ábçdëf', text[0 : -1
3153 ])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003154 assert_equal('bçdëf', text[1 : -1])
3155 assert_equal('çdëf', text[2 : -1])
3156 assert_equal('dëf', text[3 : -1])
3157 assert_equal('ëf', text[4 : -1])
3158 assert_equal('f', text[5 : -1])
3159 assert_equal('', text[6 : -1])
3160 assert_equal('', text[999 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003161
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003162 assert_equal('ábçd', text[: 3])
3163 assert_equal('bçdëf', text[1 :])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003164 assert_equal('ábçdëf', text[:])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003165
3166 assert_equal('a', g:astring[0])
3167 assert_equal('sd', g:astring[1 : 2])
3168 assert_equal('asdf', g:astring[:])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003169 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003170 CheckDefAndScriptSuccess(lines)
Bram Moolenaar918a4242020-12-06 14:37:08 +01003171
3172 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003173 var d = 'asdf'[1 :
Bram Moolenaar918a4242020-12-06 14:37:08 +01003174 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01003175 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003176 CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
3177
Bram Moolenaar918a4242020-12-06 14:37:08 +01003178 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003179 var d = 'asdf'[1 : xxx]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003180 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003181 CheckDefAndScriptFailure2(lines, 'E1001:', 'E121:', 1)
3182
Bram Moolenaar918a4242020-12-06 14:37:08 +01003183 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003184 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003185 END
Bram Moolenaar8ff16e02020-12-07 21:49:52 +01003186 CheckDefFailure(lines, 'E1097:', 3)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003187 CheckScriptFailure(['vim9script'] + lines, 'E111:', 2)
3188
Bram Moolenaar918a4242020-12-06 14:37:08 +01003189 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003190 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003191 echo d
3192 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003193 CheckDefAndScriptFailure(lines, 'E111:', 2)
3194
Bram Moolenaar918a4242020-12-06 14:37:08 +01003195 lines =<< trim END
3196 var d = 'asdf'['1']
3197 echo d
3198 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003199 CheckDefAndScriptFailure2(lines, 'E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "1"', 1)
3200
Bram Moolenaar918a4242020-12-06 14:37:08 +01003201 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003202 var d = 'asdf'['1' : 2]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003203 echo d
3204 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003205 CheckDefAndScriptFailure2(lines, 'E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "1"', 1)
3206
Bram Moolenaar918a4242020-12-06 14:37:08 +01003207 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003208 var d = 'asdf'[1 : '2']
Bram Moolenaar918a4242020-12-06 14:37:08 +01003209 echo d
3210 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003211 CheckDefAndScriptFailure2(lines, 'E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "2"', 1)
Bram Moolenaarbf9d8c32020-07-19 17:55:44 +02003212enddef
3213
Bram Moolenaared591872020-08-15 22:14:53 +02003214def Test_expr7_list_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003215 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003216 var list = [0, 1, 2, 3, 4]
3217 assert_equal(0, list[0])
3218 assert_equal(4, list[4])
3219 assert_equal(4, list[-1])
3220 assert_equal(0, list[-5])
Bram Moolenaared591872020-08-15 22:14:53 +02003221
Bram Moolenaar90193e62021-04-04 20:49:50 +02003222 assert_equal([0, 1, 2, 3, 4], list[0 : 4])
3223 assert_equal([0, 1, 2, 3, 4], list[:])
3224 assert_equal([1, 2, 3, 4], list[1 :])
3225 assert_equal([2, 3, 4], list[2 : -1])
3226 assert_equal([4], list[4 : -1])
3227 assert_equal([], list[5 : -1])
3228 assert_equal([], list[999 : -1])
3229 assert_equal([1, 2, 3, 4], list[g:theone : g:thefour])
Bram Moolenaared591872020-08-15 22:14:53 +02003230
Bram Moolenaar90193e62021-04-04 20:49:50 +02003231 assert_equal([0, 1, 2, 3], list[0 : 3])
3232 assert_equal([0], list[0 : 0])
3233 assert_equal([0, 1, 2, 3, 4], list[0 : -1])
3234 assert_equal([0, 1, 2], list[0 : -3])
3235 assert_equal([0], list[0 : -5])
3236 assert_equal([], list[0 : -6])
3237 assert_equal([], list[0 : -99])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003238
3239 assert_equal(2, g:alist[0])
3240 assert_equal([2, 3, 4], g:alist[:])
Bram Moolenaared591872020-08-15 22:14:53 +02003241 END
Bram Moolenaare7525c52021-01-09 13:20:37 +01003242 CheckDefAndScriptSuccess(lines)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003243
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003244 lines = ['var l = [0, 1, 2]', 'echo l[g:astring : g:theone]']
Bram Moolenaar90193e62021-04-04 20:49:50 +02003245 CheckDefExecAndScriptFailure2(lines, 'E1012:', 'E1030:', 2)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003246
3247 lines =<< trim END
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003248 var ld = []
3249 def Func()
3250 eval ld[0].key
3251 enddef
3252 defcompile
3253 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003254 CheckDefAndScriptSuccess(lines)
Bram Moolenaared591872020-08-15 22:14:53 +02003255enddef
3256
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003257def Test_expr7_dict_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003258 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01003259 var l = [{lnum: 2}, {lnum: 1}]
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003260 var res = l[0].lnum > l[1].lnum
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003261 assert_true(res)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003262
Bram Moolenaar261417b2021-05-06 21:04:55 +02003263 assert_equal(2, g:adict['aaa'])
3264 assert_equal(8, g:adict.bbb)
3265
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003266 var dd = {}
3267 def Func1()
3268 eval dd.key1.key2
3269 enddef
3270 def Func2()
3271 eval dd['key1'].key2
3272 enddef
3273 defcompile
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003274 END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003275 CheckDefAndScriptSuccess(lines)
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003276enddef
3277
Bram Moolenaar261417b2021-05-06 21:04:55 +02003278def Test_expr7_blob_subscript()
3279 var lines =<< trim END
3280 var b = 0z112233
3281 assert_equal(0x11, b[0])
3282 assert_equal(0z112233, b[:])
3283
3284 assert_equal(0x01, g:ablob[0])
3285 assert_equal(0z01ab, g:ablob[:])
3286 END
3287 CheckDefAndScriptSuccess(lines)
3288enddef
3289
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003290def Test_expr7_subscript_linebreak()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003291 var lines =<< trim END
3292 var range = range(
3293 3)
3294 var l = range
3295 ->mapnew('string(v:key)')
3296 assert_equal(['0', '1', '2'], l)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003297
Bram Moolenaar90193e62021-04-04 20:49:50 +02003298 l = range
3299 ->mapnew('string(v:key)')
3300 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003301
Bram Moolenaar90193e62021-04-04 20:49:50 +02003302 l = range # comment
3303 ->mapnew('string(v:key)')
3304 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003305
Bram Moolenaar90193e62021-04-04 20:49:50 +02003306 l = range
Bram Moolenaar23c55272020-06-21 16:58:13 +02003307
Bram Moolenaar90193e62021-04-04 20:49:50 +02003308 ->mapnew('string(v:key)')
3309 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003310
Bram Moolenaar90193e62021-04-04 20:49:50 +02003311 l = range
3312 # comment
3313 ->mapnew('string(v:key)')
3314 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003315
Bram Moolenaar90193e62021-04-04 20:49:50 +02003316 assert_equal('1', l[
3317 1])
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003318
Bram Moolenaar90193e62021-04-04 20:49:50 +02003319 var d = {one: 33}
3320 assert_equal(33, d
3321 .one)
3322 END
3323 CheckDefAndScriptSuccess(lines)
3324
3325 lines =<< trim END
3326 var d = {one: 33}
3327 assert_equal(33, d.
3328 one)
3329 END
3330 CheckDefAndScriptFailure2(lines, 'E1127:', 'E116:', 2)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003331enddef
3332
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003333func Test_expr7_trailing_fails()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003334 call CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8))'], 'E107:', 2)
3335 call CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8)) ()'], 'E274:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003336endfunc
3337
3338func Test_expr_fails()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003339 call CheckDefAndScriptFailure2(["var x = '1'is2"], 'E488:', 'E15:', 1)
3340 call CheckDefAndScriptFailure2(["var x = '1'isnot2"], 'E488:', 'E15:', 1)
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003341
Bram Moolenaar90193e62021-04-04 20:49:50 +02003342 call CheckDefAndScriptFailure2(["CallMe ('yes')"], 'E476:', 'E492:', 1)
3343
Bram Moolenaarba7c0d72020-09-09 18:54:42 +02003344 call CheckDefAndScriptFailure(["CallMe2('yes','no')"], 'E1069:', 1)
Bram Moolenaar0c2ca582020-02-25 22:58:29 +01003345
Bram Moolenaar90193e62021-04-04 20:49:50 +02003346 call CheckDefAndScriptFailure2(["v:nosuch += 3"], 'E1001:', 'E121:', 1)
3347 call CheckDefAndScriptFailure(["var v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:', 1)
3348 call CheckDefAndScriptFailure2(["var asdf = v:nosuch"], 'E1001:', 'E121:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003349
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02003350 call CheckDefFailure(["echo len('asdf'"], 'E110:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003351 call CheckScriptFailure(['vim9script', "echo len('asdf'"], 'E116:', 2)
3352
3353 call CheckDefAndScriptFailure2(["echo Func0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], 'E1011:', 'E117:', 1)
3354 call CheckDefAndScriptFailure(["echo doesnotexist()"], 'E117:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003355endfunc
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02003356
3357" vim: shiftwidth=2 sts=2 expandtab