blob: 38b2afecd5920361671ab2d630c6908e3c39d8d2 [file] [log] [blame]
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001" Tests for Vim9 script expressions
2
3source check.vim
Bram Moolenaar62aec932022-01-29 21:45:34 +00004import './vim9.vim' as v9
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
=?UTF-8?q?Dundar=20G=C3=B6c?=e41c1dd2022-02-26 11:46:13 +000015def Test_expr1_ternary()
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')
Bram Moolenaar7a40ff02021-07-04 15:54:08 +020060 var RetTwo: func(string): number = function('charcol')
Bram Moolenaar659bb222020-11-12 20:16:39 +010061 var RetThat: func = g:atrue ? RetOne : RetTwo
62 assert_equal(function('len'), RetThat)
Bram Moolenaarc7db5772020-07-21 20:55:50 +020063
Bram Moolenaar848fadd2022-01-30 15:28:30 +000064 var X = g:FuncOne
65 var Y = g:FuncTwo
66 var Z = g:cond ? g:FuncOne : g:FuncTwo
Bram Moolenaar659bb222020-11-12 20:16:39 +010067 assert_equal(123, Z(3))
68 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000069 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar848fadd2022-01-30 15:28:30 +000070
71 lines =<< trim END
72 var Z = g:cond ? FuncOne : FuncTwo
73 END
74 v9.CheckDefAndScriptFailure(lines, ['E1001: Variable not found: FuncOne', 'E121: Undefined variable: FuncTwo'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010075enddef
76
=?UTF-8?q?Dundar=20G=C3=B6c?=e41c1dd2022-02-26 11:46:13 +000077def Test_expr1_ternary_vimscript()
Bram Moolenaarfdac71c2020-08-05 12:44:41 +020078 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +020079 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +020080 var name = 1
Bram Moolenaar793648f2020-06-26 21:28:25 +020081 ? 'yes'
82 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020083 assert_equal('yes', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020084 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000085 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar793648f2020-06-26 21:28:25 +020086
87 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +020088 var name = v:false
Bram Moolenaar793648f2020-06-26 21:28:25 +020089 ? 'yes'
90 : 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020091 assert_equal('no', name)
Bram Moolenaar793648f2020-06-26 21:28:25 +020092 END
Bram Moolenaar62aec932022-01-29 21:45:34 +000093 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +020094
95 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +020096 var name = v:false ?
Bram Moolenaar9215f012020-06-27 21:18:00 +020097 'yes' :
98 'no'
Bram Moolenaar98309382020-09-27 21:58:45 +020099 assert_equal('no', name)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200100 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000101 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200102
Bram Moolenaar93be1642020-10-11 21:34:41 +0200103 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200104 var name = v:false ? # comment
105 'yes' :
106 # comment
107 'no' # comment
108 assert_equal('no', name)
109 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000110 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200111
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200112 # check white space
113 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 Moolenaar62aec932022-01-29 21:45:34 +0000116 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''?'' at "?1:2"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200117
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 Moolenaar62aec932022-01-29 21:45:34 +0000121 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200122
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 Moolenaar62aec932022-01-29 21:45:34 +0000126 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200127
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 Moolenaar62aec932022-01-29 21:45:34 +0000131 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after '':'' at ": 2"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200132
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200133 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200134 var name = v:true ? 1 :2
Bram Moolenaarfdac71c2020-08-05 12:44:41 +0200135 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000136 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar69e445522020-08-22 22:37:20 +0200137
Bram Moolenaar13106602020-10-04 16:06:05 +0200138 lines =<< trim END
Bram Moolenaar13106602020-10-04 16:06:05 +0200139 var name = 'x' ? 1 : 2
140 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000141 v9.CheckDefAndScriptFailure(lines, 'E1135:', 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 Moolenaar62aec932022-01-29 21:45:34 +0000146 v9.CheckDefExecAndScriptFailure(lines, 'E745:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200147
148 lines =<< trim END
Bram Moolenaar13106602020-10-04 16:06:05 +0200149 var name = {} ? 1 : 2
150 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000151 v9.CheckDefExecAndScriptFailure(lines, 'E728:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200152
Bram Moolenaar69e445522020-08-22 22:37:20 +0200153 # check after failure eval_flags is reset
154 lines =<< trim END
Bram Moolenaar69e445522020-08-22 22:37:20 +0200155 try
Bram Moolenaard2c61702020-09-06 15:58:36 +0200156 eval('0 ? 1: 2')
Bram Moolenaar69e445522020-08-22 22:37:20 +0200157 catch
158 endtry
159 assert_equal(v:true, eval(string(v:true)))
160 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000161 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar69e445522020-08-22 22:37:20 +0200162
163 lines =<< trim END
Bram Moolenaar69e445522020-08-22 22:37:20 +0200164 try
Bram Moolenaard2c61702020-09-06 15:58:36 +0200165 eval('0 ? 1 :2')
Bram Moolenaar69e445522020-08-22 22:37:20 +0200166 catch
167 endtry
168 assert_equal(v:true, eval(string(v:true)))
169 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000170 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar793648f2020-06-26 21:28:25 +0200171enddef
172
=?UTF-8?q?Dundar=20G=C3=B6c?=e41c1dd2022-02-26 11:46:13 +0000173func Test_expr1_ternary_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +0000174 call v9.CheckDefAndScriptFailure(["var x = 1 ? 'one'"], "Missing ':' after '?'", 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100175
Bram Moolenaar77072282020-09-16 17:55:40 +0200176 let msg = "White space required before and after '?'"
Bram Moolenaar62aec932022-01-29 21:45:34 +0000177 call v9.CheckDefAndScriptFailure(["var x = 1? 'one' : 'two'"], msg, 1)
178 call v9.CheckDefAndScriptFailure(["var x = 1 ?'one' : 'two'"], msg, 1)
179 call v9.CheckDefAndScriptFailure(["var x = 1?'one' : 'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200180 let lines =<< trim END
181 var x = 1
182 ?'one' : 'two'
183 # comment
184 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000185 call v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''?'' at "?''one'' : ''two''"', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100186
Bram Moolenaar77072282020-09-16 17:55:40 +0200187 let msg = "White space required before and after ':'"
Bram Moolenaar62aec932022-01-29 21:45:34 +0000188 call v9.CheckDefAndScriptFailure(["var x = 1 ? 'one': 'two'"], msg, 1)
189 call v9.CheckDefAndScriptFailure(["var x = 1 ? 'one' :'two'"], msg, 1)
190 call v9.CheckDefAndScriptFailure(["var x = 1 ? 'one':'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200191 let lines =<< trim END
192 var x = 1 ? 'one'
193 :'two'
194 # Comment
195 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000196 call v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after '':'' at ":''two''"', 2)
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200197
Bram Moolenaar62aec932022-01-29 21:45:34 +0000198 call v9.CheckDefAndScriptFailure(["var x = 'x' ? 'one' : 'two'"], 'E1135:', 1)
199 call v9.CheckDefAndScriptFailure(["var x = 0z1234 ? 'one' : 'two'"], 'E974:', 1)
200 call v9.CheckDefExecAndScriptFailure(["var x = [] ? 'one' : 'two'"], 'E745:', 1)
201 call v9.CheckDefExecAndScriptFailure(["var x = {} ? 'one' : 'two'"], 'E728:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200202
Bram Moolenaar62aec932022-01-29 21:45:34 +0000203 call v9.CheckDefExecFailure(["var x = false ? "], 'E1097:', 3)
204 call v9.CheckScriptFailure(['vim9script', "var x = false ? "], 'E15:', 2)
205 call v9.CheckDefExecFailure(["var x = false ? 'one' : "], 'E1097:', 3)
206 call v9.CheckScriptFailure(['vim9script', "var x = false ? 'one' : "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100207
Bram Moolenaar62aec932022-01-29 21:45:34 +0000208 call v9.CheckDefExecAndScriptFailure(["var x = true ? xxx : 'foo'"], ['E1001:', 'E121:'], 1)
209 call v9.CheckDefExecAndScriptFailure(["var x = false ? 'foo' : xxx"], ['E1001:', 'E121:'], 1)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100210
Bram Moolenaar13106602020-10-04 16:06:05 +0200211 if has('float')
Bram Moolenaar62aec932022-01-29 21:45:34 +0000212 call v9.CheckDefAndScriptFailure(["var x = 0.1 ? 'one' : 'two'"], 'E805:', 1)
Bram Moolenaar13106602020-10-04 16:06:05 +0200213 endif
214
Bram Moolenaarc7db5772020-07-21 20:55:50 +0200215 " missing argument detected even when common type is used
Bram Moolenaar62aec932022-01-29 21:45:34 +0000216 call v9.CheckDefAndScriptFailure([
Bram Moolenaar848fadd2022-01-30 15:28:30 +0000217 \ 'var X = g:FuncOne',
218 \ 'var Y = g:FuncTwo',
219 \ 'var Z = g:cond ? g:FuncOne : g:FuncTwo',
Bram Moolenaar3affe7a2020-08-18 20:34:13 +0200220 \ 'Z()'], 'E119:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100221endfunc
222
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200223def Test_expr1_falsy()
224 var lines =<< trim END
225 assert_equal(v:true, v:true ?? 456)
226 assert_equal(123, 123 ?? 456)
227 assert_equal('yes', 'yes' ?? 456)
228 assert_equal([1], [1] ?? 456)
Bram Moolenaare0de1712020-12-02 17:36:54 +0100229 assert_equal({one: 1}, {one: 1} ?? 456)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200230 if has('float')
231 assert_equal(0.1, 0.1 ?? 456)
232 endif
233
234 assert_equal(456, v:false ?? 456)
235 assert_equal(456, 0 ?? 456)
236 assert_equal(456, '' ?? 456)
237 assert_equal(456, [] ?? 456)
238 assert_equal(456, {} ?? 456)
239 if has('float')
240 assert_equal(456, 0.0 ?? 456)
241 endif
242 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000243 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200244
245 var msg = "White space required before and after '??'"
Bram Moolenaar62aec932022-01-29 21:45:34 +0000246 call v9.CheckDefAndScriptFailure(["var x = 1?? 'one' : 'two'"], msg, 1)
247 call v9.CheckDefAndScriptFailure(["var x = 1 ??'one' : 'two'"], msg, 1)
248 call v9.CheckDefAndScriptFailure(["var x = 1??'one' : 'two'"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200249 lines =<< trim END
250 var x = 1
251 ??'one' : 'two'
252 #comment
253 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000254 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''??'' at "??''one'' : ''two''"', 2)
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200255enddef
256
Bram Moolenaar62aec932022-01-29 21:45:34 +0000257def g:Record(val: any): any
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100258 g:vals->add(val)
259 return val
260enddef
261
262" test ||
263def Test_expr2()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100264 var lines =<< trim END
265 assert_equal(true, 1 || 0)
266 assert_equal(true, 0 ||
267 0 ||
268 1)
269 assert_equal(true, 0 ||
270 0 ||
271 !!7)
272 assert_equal(false, 0 || 0)
273 assert_equal(false, 0
274 || 0)
275 assert_equal(false, 0 || false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100276
Bram Moolenaar659bb222020-11-12 20:16:39 +0100277 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000278 assert_equal(true, g:Record(1) || g:Record(3))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100279 assert_equal([1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100280
Bram Moolenaar659bb222020-11-12 20:16:39 +0100281 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000282 assert_equal(true, g:Record(0) || g:Record(1))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100283 assert_equal([0, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100284
Bram Moolenaar659bb222020-11-12 20:16:39 +0100285 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000286 assert_equal(true, g:Record(0) || g:Record(true))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100287 assert_equal([0, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100288
Bram Moolenaar659bb222020-11-12 20:16:39 +0100289 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000290 assert_equal(true, g:Record(0)
291 || g:Record(1)
292 || g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100293 assert_equal([0, 1], g:vals)
294
295 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000296 assert_equal(true, g:Record(0)
297 || g:Record(true)
298 || g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100299 assert_equal([0, true], g:vals)
300
301 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000302 assert_equal(true, g:Record(true) || g:Record(false))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100303 assert_equal([true], g:vals)
304
305 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000306 assert_equal(false, g:Record(0) || g:Record(false) || g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100307 assert_equal([0, false, 0], g:vals)
Bram Moolenaaraf8ea0d2021-04-11 18:24:46 +0200308
309 g:vals = []
310 var x = 1
311 if x || true
312 g:vals = [1]
313 endif
314 assert_equal([1], g:vals)
315
316 g:vals = []
317 x = 3
318 if true || x
319 g:vals = [1]
320 endif
321 assert_equal([1], g:vals)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100322 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000323 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100324enddef
325
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200326def Test_expr2_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200327 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200328 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200329 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200330 || 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200331 assert_equal(true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200332 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000333 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200334
335 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200336 var name = v:false
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200337 || v:true
338 || v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200339 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200340 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000341 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200342
343 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200344 var name = v:false ||
Bram Moolenaar9215f012020-06-27 21:18:00 +0200345 v:true ||
346 v:false
Bram Moolenaar98309382020-09-27 21:58:45 +0200347 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200348 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000349 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200350
Bram Moolenaar93be1642020-10-11 21:34:41 +0200351 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200352 var name = v:false || # comment
353 # comment
354 v:true ||
355 # comment
356 v:false # comment
357 assert_equal(v:true, name)
358 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000359 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200360
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200361 # check white space
362 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 Moolenaar62aec932022-01-29 21:45:34 +0000365 v9.CheckDefExecAndScriptFailure(lines, 'E1004: White space required before and after ''||'' at "||v:true"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200366
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 Moolenaar62aec932022-01-29 21:45:34 +0000370 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200371
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200372 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200373 var name = v:true|| v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200374 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000375 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200376enddef
377
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200378def Test_expr2_fails()
379 var msg = "White space required before and after '||'"
Bram Moolenaar62aec932022-01-29 21:45:34 +0000380 v9.CheckDefAndScriptFailure(["var x = 1||0"], msg, 1)
381 v9.CheckDefAndScriptFailure(["var x = 1 ||0"], msg, 1)
382 v9.CheckDefAndScriptFailure(["var x = 1|| 0"], msg, 1)
Bram Moolenaara8c17702020-04-01 21:17:24 +0200383
Bram Moolenaar62aec932022-01-29 21:45:34 +0000384 v9.CheckDefFailure(["var x = false || "], 'E1097:', 3)
385 v9.CheckScriptFailure(['vim9script', "var x = false || "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100386
Bram Moolenaar90193e62021-04-04 20:49:50 +0200387 # script does not fail, the second expression is skipped
Bram Moolenaar62aec932022-01-29 21:45:34 +0000388 v9.CheckDefFailure(["var x = 1 || xxx"], 'E1001:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200389
Bram Moolenaar62aec932022-01-29 21:45:34 +0000390 v9.CheckDefAndScriptFailure(["var x = [] || false"], ['E1012:', 'E745:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200391
Bram Moolenaar62aec932022-01-29 21:45:34 +0000392 v9.CheckDefAndScriptFailure(["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 +0200393
Bram Moolenaar62aec932022-01-29 21:45:34 +0000394 v9.CheckDefAndScriptFailure(["var x = 3 || false"], ['E1012:', 'E1023:'], 1)
395 v9.CheckDefAndScriptFailure(["var x = false || 3"], ['E1012:', 'E1023:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200396
Bram Moolenaar62aec932022-01-29 21:45:34 +0000397 v9.CheckDefAndScriptFailure(["if 3"], 'E1023:', 1)
398 v9.CheckDefExecAndScriptFailure(['var x = 3', 'if x', 'endif'], 'E1023:', 2)
Bram Moolenaaraf8ea0d2021-04-11 18:24:46 +0200399
Bram Moolenaar62aec932022-01-29 21:45:34 +0000400 v9.CheckDefAndScriptFailure(["var x = [] || false"], ['E1012: Type mismatch; expected bool but got list<unknown>', 'E745:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200401
mityu4ac198c2021-05-28 17:52:40 +0200402 var lines =<< trim END
403 vim9script
404 echo false
405 ||true
406 # comment
407 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000408 v9.CheckScriptFailure(lines, 'E1004: White space required before and after ''||'' at "||true"', 3)
Bram Moolenaar9e60e892021-07-15 15:40:58 +0200409
410 lines =<< trim END
411 var x = false
412 || false
413 || a.b
414 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000415 v9.CheckDefFailure(lines, 'E1001:', 3)
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200416enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100417
418" test &&
419def Test_expr3()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100420 var lines =<< trim END
421 assert_equal(false, 1 && 0)
422 assert_equal(false, 0 &&
423 0 &&
424 1)
425 assert_equal(true, 1
426 && true
427 && 1)
428 assert_equal(false, 0 && 0)
429 assert_equal(false, 0 && false)
430 assert_equal(true, 1 && true)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100431
Bram Moolenaar659bb222020-11-12 20:16:39 +0100432 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000433 assert_equal(true, g:Record(true) && g:Record(1))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100434 assert_equal([true, 1], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100435
Bram Moolenaar659bb222020-11-12 20:16:39 +0100436 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000437 assert_equal(true, g:Record(1) && g:Record(true))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100438 assert_equal([1, true], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100439
Bram Moolenaar659bb222020-11-12 20:16:39 +0100440 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000441 assert_equal(false, g:Record(0) && g:Record(1))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100442 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100443
Bram Moolenaar659bb222020-11-12 20:16:39 +0100444 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000445 assert_equal(false, g:Record(0) && g:Record(1) && g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100446 assert_equal([0], g:vals)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100447
Bram Moolenaar659bb222020-11-12 20:16:39 +0100448 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000449 assert_equal(false, g:Record(0) && g:Record(4) && g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100450 assert_equal([0], g:vals)
451
452 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000453 assert_equal(false, g:Record(1) && g:Record(true) && g:Record(0))
Bram Moolenaar659bb222020-11-12 20:16:39 +0100454 assert_equal([1, true, 0], g:vals)
455 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000456 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100457enddef
458
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200459def Test_expr3_vimscript()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200460 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200461 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200462 var name = 0
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200463 && 1
Bram Moolenaar2bb26582020-10-03 22:52:39 +0200464 assert_equal(false, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200465 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000466 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200467
468 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200469 var name = v:true
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200470 && v:true
471 && v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200472 assert_equal(v:true, name)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200473 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000474 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +0200475
476 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200477 var name = v:true &&
Bram Moolenaar9215f012020-06-27 21:18:00 +0200478 v:true &&
479 v:true
Bram Moolenaar98309382020-09-27 21:58:45 +0200480 assert_equal(v:true, name)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200481 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000482 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8c34ea52020-07-13 22:29:02 +0200483
Bram Moolenaar93be1642020-10-11 21:34:41 +0200484 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +0200485 var name = v:true && # comment
486 # comment
487 v:true &&
488 # comment
489 v:true
490 assert_equal(v:true, name)
491 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000492 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +0200493
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200494 # check white space
495 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200496 var name = v:true&&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200497 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000498 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200499
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200500 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200501 var name = v:true &&v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200502 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000503 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''&&'' at "&&v:true"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +0200504
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200505 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200506 var name = v:true&& v:true
Bram Moolenaar3c1c9fd2020-08-05 12:32:38 +0200507 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000508 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbe7ee482020-06-26 21:38:51 +0200509enddef
510
Bram Moolenaara7511c02021-04-03 21:47:07 +0200511def Test_expr3_fails()
512 var msg = "White space required before and after '&&'"
Bram Moolenaar62aec932022-01-29 21:45:34 +0000513 v9.CheckDefAndScriptFailure(["var x = 1&&0"], msg, 1)
514 v9.CheckDefAndScriptFailure(["var x = 1 &&0"], msg, 1)
515 v9.CheckDefAndScriptFailure(["var x = 1&& 0"], msg, 1)
mityu4ac198c2021-05-28 17:52:40 +0200516 var lines =<< trim END
517 var x = 1
Bram Moolenaar05bd9782021-07-21 21:37:28 +0200518 &&0
mityu4ac198c2021-05-28 17:52:40 +0200519 # comment
520 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000521 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''&&'' at "&&0"', 2)
Bram Moolenaarea2d4072020-11-12 12:08:51 +0100522
Bram Moolenaar90193e62021-04-04 20:49:50 +0200523 g:vals = []
Bram Moolenaar62aec932022-01-29 21:45:34 +0000524 v9.CheckDefAndScriptFailure(["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 +0100525
Bram Moolenaar62aec932022-01-29 21:45:34 +0000526 v9.CheckDefExecAndScriptFailure(['assert_equal(false, g:Record(1) && g:Record(4) && g:Record(0))'], 'E1023: Using a Number as a Bool: 4', 1)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200527
mityu4ac198c2021-05-28 17:52:40 +0200528 lines =<< trim END
Bram Moolenaara7511c02021-04-03 21:47:07 +0200529 if 3
530 && true
531 endif
532 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000533 v9.CheckDefAndScriptFailure(lines, ['E1012:', 'E1023:'], 1)
Bram Moolenaar05bd9782021-07-21 21:37:28 +0200534
535 lines =<< trim END
536 if true
537 && 3
538 endif
539 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000540 v9.CheckDefAndScriptFailure(lines, ['E1012:', 'E1023:'], 2)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200541
542 lines =<< trim END
543 if 'yes'
544 && true
545 endif
546 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000547 v9.CheckDefAndScriptFailure(lines, ['E1012:', 'E1135: Using a String as a Bool'], 1)
Bram Moolenaara7511c02021-04-03 21:47:07 +0200548enddef
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100549
Bram Moolenaar56acb092020-08-16 14:48:19 +0200550" global variables to use for tests with the "any" type
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100551let atrue = v:true
552let afalse = v:false
553let anone = v:none
554let anull = v:null
555let anint = 10
Bram Moolenaar56acb092020-08-16 14:48:19 +0200556let theone = 1
557let thefour = 4
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100558if has('float')
559 let afloat = 0.1
560endif
561let astring = 'asdf'
562let ablob = 0z01ab
563let alist = [2, 3, 4]
564let adict = #{aaa: 2, bbb: 8}
565
Dominique Pelle81b573d2022-03-22 21:14:55 +0000566" test == comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100567def Test_expr4_equal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100568 var lines =<< trim END
569 var trueVar = true
570 var falseVar = false
571 assert_equal(true, true == true)
572 assert_equal(false, true ==
573 false)
574 assert_equal(true, true
575 == trueVar)
576 assert_equal(false, true == falseVar)
577 assert_equal(true, true == g:atrue)
578 assert_equal(false, g:atrue == false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100579
Bram Moolenaar659bb222020-11-12 20:16:39 +0100580 assert_equal(true, v:none == v:none)
581 assert_equal(false, v:none == v:null)
582 assert_equal(true, g:anone == v:none)
Bram Moolenaar67977822021-01-03 21:53:53 +0100583 assert_equal(true, null == v:null)
584 assert_equal(true, null == g:anull)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100585 assert_equal(false, v:none == g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100586
Bram Moolenaar659bb222020-11-12 20:16:39 +0100587 var nr0 = 0
588 var nr61 = 61
589 assert_equal(false, 2 == 0)
590 assert_equal(false, 2 == nr0)
591 assert_equal(true, 61 == 61)
592 assert_equal(true, 61 == nr61)
593 assert_equal(true, g:anint == 10)
594 assert_equal(false, 61 == g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100595
Bram Moolenaar659bb222020-11-12 20:16:39 +0100596 if has('float')
597 var ff = 0.3
598 assert_equal(true, ff == 0.3)
599 assert_equal(false, 0.4 == ff)
600 assert_equal(true, 0.1 == g:afloat)
601 assert_equal(false, g:afloat == 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100602
Bram Moolenaar659bb222020-11-12 20:16:39 +0100603 ff = 3.0
604 assert_equal(true, ff == 3)
605 assert_equal(true, 3 == ff)
606 ff = 3.1
607 assert_equal(false, ff == 3)
608 assert_equal(false, 3 == ff)
609 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100610
Bram Moolenaar659bb222020-11-12 20:16:39 +0100611 assert_equal(true, 'abc' == 'abc')
612 assert_equal(false, 'xyz' == 'abc')
613 assert_equal(true, g:astring == 'asdf')
614 assert_equal(false, 'xyz' == g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100615
Bram Moolenaar659bb222020-11-12 20:16:39 +0100616 assert_equal(false, 'abc' == 'aBc')
617 assert_equal(false, 'abc' ==# 'aBc')
618 assert_equal(true, 'abc' ==? 'aBc')
Bram Moolenaar9be61bb2020-03-30 22:51:24 +0200619
Bram Moolenaar659bb222020-11-12 20:16:39 +0100620 assert_equal(false, 'abc' == 'ABC')
621 set ignorecase
622 assert_equal(false, 'abc' == 'ABC')
623 assert_equal(false, 'abc' ==# 'ABC')
624 assert_equal(true, 'abc' ==? 'ABC')
625 set noignorecase
626
627 var bb = 0z3f
628 assert_equal(true, 0z3f == bb)
629 assert_equal(false, bb == 0z4f)
630 assert_equal(true, g:ablob == 0z01ab)
631 assert_equal(false, 0z3f == g:ablob)
632
633 assert_equal(true, [1, 2, 3] == [1, 2, 3])
634 assert_equal(false, [1, 2, 3] == [2, 3, 1])
635 assert_equal(true, [2, 3, 4] == g:alist)
636 assert_equal(false, g:alist == [2, 3, 1])
637 assert_equal(false, [1, 2, 3] == [])
638 assert_equal(false, [1, 2, 3] == ['1', '2', '3'])
639
Bram Moolenaare0de1712020-12-02 17:36:54 +0100640 assert_equal(true, {one: 1, two: 2} == {one: 1, two: 2})
641 assert_equal(false, {one: 1, two: 2} == {one: 2, two: 2})
642 assert_equal(false, {one: 1, two: 2} == {two: 2})
643 assert_equal(false, {one: 1, two: 2} == {})
644 assert_equal(true, g:adict == {bbb: 8, aaa: 2})
645 assert_equal(false, {ccc: 9, aaa: 2} == g:adict)
Bram Moolenaar659bb222020-11-12 20:16:39 +0100646
647 assert_equal(true, function('g:Test_expr4_equal') == function('g:Test_expr4_equal'))
648 assert_equal(false, function('g:Test_expr4_equal') == function('g:Test_expr4_is'))
649
650 assert_equal(true, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [123]))
651 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_is', [123]))
652 assert_equal(false, function('g:Test_expr4_equal', [123]) == function('g:Test_expr4_equal', [999]))
653
Bram Moolenaarb3341372021-12-14 18:57:45 +0000654 if true
655 var OneFunc: func
656 var TwoFunc: func
657 OneFunc = function('len')
658 TwoFunc = function('len')
659 assert_equal(true, OneFunc('abc') == TwoFunc('123'))
660 endif
661
662 # check this doesn't fail when skipped
663 if false
Bram Moolenaara065a142020-11-14 20:57:20 +0100664 var OneFunc: func
665 var TwoFunc: func
666 OneFunc = function('len')
667 TwoFunc = function('len')
668 assert_equal(true, OneFunc('abc') == TwoFunc('123'))
669 endif
Bram Moolenaar659bb222020-11-12 20:16:39 +0100670 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000671 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100672
Bram Moolenaar62aec932022-01-29 21:45:34 +0000673 v9.CheckDefAndScriptFailure(["var x = 'a' == xxx"], ['E1001:', 'E121:'], 1)
674 v9.CheckDefFailure(["var x = 'a' == "], 'E1097:', 3)
675 v9.CheckScriptFailure(['vim9script', "var x = 'a' == "], 'E15:', 2)
Bram Moolenaar918a4242020-12-06 14:37:08 +0100676
Bram Moolenaar62aec932022-01-29 21:45:34 +0000677 v9.CheckDefExecAndScriptFailure(['var items: any', 'eval 1 + 1', 'eval 2 + 2', 'if items == []', 'endif'], ['E691:', 'E1072:'], 4)
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100678
Bram Moolenaar62aec932022-01-29 21:45:34 +0000679 v9.CheckDefExecAndScriptFailure(['var x: any = "a"', 'echo x == true'], 'E1072: Cannot compare string with bool', 2)
680 v9.CheckDefExecAndScriptFailure(["var x: any = true", 'echo x == ""'], 'E1072: Cannot compare bool with string', 2)
681 v9.CheckDefExecAndScriptFailure(["var x: any = 99", 'echo x == true'], ['E1138', 'E1072:'], 2)
682 v9.CheckDefExecAndScriptFailure(["var x: any = 'a'", 'echo x == 99'], ['E1030:', 'E1072:'], 2)
Bram Moolenaar28fbbea2021-12-22 21:40:33 +0000683
684 lines =<< trim END
685 vim9script
686 var n: any = 2
687 def Compare()
688 eval n == '3'
689 g:notReached = false
690 enddef
691 g:notReached = true
692 Compare()
693 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000694 v9.CheckScriptFailure(lines, 'E1030: Using a String as a Number: "3"')
Bram Moolenaar28fbbea2021-12-22 21:40:33 +0000695 assert_true(g:notReached)
696
697 if has('float')
698 lines =<< trim END
699 vim9script
700 var n: any = 2.2
701 def Compare()
702 eval n == '3'
703 g:notReached = false
704 enddef
705 g:notReached = true
706 Compare()
707 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000708 v9.CheckScriptFailure(lines, 'E892: Using a String as a Float')
Bram Moolenaar28fbbea2021-12-22 21:40:33 +0000709 assert_true(g:notReached)
710 endif
711
712 unlet g:notReached
Bram Moolenaar0c357522021-07-18 14:43:43 +0200713enddef
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100714
Bram Moolenaar7a222242022-03-01 19:23:24 +0000715def Test_expr4_compare_null()
716 g:null_dict = test_null_dict()
717 g:not_null_list = []
718 var lines =<< trim END
Bram Moolenaar05667812022-03-15 20:21:33 +0000719 assert_false(true == null)
720 assert_false(false == null)
721 assert_false(null == true)
722 assert_false(null == false)
723 assert_true(true != null)
724 assert_true(false != null)
725 assert_true(null != true)
726 assert_true(null != false)
727
728 assert_false(123 == null)
729 assert_false(0 == null)
730 assert_false(null == 123)
731 assert_false(null == 0)
732 assert_true(123 != null)
733 assert_true(0 != null)
734 assert_true(null != 123)
735 assert_true(null != 0)
736
737 if has('float')
738 assert_false(12.3 == null)
739 assert_false(0.0 == null)
740 assert_false(null == 12.3)
741 assert_false(null == 0.0)
742 assert_true(12.3 != null)
743 assert_true(0.0 != null)
744 assert_true(null != 12.3)
745 assert_true(null != 0.0)
746 endif
747
Bram Moolenaar7a222242022-03-01 19:23:24 +0000748 assert_true(test_null_blob() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000749 assert_true(null_blob == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000750 assert_true(v:null == test_null_blob())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000751 assert_true(null == null_blob)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000752 assert_false(test_null_blob() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000753 assert_false(null_blob != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000754 assert_false(v:null != test_null_blob())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000755 assert_false(null != null_blob)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000756
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100757 var nb = null_blob
758 assert_true(nb == null_blob)
759 assert_true(nb == null)
760 assert_true(null_blob == nb)
761 assert_true(null == nb)
762
Bram Moolenaar7a222242022-03-01 19:23:24 +0000763 if has('channel')
764 assert_true(test_null_channel() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000765 assert_true(null_channel == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000766 assert_true(v:null == test_null_channel())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000767 assert_true(null == null_channel)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000768 assert_false(test_null_channel() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000769 assert_false(null_channel != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000770 assert_false(v:null != test_null_channel())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000771 assert_false(null != null_channel)
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100772
773 var nc = null_channel
774 assert_true(nc == null_channel)
775 assert_true(nc == null)
776 assert_true(null_channel == nc)
777 assert_true(null == nc)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000778 endif
779
780 assert_true(test_null_dict() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000781 assert_true(null_dict == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000782 assert_true(v:null == test_null_dict())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000783 assert_true(null == null_dict)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000784 assert_false(test_null_dict() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000785 assert_false(null_dict != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000786 assert_false(v:null != test_null_dict())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000787 assert_false(null != null_dict)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000788
789 assert_true(g:null_dict == v:null)
790 assert_true(v:null == g:null_dict)
791 assert_false(g:null_dict != v:null)
792 assert_false(v:null != g:null_dict)
793
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100794 var nd = null_dict
795 assert_true(nd == null_dict)
796 assert_true(nd == null)
797 assert_true(null_dict == nd)
798 assert_true(null == nd)
799
Bram Moolenaar7a222242022-03-01 19:23:24 +0000800 assert_true(test_null_function() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000801 assert_true(null_function == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000802 assert_true(v:null == test_null_function())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000803 assert_true(null == null_function)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000804 assert_false(test_null_function() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000805 assert_false(null_function != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000806 assert_false(v:null != test_null_function())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000807 assert_false(null != null_function)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000808
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100809 var Nf = null_function
810 assert_true(Nf == null_function)
811 assert_true(Nf == null)
812 assert_true(null_function == Nf)
813 assert_true(null == Nf)
814
Bram Moolenaar7a222242022-03-01 19:23:24 +0000815 if has('job')
816 assert_true(test_null_job() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000817 assert_true(null_job == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000818 assert_true(v:null == test_null_job())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000819 assert_true(null == null_job)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000820 assert_false(test_null_job() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000821 assert_false(null_job != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000822 assert_false(v:null != test_null_job())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000823 assert_false(null != null_job)
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100824
825 var nj = null_job
826 assert_true(nj == null_job)
827 assert_true(nj == null)
828 assert_true(null_job == nj)
829 assert_true(null == nj)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000830 endif
831
832 assert_true(test_null_list() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000833 assert_true(null_list == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000834 assert_true(v:null == test_null_list())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000835 assert_true(null == null_list)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000836 assert_false(test_null_list() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000837 assert_false(null_list != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000838 assert_false(v:null != test_null_list())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000839 assert_false(null != null_list)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000840
841 assert_false(g:not_null_list == v:null)
842 assert_false(v:null == g:not_null_list)
843 assert_true(g:not_null_list != v:null)
844 assert_true(v:null != g:not_null_list)
845
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100846 var nl = null_list
847 assert_true(nl == null_list)
848 assert_true(nl == null)
849 assert_true(null_list == nl)
850 assert_true(null == nl)
851
Bram Moolenaar7a222242022-03-01 19:23:24 +0000852 assert_true(test_null_partial() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000853 assert_true(null_partial == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000854 assert_true(v:null == test_null_partial())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000855 assert_true(null == null_partial)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000856 assert_false(test_null_partial() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000857 assert_false(null_partial != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000858 assert_false(v:null != test_null_partial())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000859 assert_false(null != null_partial)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000860
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100861 var Np = null_partial
862 assert_true(Np == null_partial)
863 assert_true(Np == null)
864 assert_true(null_partial == Np)
865 assert_true(null == Np)
866
Bram Moolenaar7a222242022-03-01 19:23:24 +0000867 assert_true(test_null_string() == v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000868 assert_true(null_string == null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000869 assert_true(v:null == test_null_string())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000870 assert_true(null == null_string)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000871 assert_false(test_null_string() != v:null)
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000872 assert_false(null_string != null)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000873 assert_false(v:null != test_null_string())
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000874 assert_false(null != null_string)
Bram Moolenaarf8691002022-03-10 12:20:53 +0000875
876 assert_true(null_string is test_null_string())
877 assert_false(null_string is '')
878 assert_false('' is null_string)
879 assert_false(null_string isnot test_null_string())
880 assert_true(null_string isnot '')
881 assert_true('' isnot null_string)
Bram Moolenaarec15b1c2022-03-27 16:29:53 +0100882
883 var ns = null_string
884 assert_true(ns == null_string)
885 assert_true(ns == null)
886 assert_true(null_string == ns)
887 assert_true(null == ns)
Bram Moolenaar7a222242022-03-01 19:23:24 +0000888 END
889 v9.CheckDefAndScriptSuccess(lines)
890 unlet g:null_dict
891 unlet g:not_null_list
892
Bram Moolenaar859cc212022-03-28 15:22:35 +0100893 # variables declared at script level used in a :def function
894 lines =<< trim END
895 vim9script
896
897 var l_decl: list<number>
898 var l_empty = []
899 var l_null = null_list
900
901 def TestList()
902 assert_false(l_decl == null)
903 assert_false(l_decl is null_list)
904 assert_false(l_empty == null)
905 assert_false(l_empty is null_list)
906 assert_true(l_null == null)
907 assert_true(l_null is null_list)
908 assert_true(l_null == null_list)
909
910 add(l_decl, 6)
911 assert_equal([6], l_decl)
912 add(l_empty, 7)
913 assert_equal([7], l_empty)
914 var caught = false
915 try
916 add(l_null, 9)
917 catch /E1130:/
918 caught = true
919 endtry
920 assert_true(caught)
921 enddef
922 TestList()
923
924 var b_decl: blob
925 var b_empty = 0z
926 var b_null = null_blob
927
928 def TestBlob()
929 assert_false(b_decl == null)
930 assert_false(b_decl is null_blob)
931 assert_false(b_empty == null)
932 assert_false(b_empty is null_blob)
933 assert_true(b_null == null)
934 assert_true(b_null is null_blob)
935 assert_true(b_null == null_blob)
936
937 add(b_decl, 6)
938 assert_equal(0z06, b_decl)
939 add(b_empty, 7)
940 assert_equal(0z07, b_empty)
941 var caught = false
942 try
943 add(b_null, 9)
944 catch /E1131:/
945 caught = true
946 endtry
947 assert_true(caught)
948 enddef
949 TestBlob()
950
951 var d_decl: dict<number>
952 var d_empty = {}
953 var d_null = null_dict
954
955 def TestDict()
956 assert_false(d_decl == null)
957 assert_false(d_decl is null_dict)
958 assert_false(d_empty == null)
959 assert_false(d_empty is null_dict)
960 assert_true(d_null == null)
961 assert_true(d_null is null_dict)
962 assert_true(d_null == null_dict)
963
964 d_decl['a'] = 6
965 assert_equal({a: 6}, d_decl)
966 d_empty['b'] = 7
967 assert_equal({b: 7}, d_empty)
968 var caught = false
969 try
970 d_null['c'] = 9
971 catch /E1103:/
972 caught = true
973 endtry
974 assert_true(caught)
975 enddef
976 TestDict()
977 END
978 v9.CheckScriptSuccess(lines)
979
Bram Moolenaared0c62e2022-03-08 19:43:55 +0000980 lines =<< trim END
981 var d: dict<func> = {f: null_function}
982 assert_equal(null_function, d.f)
983 END
984 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar53ba6ca2022-03-10 19:23:28 +0000985enddef
Bram Moolenaar7a222242022-03-01 19:23:24 +0000986
Bram Moolenaar53ba6ca2022-03-10 19:23:28 +0000987def Test_expr4_compare_none()
988 var lines =<< trim END
989 assert_false('' == v:none)
990 assert_false('text' == v:none)
991 assert_true(v:none == v:none)
992 assert_false(v:none == '')
993 assert_false(v:none == 'text')
994 assert_true(v:none == v:none)
995 END
996 v9.CheckDefAndScriptSuccess(lines)
997
998 v9.CheckDefAndScriptFailure(['echo [] == v:none'], 'E1072: Cannot compare list with special')
999 v9.CheckDefAndScriptFailure(['echo 123 == v:none'], 'E1072: Cannot compare number with special')
1000 v9.CheckDefAndScriptFailure(['echo 0z00 == v:none'], 'E1072: Cannot compare blob with special')
Bram Moolenaar1b1df952022-03-10 20:01:50 +00001001
1002 lines =<< trim END
1003 echo [] == v:none
1004
1005 eval 0 + 0
1006 END
1007 v9.CheckDefAndScriptFailure(lines, 'E1072:', 1)
Bram Moolenaar7a222242022-03-01 19:23:24 +00001008enddef
1009
Bram Moolenaar0c357522021-07-18 14:43:43 +02001010def Test_expr4_wrong_type()
Bram Moolenaarcff40ff2021-01-09 16:21:37 +01001011 for op in ['>', '>=', '<', '<=', '=~', '!~']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001012 v9.CheckDefExecAndScriptFailure([
Bram Moolenaarcff40ff2021-01-09 16:21:37 +01001013 "var a: any = 'a'",
1014 'var b: any = true',
1015 'echo a ' .. op .. ' b'], 'E1072:', 3)
1016 endfor
Bram Moolenaar0c357522021-07-18 14:43:43 +02001017 for op in ['>', '>=', '<', '<=']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001018 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001019 "var n: any = 2",
Bram Moolenaar86b3ab42021-12-19 18:33:23 +00001020 'echo n ' .. op .. ' "3"'], ['E1030:', 'E1072:'], 2)
Bram Moolenaar0c357522021-07-18 14:43:43 +02001021 endfor
1022 for op in ['=~', '!~']
Bram Moolenaar62aec932022-01-29 21:45:34 +00001023 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001024 "var n: any = 2",
1025 'echo n ' .. op .. ' "3"'], 'E1072:', 2)
1026 endfor
1027
Bram Moolenaar62aec932022-01-29 21:45:34 +00001028 v9.CheckDefAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001029 'echo v:none == true'], 'E1072:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001030 v9.CheckDefAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001031 'echo false >= true'], 'E1072:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001032 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001033 "var n: any = v:none",
1034 'echo n == true'], 'E1072:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001035 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +02001036 "var n: any = v:none",
1037 'echo n < true'], 'E1072:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001038enddef
1039
Dominique Pelle81b573d2022-03-22 21:14:55 +00001040" test != comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001041def Test_expr4_notequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001042 var lines =<< trim END
1043 var trueVar = true
1044 var falseVar = false
1045 assert_equal(false, true != true)
1046 assert_equal(true, true !=
1047 false)
1048 assert_equal(false, true
1049 != trueVar)
1050 assert_equal(true, true != falseVar)
1051 assert_equal(false, true != g:atrue)
1052 assert_equal(true, g:atrue != false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001053
Bram Moolenaar659bb222020-11-12 20:16:39 +01001054 assert_equal(false, v:none != v:none)
1055 assert_equal(true, v:none != v:null)
1056 assert_equal(false, g:anone != v:none)
1057 assert_equal(true, v:none != g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001058
Bram Moolenaar659bb222020-11-12 20:16:39 +01001059 var nr55 = 55
1060 var nr0 = 55
1061 assert_equal(true, 2 != 0)
1062 assert_equal(true, 2 != nr0)
1063 assert_equal(false, 55 != 55)
1064 assert_equal(false, 55 != nr55)
1065 assert_equal(false, g:anint != 10)
1066 assert_equal(true, 61 != g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001067
Bram Moolenaar659bb222020-11-12 20:16:39 +01001068 if has('float')
1069 var ff = 0.3
1070 assert_equal(false, 0.3 != ff)
1071 assert_equal(true, 0.4 != ff)
1072 assert_equal(false, 0.1 != g:afloat)
1073 assert_equal(true, g:afloat != 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001074
Bram Moolenaar659bb222020-11-12 20:16:39 +01001075 ff = 3.0
1076 assert_equal(false, ff != 3)
1077 assert_equal(false, 3 != ff)
1078 ff = 3.1
1079 assert_equal(true, ff != 3)
1080 assert_equal(true, 3 != ff)
1081 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001082
Bram Moolenaar659bb222020-11-12 20:16:39 +01001083 assert_equal(false, 'abc' != 'abc')
1084 assert_equal(true, 'xyz' != 'abc')
1085 assert_equal(false, g:astring != 'asdf')
1086 assert_equal(true, 'xyz' != g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001087
Bram Moolenaar659bb222020-11-12 20:16:39 +01001088 assert_equal(true, 'abc' != 'ABC')
1089 set ignorecase
1090 assert_equal(true, 'abc' != 'ABC')
1091 assert_equal(true, 'abc' !=# 'ABC')
1092 assert_equal(false, 'abc' !=? 'ABC')
1093 set noignorecase
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001094
Bram Moolenaar659bb222020-11-12 20:16:39 +01001095 var bb = 0z3f
1096 assert_equal(false, 0z3f != bb)
1097 assert_equal(true, bb != 0z4f)
1098 assert_equal(false, g:ablob != 0z01ab)
1099 assert_equal(true, 0z3f != g:ablob)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001100
Bram Moolenaar659bb222020-11-12 20:16:39 +01001101 assert_equal(false, [1, 2, 3] != [1, 2, 3])
1102 assert_equal(true, [1, 2, 3] != [2, 3, 1])
1103 assert_equal(false, [2, 3, 4] != g:alist)
1104 assert_equal(true, g:alist != [2, 3, 1])
1105 assert_equal(true, [1, 2, 3] != [])
1106 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001107
Bram Moolenaare0de1712020-12-02 17:36:54 +01001108 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
1109 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
1110 assert_equal(true, {one: 1, two: 2} != {two: 2})
1111 assert_equal(true, {one: 1, two: 2} != {})
1112 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
1113 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001114
Bram Moolenaar659bb222020-11-12 20:16:39 +01001115 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
1116 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001117
Bram Moolenaar659bb222020-11-12 20:16:39 +01001118 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
1119 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
1120 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
1121 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001122 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001123enddef
1124
Dominique Pelle81b573d2022-03-22 21:14:55 +00001125" test > comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001126def Test_expr4_greater()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001127 var lines =<< trim END
1128 assert_true(2 > 0)
1129 assert_true(2 >
1130 1)
1131 assert_false(2 > 2)
1132 assert_false(2 > 3)
1133 var nr2 = 2
1134 assert_true(nr2 > 0)
1135 assert_true(nr2 >
1136 1)
1137 assert_false(nr2 > 2)
1138 assert_false(nr2
1139 > 3)
1140 if has('float')
1141 var ff = 2.0
1142 assert_true(ff > 0.0)
1143 assert_true(ff > 1.0)
1144 assert_false(ff > 2.0)
1145 assert_false(ff > 3.0)
1146 endif
1147 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001148 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001149enddef
1150
Dominique Pelle81b573d2022-03-22 21:14:55 +00001151" test >= comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001152def Test_expr4_greaterequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001153 var lines =<< trim END
1154 assert_true(2 >= 0)
1155 assert_true(2 >=
1156 2)
1157 assert_false(2 >= 3)
1158 var nr2 = 2
1159 assert_true(nr2 >= 0)
1160 assert_true(nr2 >= 2)
1161 assert_false(nr2 >= 3)
1162 if has('float')
1163 var ff = 2.0
1164 assert_true(ff >= 0.0)
1165 assert_true(ff >= 2.0)
1166 assert_false(ff >= 3.0)
1167 endif
1168 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001169 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001170enddef
1171
Dominique Pelle81b573d2022-03-22 21:14:55 +00001172" test < comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001173def Test_expr4_smaller()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001174 var lines =<< trim END
1175 assert_false(2 < 0)
1176 assert_false(2 <
1177 2)
1178 assert_true(2
1179 < 3)
1180 var nr2 = 2
1181 assert_false(nr2 < 0)
1182 assert_false(nr2 < 2)
1183 assert_true(nr2 < 3)
1184 if has('float')
1185 var ff = 2.0
1186 assert_false(ff < 0.0)
1187 assert_false(ff < 2.0)
1188 assert_true(ff < 3.0)
1189 endif
1190 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001191 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001192enddef
1193
Dominique Pelle81b573d2022-03-22 21:14:55 +00001194" test <= comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001195def Test_expr4_smallerequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001196 var lines =<< trim END
1197 assert_false(2 <= 0)
1198 assert_false(2 <=
1199 1)
1200 assert_true(2
1201 <= 2)
1202 assert_true(2 <= 3)
1203 var nr2 = 2
1204 assert_false(nr2 <= 0)
1205 assert_false(nr2 <= 1)
1206 assert_true(nr2 <= 2)
1207 assert_true(nr2 <= 3)
1208 if has('float')
1209 var ff = 2.0
1210 assert_false(ff <= 0.0)
1211 assert_false(ff <= 1.0)
1212 assert_true(ff <= 2.0)
1213 assert_true(ff <= 3.0)
1214 endif
1215 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001216 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001217enddef
1218
Dominique Pelle81b573d2022-03-22 21:14:55 +00001219" test =~ comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001220def Test_expr4_match()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001221 var lines =<< trim END
1222 assert_equal(false, '2' =~ '0')
1223 assert_equal(false, ''
1224 =~ '0')
1225 assert_equal(true, '2' =~
1226 '[0-9]')
1227 set ignorecase
1228 assert_equal(false, 'abc' =~ 'ABC')
1229 assert_equal(false, 'abc' =~# 'ABC')
1230 assert_equal(true, 'abc' =~? 'ABC')
1231 set noignorecase
1232 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001233 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001234enddef
1235
Dominique Pelle81b573d2022-03-22 21:14:55 +00001236" test !~ comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001237def Test_expr4_nomatch()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001238 var lines =<< trim END
1239 assert_equal(true, '2' !~ '0')
1240 assert_equal(true, ''
1241 !~ '0')
1242 assert_equal(false, '2' !~
1243 '[0-9]')
1244 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001245 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001246enddef
1247
Dominique Pelle81b573d2022-03-22 21:14:55 +00001248" test is comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001249def Test_expr4_is()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001250 var lines =<< trim END
1251 var mylist = [2]
1252 assert_false(mylist is [2])
1253 var other = mylist
1254 assert_true(mylist is
1255 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001256
Bram Moolenaar659bb222020-11-12 20:16:39 +01001257 var myblob = 0z1234
1258 assert_false(myblob
1259 is 0z1234)
1260 var otherblob = myblob
1261 assert_true(myblob is otherblob)
1262 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001263 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001264enddef
1265
Dominique Pelle81b573d2022-03-22 21:14:55 +00001266" test isnot comparator
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001267def Test_expr4_isnot()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001268 var lines =<< trim END
1269 var mylist = [2]
1270 assert_true('2' isnot '0')
1271 assert_true(mylist isnot [2])
1272 var other = mylist
1273 assert_false(mylist isnot
1274 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001275
Bram Moolenaar659bb222020-11-12 20:16:39 +01001276 var myblob = 0z1234
1277 assert_true(myblob
1278 isnot 0z1234)
1279 var otherblob = myblob
1280 assert_false(myblob isnot otherblob)
1281 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001282 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001283enddef
1284
Bram Moolenaar62aec932022-01-29 21:45:34 +00001285def g:RetVoid()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001286 var x = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001287enddef
1288
Bram Moolenaar8294d492020-08-10 22:40:56 +02001289def Test_expr4_vim9script()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001290 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001291 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001292 var name = 0
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001293 < 1
Bram Moolenaar98309382020-09-27 21:58:45 +02001294 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001295 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001296 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001297
1298 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001299 var name = 123
Bram Moolenaar93be1642020-10-11 21:34:41 +02001300 # comment
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001301 != 123
Bram Moolenaar98309382020-09-27 21:58:45 +02001302 assert_equal(false, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001303 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001304 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001305
1306 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001307 var name = 123 ==
Bram Moolenaar9215f012020-06-27 21:18:00 +02001308 123
Bram Moolenaar98309382020-09-27 21:58:45 +02001309 assert_equal(true, name)
Bram Moolenaar9215f012020-06-27 21:18:00 +02001310 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001311 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +02001312
1313 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001314 var list = [1, 2, 3]
1315 var name = list
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001316 is list
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001317 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001318 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001319 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001320
1321 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001322 var list = [1, 2, 3]
1323 var name = list # comment
1324 # comment
1325 is list
1326 assert_equal(true, name)
1327 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001328 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001329
1330 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001331 var myblob = 0z1234
1332 var name = myblob
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001333 isnot 0z11
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001334 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001335 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001336 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001337
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001338 # spot check mismatching types
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001339 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001340 echo '' == 0
1341 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001342 v9.CheckDefAndScriptFailure(lines, 'E1072:', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001343
1344 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001345 echo v:true > v:false
1346 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001347 v9.CheckDefAndScriptFailure(lines, 'Cannot compare bool with bool', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001348
1349 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001350 echo 123 is 123
1351 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001352 v9.CheckDefAndScriptFailure(lines, 'Cannot use "is" with number', 1)
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02001353
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001354 # check missing white space
1355 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001356 echo 2>3
1357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001358 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''>'' at ">3"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001359
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001360 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001361 echo 2 >3
1362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001363 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001364
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001365 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001366 echo 2> 3
1367 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001368 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001369
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001370 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001371 echo 2!=3
1372 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001373 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001374
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001375 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001376 echo 2 !=3
1377 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001378 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''!='' at "!=3"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001379
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001380 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001381 echo 2!= 3
1382 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001383 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar8294d492020-08-10 22:40:56 +02001384
mityu4ac198c2021-05-28 17:52:40 +02001385 for op in ['==', '>', '>=', '<', '<=', '=~', '!~', 'is', 'isnot']
1386 lines = ["echo 'aaa'", op .. "'bbb'", '# comment']
1387 var msg = printf("E1004: White space required before and after '%s'", op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001388 v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02001389 endfor
1390
Bram Moolenaar8294d492020-08-10 22:40:56 +02001391 lines =<< trim END
Bram Moolenaar8294d492020-08-10 22:40:56 +02001392 echo len('xxx') == 3
1393 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001394 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf9235712020-08-16 18:42:53 +02001395
1396 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001397 var line = 'abc'
Bram Moolenaarf9235712020-08-16 18:42:53 +02001398 echo line[1] =~ '\w'
1399 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001400 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001401enddef
1402
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001403func Test_expr4_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001404 let msg = "White space required before and after '>'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001405 call v9.CheckDefAndScriptFailure(["var x = 1>2"], msg, 1)
1406 call v9.CheckDefAndScriptFailure(["var x = 1 >2"], msg, 1)
1407 call v9.CheckDefAndScriptFailure(["var x = 1> 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001408
Bram Moolenaar77072282020-09-16 17:55:40 +02001409 let msg = "White space required before and after '=='"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001410 call v9.CheckDefAndScriptFailure(["var x = 1==2"], msg, 1)
1411 call v9.CheckDefAndScriptFailure(["var x = 1 ==2"], msg, 1)
1412 call v9.CheckDefAndScriptFailure(["var x = 1== 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001413
Bram Moolenaar77072282020-09-16 17:55:40 +02001414 let msg = "White space required before and after 'is'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001415 call v9.CheckDefAndScriptFailure(["var x = '1'is'2'"], msg, 1)
1416 call v9.CheckDefAndScriptFailure(["var x = '1' is'2'"], msg, 1)
1417 call v9.CheckDefAndScriptFailure(["var x = '1'is '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001418
Bram Moolenaar77072282020-09-16 17:55:40 +02001419 let msg = "White space required before and after 'isnot'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001420 call v9.CheckDefAndScriptFailure(["var x = '1'isnot'2'"], msg, 1)
1421 call v9.CheckDefAndScriptFailure(["var x = '1' isnot'2'"], msg, 1)
1422 call v9.CheckDefAndScriptFailure(["var x = '1'isnot '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001423
Bram Moolenaar62aec932022-01-29 21:45:34 +00001424 call v9.CheckDefAndScriptFailure(["var x = 1 is# 2"], 'E15:', 1)
1425 call v9.CheckDefAndScriptFailure(["var x = 1 is? 2"], 'E15:', 1)
1426 call v9.CheckDefAndScriptFailure(["var x = 1 isnot# 2"], 'E15:', 1)
1427 call v9.CheckDefAndScriptFailure(["var x = 1 isnot? 2"], 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001428
Bram Moolenaar62aec932022-01-29 21:45:34 +00001429 call v9.CheckDefAndScriptFailure(["var x = 1 == '2'"], 'Cannot compare number with string', 1)
1430 call v9.CheckDefAndScriptFailure(["var x = '1' == 2"], 'Cannot compare string with number', 1)
1431 call v9.CheckDefAndScriptFailure(["var x = 1 == g:RetVoid()"], 'Cannot compare number with void', 1)
1432 call v9.CheckDefAndScriptFailure(["var x = g:RetVoid() == 1"], 'Cannot compare void with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001433
Bram Moolenaar62aec932022-01-29 21:45:34 +00001434 call v9.CheckDefAndScriptFailure(["var x = true > false"], 'Cannot compare bool with bool', 1)
1435 call v9.CheckDefAndScriptFailure(["var x = true >= false"], 'Cannot compare bool with bool', 1)
1436 call v9.CheckDefAndScriptFailure(["var x = true < false"], 'Cannot compare bool with bool', 1)
1437 call v9.CheckDefAndScriptFailure(["var x = true <= false"], 'Cannot compare bool with bool', 1)
1438 call v9.CheckDefAndScriptFailure(["var x = true =~ false"], 'Cannot compare bool with bool', 1)
1439 call v9.CheckDefAndScriptFailure(["var x = true !~ false"], 'Cannot compare bool with bool', 1)
1440 call v9.CheckDefAndScriptFailure(["var x = true is false"], 'Cannot use "is" with bool', 1)
1441 call v9.CheckDefAndScriptFailure(["var x = true isnot false"], 'Cannot use "isnot" with bool', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001442
Bram Moolenaar62aec932022-01-29 21:45:34 +00001443 call v9.CheckDefAndScriptFailure(["var x = v:none is v:null"], 'Cannot use "is" with special', 1)
1444 call v9.CheckDefAndScriptFailure(["var x = v:none isnot v:null"], 'Cannot use "isnot" with special', 1)
1445 call v9.CheckDefAndScriptFailure(["var x = 123 is 123"], 'Cannot use "is" with number', 1)
1446 call v9.CheckDefAndScriptFailure(["var x = 123 isnot 123"], 'Cannot use "isnot" with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001447 if has('float')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001448 call v9.CheckDefAndScriptFailure(["var x = 1.3 is 1.3"], 'Cannot use "is" with float', 1)
1449 call v9.CheckDefAndScriptFailure(["var x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001450 endif
1451
Bram Moolenaar62aec932022-01-29 21:45:34 +00001452 call v9.CheckDefAndScriptFailure(["var x = 0za1 > 0z34"], 'Cannot compare blob with blob', 1)
1453 call v9.CheckDefAndScriptFailure(["var x = 0za1 >= 0z34"], 'Cannot compare blob with blob', 1)
1454 call v9.CheckDefAndScriptFailure(["var x = 0za1 < 0z34"], 'Cannot compare blob with blob', 1)
1455 call v9.CheckDefAndScriptFailure(["var x = 0za1 <= 0z34"], 'Cannot compare blob with blob', 1)
1456 call v9.CheckDefAndScriptFailure(["var x = 0za1 =~ 0z34"], 'Cannot compare blob with blob', 1)
1457 call v9.CheckDefAndScriptFailure(["var x = 0za1 !~ 0z34"], 'Cannot compare blob with blob', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001458
Bram Moolenaar62aec932022-01-29 21:45:34 +00001459 call v9.CheckDefAndScriptFailure(["var x = [13] > [88]"], 'Cannot compare list with list', 1)
1460 call v9.CheckDefAndScriptFailure(["var x = [13] >= [88]"], 'Cannot compare list with list', 1)
1461 call v9.CheckDefAndScriptFailure(["var x = [13] < [88]"], 'Cannot compare list with list', 1)
1462 call v9.CheckDefAndScriptFailure(["var x = [13] <= [88]"], 'Cannot compare list with list', 1)
1463 call v9.CheckDefAndScriptFailure(["var x = [13] =~ [88]"], 'Cannot compare list with list', 1)
1464 call v9.CheckDefAndScriptFailure(["var x = [13] !~ [88]"], 'Cannot compare list with list', 1)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001465
Bram Moolenaar62aec932022-01-29 21:45:34 +00001466 call v9.CheckDefAndScriptFailure(['var j: job', 'var chan: channel', 'var r = j == chan'], 'Cannot compare job with channel', 3)
1467 call v9.CheckDefAndScriptFailure(['var j: job', 'var x: list<any>', 'var r = j == x'], 'Cannot compare job with list', 3)
1468 call v9.CheckDefAndScriptFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
1469 call v9.CheckDefAndScriptFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001470endfunc
1471
1472" test addition, subtraction, concatenation
1473def Test_expr5()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001474 var lines =<< trim END
1475 assert_equal(66, 60 + 6)
1476 assert_equal(70, 60 +
1477 g:anint)
1478 assert_equal(9, g:thefour
1479 + 5)
1480 assert_equal(14, g:thefour + g:anint)
1481 assert_equal([1, 2, 3, 4], [1] + g:alist)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001482
Bram Moolenaar659bb222020-11-12 20:16:39 +01001483 assert_equal(54, 60 - 6)
1484 assert_equal(50, 60 -
1485 g:anint)
1486 assert_equal(-1, g:thefour
1487 - 5)
1488 assert_equal(-6, g:thefour - g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001489
Bram Moolenaar659bb222020-11-12 20:16:39 +01001490 assert_equal('hello', 'hel' .. 'lo')
1491 assert_equal('hello 123', 'hello ' ..
1492 123)
1493 assert_equal('hello 123', 'hello '
1494 .. 123)
1495 assert_equal('123 hello', 123 .. ' hello')
1496 assert_equal('123456', 123 .. 456)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001497
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001498 assert_equal('atrue', 'a' .. true)
1499 assert_equal('afalse', 'a' .. false)
Bram Moolenaar67977822021-01-03 21:53:53 +01001500 assert_equal('anull', 'a' .. v:null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001501 assert_equal('av:none', 'a' .. v:none)
1502 if has('float')
1503 assert_equal('a0.123', 'a' .. 0.123)
1504 endif
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001505
Bram Moolenaare507ff12021-01-31 21:47:42 +01001506 assert_equal(3, 1 + [2, 3, 4][0])
1507 assert_equal(5, 2 + {key: 3}['key'])
1508
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001509 set digraph
1510 assert_equal('val: true', 'val: ' .. &digraph)
1511 set nodigraph
1512 assert_equal('val: false', 'val: ' .. &digraph)
1513
Bram Moolenaar659bb222020-11-12 20:16:39 +01001514 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
1515 assert_equal(0z11223344, 0z1122 + 0z3344)
1516 assert_equal(0z112201ab, 0z1122
1517 + g:ablob)
1518 assert_equal(0z01ab3344, g:ablob + 0z3344)
1519 assert_equal(0z01ab01ab, g:ablob + g:ablob)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001520
Bram Moolenaar659bb222020-11-12 20:16:39 +01001521 # concatenate non-constant to constant
1522 var save_path = &path
1523 &path = 'b'
1524 assert_equal('ab', 'a' .. &path)
1525 &path = save_path
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001526
Bram Moolenaar659bb222020-11-12 20:16:39 +01001527 @b = 'b'
1528 assert_equal('ab', 'a' .. @b)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001529
Bram Moolenaar659bb222020-11-12 20:16:39 +01001530 $ENVVAR = 'env'
1531 assert_equal('aenv', 'a' .. $ENVVAR)
Bram Moolenaard62d87d2021-01-04 17:40:12 +01001532
1533 assert_equal('val', '' .. {key: 'val'}['key'])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001534 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001535 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001536enddef
1537
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001538def Test_expr5_vim9script()
Bram Moolenaar696ba232020-07-29 21:20:41 +02001539 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001540 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001541 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001542 + 77
1543 - 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001544 assert_equal(66, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001545 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001546 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001547
1548 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001549 var name = 11 +
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001550 77 -
1551 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001552 assert_equal(66, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001553 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001554 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001555
1556 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001557 var name = 11 + # comment
1558 77 -
1559 # comment
1560 22
1561 assert_equal(66, name)
1562 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001563 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001564
1565 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001566 var name = 'one'
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001567 .. 'two'
Bram Moolenaar98309382020-09-27 21:58:45 +02001568 assert_equal('onetwo', name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001569 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001570 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001571
1572 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001573 echo 'abc' is# 'abc'
1574 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001575 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001576
1577 lines =<< trim END
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001578 echo {} - 22
1579 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001580 v9.CheckDefAndScriptFailure(lines, ['E1036:', 'E728:'], 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001581
1582 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001583 echo [] - 33
1584 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001585 v9.CheckDefAndScriptFailure(lines, ['E1036:', 'E745:'], 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001586
1587 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001588 echo 0z1234 - 44
1589 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001590 v9.CheckDefAndScriptFailure(lines, ['E1036', 'E974:'], 1)
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001591
1592 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001593 echo 'abc' is? 'abc'
1594 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001595 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001596
1597 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001598 echo 'abc' isnot# 'abc'
1599 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001600 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001601
1602 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001603 echo 'abc' isnot? 'abc'
1604 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001605 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001606
1607 # check white space
1608 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001609 echo 5+6
1610 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001611 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001612 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001613 echo 5 +6
1614 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001615 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001616
1617 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001618 echo 5+ 6
1619 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001620 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001621
1622 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001623 echo 'a'..'b'
1624 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001625 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001626
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001627 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001628 echo 'a' ..'b'
1629 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001630 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001631
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001632 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001633 echo 'a'.. 'b'
1634 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001635 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at ".. ''b''"', 1)
mityu89dcb4d2021-05-28 13:50:17 +02001636
1637 lines =<< trim END
1638 echo 'a'
1639 ..'b'
1640 # comment
1641 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001642 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001643
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001644 # check invalid string concatenation
1645 lines =<< trim END
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001646 echo 'a' .. [1]
1647 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001648 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E730:'], 1)
Bram Moolenaara9749532021-03-06 18:18:19 +01001649
1650 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001651 echo 'a' .. {a: 1}
1652 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001653 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E731:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001654
1655 lines =<< trim END
1656 echo 'a' .. test_void()
1657 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001658 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001659
1660 lines =<< trim END
1661 echo 'a' .. 0z33
1662 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001663 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E976:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001664
1665 lines =<< trim END
1666 echo 'a' .. function('len')
1667 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001668 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E729:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001669
1670 lines =<< trim END
Bram Moolenaara9749532021-03-06 18:18:19 +01001671 new
1672 ['']->setline(1)
1673 /pattern
1674
1675 eval 0
1676 bwipe!
1677 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001678 v9.CheckDefAndScriptFailure(lines, "E1004: White space required before and after '/' at \"/pattern", 3)
mityu4ac198c2021-05-28 17:52:40 +02001679
1680 for op in ['+', '-']
1681 lines = ['var x = 1', op .. '2', '# comment']
1682 var msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001683 v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02001684 endfor
Bram Moolenaar79182382020-09-05 20:06:33 +02001685enddef
1686
1687def Test_expr5_vim9script_channel()
1688 if !has('channel')
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001689 MissingFeature 'channel'
Bram Moolenaar79182382020-09-05 20:06:33 +02001690 else
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001691 var lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001692 echo 'a' .. test_null_job()
1693 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001694 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001695 lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001696 echo 'a' .. test_null_channel()
1697 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001698 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001699 endif
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001700enddef
1701
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001702def Test_expr5_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001703 if !has('float')
1704 MissingFeature 'float'
1705 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001706 var lines =<< trim END
1707 assert_equal(66.0, 60.0 + 6.0)
1708 assert_equal(66.0, 60.0 + 6)
1709 assert_equal(66.0, 60 +
1710 6.0)
1711 assert_equal(5.1, g:afloat
1712 + 5)
1713 assert_equal(8.1, 8 + g:afloat)
1714 assert_equal(10.1, g:anint + g:afloat)
1715 assert_equal(10.1, g:afloat + g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001716
Bram Moolenaar659bb222020-11-12 20:16:39 +01001717 assert_equal(54.0, 60.0 - 6.0)
1718 assert_equal(54.0, 60.0
1719 - 6)
1720 assert_equal(54.0, 60 - 6.0)
1721 assert_equal(-4.9, g:afloat - 5)
1722 assert_equal(7.9, 8 - g:afloat)
1723 assert_equal(9.9, g:anint - g:afloat)
1724 assert_equal(-9.9, g:afloat - g:anint)
1725 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001726 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001727 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001728enddef
1729
1730func Test_expr5_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001731 let msg = "White space required before and after '+'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001732 call v9.CheckDefAndScriptFailure(["var x = 1+2"], msg, 1)
1733 call v9.CheckDefAndScriptFailure(["var x = 1 +2"], msg, 1)
1734 call v9.CheckDefAndScriptFailure(["var x = 1+ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001735
Bram Moolenaar77072282020-09-16 17:55:40 +02001736 let msg = "White space required before and after '-'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001737 call v9.CheckDefAndScriptFailure(["var x = 1-2"], msg, 1)
1738 call v9.CheckDefAndScriptFailure(["var x = 1 -2"], msg, 1)
1739 call v9.CheckDefAndScriptFailure(["var x = 1- 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001740
Bram Moolenaar77072282020-09-16 17:55:40 +02001741 let msg = "White space required before and after '..'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001742 call v9.CheckDefAndScriptFailure(["var x = '1'..'2'"], msg, 1)
1743 call v9.CheckDefAndScriptFailure(["var x = '1' ..'2'"], msg, 1)
1744 call v9.CheckDefAndScriptFailure(["var x = '1'.. '2'"], msg, 1)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001745
Bram Moolenaar62aec932022-01-29 21:45:34 +00001746 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + 33"], ['E1051:', 'E974:'], 1)
1747 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + [3]"], ['E1051:', 'E974:'], 1)
1748 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + 'asd'"], ['E1051:', 'E974:'], 1)
1749 call v9.CheckDefAndScriptFailure(["var x = 33 + 0z1122"], ['E1051:', 'E974:'], 1)
1750 call v9.CheckDefAndScriptFailure(["var x = [3] + 0z1122"], ['E1051:', 'E745:'], 1)
1751 call v9.CheckDefAndScriptFailure(["var x = 'asdf' + 0z1122"], ['E1051:', 'E1030:'], 1)
1752 call v9.CheckDefAndScriptFailure(["var x = 6 + xxx"], ['E1001:', 'E121:'], 1)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001753
Bram Moolenaar62aec932022-01-29 21:45:34 +00001754 call v9.CheckDefAndScriptFailure(["var x = 'a' .. [1]"], ['E1105:', 'E730:'], 1)
1755 call v9.CheckDefAndScriptFailure(["var x = 'a' .. {a: 1}"], ['E1105:', 'E731:'], 1)
1756 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_void()"], ['E1105:', 'E908:'], 1)
1757 call v9.CheckDefAndScriptFailure(["var x = 'a' .. 0z32"], ['E1105:', 'E976:'], 1)
1758 call v9.CheckDefAndScriptFailure(["var x = 'a' .. function('len')"], ['E1105:', 'E729:'], 1)
1759 call v9.CheckDefAndScriptFailure(["var x = 'a' .. function('len', ['a'])"], ['E1105:', 'E729:'], 1)
Bram Moolenaard92cc132020-11-18 17:17:15 +01001760
Bram Moolenaar62aec932022-01-29 21:45:34 +00001761 call v9.CheckDefAndScriptFailure(['var x = 1 + v:none'], ['E1051:', 'E611:'], 1)
1762 call v9.CheckDefAndScriptFailure(['var x = 1 + v:null'], ['E1051:', 'E611:'], 1)
1763 call v9.CheckDefAndScriptFailure(['var x = 1 + v:true'], ['E1051:', 'E1138:'], 1)
1764 call v9.CheckDefAndScriptFailure(['var x = 1 + v:false'], ['E1051:', 'E1138:'], 1)
1765 call v9.CheckDefAndScriptFailure(['var x = 1 + true'], ['E1051:', 'E1138:'], 1)
1766 call v9.CheckDefAndScriptFailure(['var x = 1 + false'], ['E1051:', 'E1138:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001767endfunc
1768
1769func Test_expr5_fails_channel()
Bram Moolenaareb6c2762022-01-31 13:36:36 +00001770 CheckFeature channel
1771
Bram Moolenaar62aec932022-01-29 21:45:34 +00001772 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_null_job()"], ['E1105:', 'E908:'], 1)
1773 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_null_channel()"], ['E1105:', 'E908:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001774endfunc
1775
Bram Moolenaar399ea812020-12-15 21:28:57 +01001776def Test_expr5_list_add()
Bram Moolenaar90193e62021-04-04 20:49:50 +02001777 var lines =<< trim END
1778 # concatenating two lists with same member types is OK
1779 var d = {}
1780 for i in ['a'] + ['b']
1781 d = {[i]: 0}
1782 endfor
Bram Moolenaar399ea812020-12-15 21:28:57 +01001783
Bram Moolenaar90193e62021-04-04 20:49:50 +02001784 # concatenating two lists with different member types results in "any"
1785 var dany = {}
1786 for i in ['a'] + [12]
1787 dany[i] = i
1788 endfor
1789 assert_equal({a: 'a', 12: 12}, dany)
Bram Moolenaard345fb92021-03-10 18:43:09 +01001790
Bram Moolenaar90193e62021-04-04 20:49:50 +02001791 # result of glob() is "any", runtime type check
1792 var sl: list<string> = glob('*.txt', false, true) + ['']
Bram Moolenaar7676c152022-02-03 21:47:34 +00001793
1794 var lln: list<list<number>> = [[1] + [2]]
1795 assert_equal([[1, 2]], lln)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001796 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001797 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar46950b22022-02-04 11:36:51 +00001798
1799 lines =<< trim END
1800 var ln: list<number> = [0]
1801 var lln: list<list<number>> = [ln + []]
1802 END
1803 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar399ea812020-12-15 21:28:57 +01001804enddef
1805
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001806" test multiply, divide, modulo
1807def Test_expr6()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001808 var lines =<< trim END
1809 assert_equal(36, 6 * 6)
1810 assert_equal(24, 6 *
1811 g:thefour)
1812 assert_equal(24, g:thefour
1813 * 6)
1814 assert_equal(40, g:anint * g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001815
Bram Moolenaar659bb222020-11-12 20:16:39 +01001816 assert_equal(10, 60 / 6)
1817 assert_equal(6, 60 /
1818 g:anint)
1819 assert_equal(1, g:anint / 6)
1820 assert_equal(2, g:anint
1821 / g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001822
Bram Moolenaar659bb222020-11-12 20:16:39 +01001823 assert_equal(5, 11 % 6)
1824 assert_equal(4, g:anint % 6)
1825 assert_equal(3, 13 %
1826 g:anint)
1827 assert_equal(2, g:anint
1828 % g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001829
Bram Moolenaar659bb222020-11-12 20:16:39 +01001830 assert_equal(4, 6 * 4 / 6)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001831
Bram Moolenaar659bb222020-11-12 20:16:39 +01001832 var x = [2]
1833 var y = [3]
1834 assert_equal(5, x[0] + y[0])
1835 assert_equal(6, x[0] * y[0])
1836 if has('float')
1837 var xf = [2.0]
1838 var yf = [3.0]
1839 assert_equal(5.0, xf[0]
1840 + yf[0])
1841 assert_equal(6.0, xf[0]
1842 * yf[0])
1843 endif
1844 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001845 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001846
Bram Moolenaar62aec932022-01-29 21:45:34 +00001847 v9.CheckDefAndScriptFailure(["var x = 6 * xxx"], ['E1001:', 'E121:'], 1)
1848 v9.CheckDefFailure(["var d = 6 * "], 'E1097:', 3)
1849 v9.CheckScriptFailure(['vim9script', "var d = 6 * "], 'E15:', 2)
Bram Moolenaar99880f92021-01-20 21:23:14 +01001850
Bram Moolenaar62aec932022-01-29 21:45:34 +00001851 v9.CheckDefExecAndScriptFailure(['echo 1 / 0'], 'E1154', 1)
1852 v9.CheckDefExecAndScriptFailure(['echo 1 % 0'], 'E1154', 1)
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001853
Bram Moolenaar0c7f2612022-02-17 19:44:07 +00001854 if has('float')
1855 v9.CheckDefExecAndScriptFailure([
1856 'g:one = 1.0'
1857 'g:two = 2.0'
1858 'echo g:one % g:two'
1859 ], 'E804', 3)
1860 endif
1861
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001862 lines =<< trim END
1863 var n = 0
1864 eval 1 / n
1865 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001866 v9.CheckDefExecAndScriptFailure(lines, 'E1154', 2)
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001867
1868 lines =<< trim END
1869 var n = 0
1870 eval 1 % n
1871 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001872 v9.CheckDefExecAndScriptFailure(lines, 'E1154', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001873enddef
1874
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001875def Test_expr6_vim9script()
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001876 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001877 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001878 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001879 * 22
1880 / 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001881 assert_equal(80, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001882 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001883 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001884
1885 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001886 var name = 25
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001887 % 10
Bram Moolenaar98309382020-09-27 21:58:45 +02001888 assert_equal(5, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001889 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001890 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001891
1892 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001893 var name = 25
1894 # comment
1895
1896 # comment
1897 % 10
1898 assert_equal(5, name)
1899 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001900 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001901
1902 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001903 var name = 11 *
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001904 22 /
1905 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001906 assert_equal(80, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001907 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001908 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001909
1910 # check white space
1911 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001912 echo 5*6
1913 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001914 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001915
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001916 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001917 echo 5 *6
1918 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001919 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001920
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001921 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001922 echo 5* 6
1923 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001924 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001925enddef
1926
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001927def Test_expr6_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001928 if !has('float')
1929 MissingFeature 'float'
1930 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001931 var lines =<< trim END
1932 assert_equal(36.0, 6.0 * 6)
1933 assert_equal(36.0, 6 *
1934 6.0)
1935 assert_equal(36.0, 6.0 * 6.0)
1936 assert_equal(1.0, g:afloat * g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001937
Bram Moolenaar659bb222020-11-12 20:16:39 +01001938 assert_equal(10.0, 60 / 6.0)
1939 assert_equal(10.0, 60.0 /
1940 6)
1941 assert_equal(10.0, 60.0 / 6.0)
1942 assert_equal(0.01, g:afloat / g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001943
Bram Moolenaar659bb222020-11-12 20:16:39 +01001944 assert_equal(4.0, 6.0 * 4 / 6)
1945 assert_equal(4.0, 6 *
1946 4.0 /
1947 6)
1948 assert_equal(4.0, 6 * 4 / 6.0)
1949 assert_equal(4.0, 6.0 * 4.0 / 6)
1950 assert_equal(4.0, 6 * 4.0 / 6.0)
1951 assert_equal(4.0, 6.0 * 4 / 6.0)
1952 assert_equal(4.0, 6.0 * 4.0 / 6.0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001953
Bram Moolenaar659bb222020-11-12 20:16:39 +01001954 assert_equal(4.0, 6.0 * 4.0 / 6.0)
1955 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001956 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001957 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001958enddef
1959
1960func Test_expr6_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001961 let msg = "White space required before and after '*'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001962 call v9.CheckDefAndScriptFailure(["var x = 1*2"], msg, 1)
1963 call v9.CheckDefAndScriptFailure(["var x = 1 *2"], msg, 1)
1964 call v9.CheckDefAndScriptFailure(["var x = 1* 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001965
Bram Moolenaar77072282020-09-16 17:55:40 +02001966 let msg = "White space required before and after '/'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001967 call v9.CheckDefAndScriptFailure(["var x = 1/2"], msg, 1)
1968 call v9.CheckDefAndScriptFailure(["var x = 1 /2"], msg, 1)
1969 call v9.CheckDefAndScriptFailure(["var x = 1/ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001970
Bram Moolenaar77072282020-09-16 17:55:40 +02001971 let msg = "White space required before and after '%'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001972 call v9.CheckDefAndScriptFailure(["var x = 1%2"], msg, 1)
1973 call v9.CheckDefAndScriptFailure(["var x = 1 %2"], msg, 1)
1974 call v9.CheckDefAndScriptFailure(["var x = 1% 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001975
Bram Moolenaar62aec932022-01-29 21:45:34 +00001976 call v9.CheckDefAndScriptFailure(["var x = '1' * '2'"], ['E1036:', 'E1030:'], 1)
1977 call v9.CheckDefAndScriptFailure(["var x = '1' / '2'"], ['E1036:', 'E1030:'], 1)
1978 call v9.CheckDefAndScriptFailure(["var x = '1' % '2'"], ['E1035:', 'E1030:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001979
Bram Moolenaar62aec932022-01-29 21:45:34 +00001980 call v9.CheckDefAndScriptFailure(["var x = 0z01 * 0z12"], ['E1036:', 'E974:'], 1)
1981 call v9.CheckDefAndScriptFailure(["var x = 0z01 / 0z12"], ['E1036:', 'E974:'], 1)
1982 call v9.CheckDefAndScriptFailure(["var x = 0z01 % 0z12"], ['E1035:', 'E974:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001983
Bram Moolenaar62aec932022-01-29 21:45:34 +00001984 call v9.CheckDefAndScriptFailure(["var x = [1] * [2]"], ['E1036:', 'E745:'], 1)
1985 call v9.CheckDefAndScriptFailure(["var x = [1] / [2]"], ['E1036:', 'E745:'], 1)
1986 call v9.CheckDefAndScriptFailure(["var x = [1] % [2]"], ['E1035:', 'E745:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001987
Bram Moolenaar62aec932022-01-29 21:45:34 +00001988 call v9.CheckDefAndScriptFailure(["var x = {one: 1} * {two: 2}"], ['E1036:', 'E728:'], 1)
1989 call v9.CheckDefAndScriptFailure(["var x = {one: 1} / {two: 2}"], ['E1036:', 'E728:'], 1)
1990 call v9.CheckDefAndScriptFailure(["var x = {one: 1} % {two: 2}"], ['E1035:', 'E728:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001991
Bram Moolenaar62aec932022-01-29 21:45:34 +00001992 call v9.CheckDefAndScriptFailure(["var x = 0xff[1]"], ['E1107:', 'E1062:'], 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001993 if has('float')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001994 call v9.CheckDefAndScriptFailure(["var x = 0.7[1]"], ['E1107:', 'E806:'], 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001995 endif
mityu4ac198c2021-05-28 17:52:40 +02001996
1997 for op in ['*', '/', '%']
1998 let lines = ['var x = 1', op .. '2', '# comment']
1999 let msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002000 call v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02002001 endfor
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002002endfunc
2003
2004func Test_expr6_float_fails()
Bram Moolenaareb6c2762022-01-31 13:36:36 +00002005 CheckFeature float
Bram Moolenaar62aec932022-01-29 21:45:34 +00002006 call v9.CheckDefAndScriptFailure(["var x = 1.0 % 2"], ['E1035:', 'E804:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002007endfunc
2008
2009" define here to use old style parsing
2010if has('float')
2011 let g:float_zero = 0.0
2012 let g:float_neg = -9.8
2013 let g:float_big = 9.9e99
2014endif
2015let g:blob_empty = 0z
2016let g:blob_one = 0z01
2017let g:blob_long = 0z0102.0304
2018
2019let g:string_empty = ''
2020let g:string_short = 'x'
2021let g:string_long = 'abcdefghijklm'
2022let g:string_special = "ab\ncd\ref\ekk"
2023
2024let g:special_true = v:true
2025let g:special_false = v:false
2026let g:special_null = v:null
2027let g:special_none = v:none
2028
2029let g:list_empty = []
2030let g:list_mixed = [1, 'b', v:false]
2031
2032let g:dict_empty = {}
2033let g:dict_one = #{one: 1}
2034
2035let $TESTVAR = 'testvar'
2036
Bram Moolenaar64d662d2020-08-09 19:02:50 +02002037" type casts
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002038def Test_expr7()
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02002039 var lines =<< trim END
2040 var ls: list<string> = ['a', <string>g:string_empty]
2041 var ln: list<number> = [<number>g:anint, <number>g:thefour]
2042 var nr = <number>234
2043 assert_equal(234, nr)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02002044 var b: bool = <bool>1
2045 assert_equal(true, b)
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02002046 var text =
2047 <string>
2048 'text'
2049 if false
2050 text = <number>'xxx'
2051 endif
2052 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002053 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaard1103582020-08-14 22:44:25 +02002054
Bram Moolenaar62aec932022-01-29 21:45:34 +00002055 v9.CheckDefAndScriptFailure(["var x = <nr>123"], 'E1010:', 1)
2056 v9.CheckDefFailure(["var x = <number>"], 'E1097:', 3)
2057 v9.CheckDefFailure(["var x = <number>string(1)"], 'E1012:', 1)
2058 v9.CheckScriptFailure(['vim9script', "var x = <number>"], 'E15:', 2)
2059 v9.CheckDefAndScriptFailure(["var x = <number >123"], 'E1068:', 1)
2060 v9.CheckDefAndScriptFailure(["var x = <number 123"], 'E1104:', 1)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02002061enddef
2062
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002063" test low level expression
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002064def Test_expr8_number()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002065 # number constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01002066 var lines =<< trim END
2067 assert_equal(0, 0)
2068 assert_equal(654, 0654)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002069
Bram Moolenaar659bb222020-11-12 20:16:39 +01002070 assert_equal(6, 0x6)
2071 assert_equal(15, 0xf)
2072 assert_equal(255, 0xff)
2073 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002074 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002075enddef
2076
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002077def Test_expr8_float()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002078 # float constant
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01002079 if !has('float')
2080 MissingFeature 'float'
2081 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01002082 var lines =<< trim END
2083 assert_equal(g:float_zero, .0)
2084 assert_equal(g:float_zero, 0.0)
2085 assert_equal(g:float_neg, -9.8)
2086 assert_equal(g:float_big, 9.9e99)
2087 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002088 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002089 endif
2090enddef
2091
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002092def Test_expr8_blob()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002093 # blob constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01002094 var lines =<< trim END
2095 assert_equal(g:blob_empty, 0z)
2096 assert_equal(g:blob_one, 0z01)
2097 assert_equal(g:blob_long, 0z0102.0304)
Bram Moolenaarcfc30232021-04-11 20:26:34 +02002098
2099 var testblob = 0z010203
2100 assert_equal(0x01, testblob[0])
2101 assert_equal(0x02, testblob[1])
2102 assert_equal(0x03, testblob[-1])
2103 assert_equal(0x02, testblob[-2])
2104
2105 assert_equal(0z01, testblob[0 : 0])
2106 assert_equal(0z0102, testblob[0 : 1])
2107 assert_equal(0z010203, testblob[0 : 2])
2108 assert_equal(0z010203, testblob[0 : ])
2109 assert_equal(0z0203, testblob[1 : ])
2110 assert_equal(0z0203, testblob[1 : 2])
2111 assert_equal(0z0203, testblob[1 : -1])
2112 assert_equal(0z03, testblob[-1 : -1])
2113 assert_equal(0z02, testblob[-2 : -2])
2114
2115 # blob slice accepts out of range
2116 assert_equal(0z, testblob[3 : 3])
2117 assert_equal(0z, testblob[0 : -4])
Bram Moolenaar659bb222020-11-12 20:16:39 +01002118 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002119 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02002120
Bram Moolenaar62aec932022-01-29 21:45:34 +00002121 v9.CheckDefAndScriptFailure(["var x = 0z123"], 'E973:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002122enddef
2123
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002124def Test_expr8_string()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002125 # string constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01002126 var lines =<< trim END
2127 assert_equal(g:string_empty, '')
2128 assert_equal(g:string_empty, "")
2129 assert_equal(g:string_short, 'x')
2130 assert_equal(g:string_short, "x")
2131 assert_equal(g:string_long, 'abcdefghijklm')
2132 assert_equal(g:string_long, "abcdefghijklm")
2133 assert_equal(g:string_special, "ab\ncd\ref\ekk")
2134 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002135 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02002136
Bram Moolenaar62aec932022-01-29 21:45:34 +00002137 v9.CheckDefAndScriptFailure(['var x = "abc'], 'E114:', 1)
2138 v9.CheckDefAndScriptFailure(["var x = 'abc"], 'E115:', 1)
Bram Moolenaar83d0cec2022-02-04 21:17:58 +00002139 v9.CheckDefFailure(["if 0", "echo 'xx", "endif"], 'E115', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002140enddef
2141
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002142def Test_expr8_vimvar()
Bram Moolenaard787e402021-12-24 21:36:12 +00002143 v:errors = []
2144 var errs: list<string> = v:errors
Bram Moolenaar62aec932022-01-29 21:45:34 +00002145 v9.CheckDefFailure(['var errs: list<number> = v:errors'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00002146
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002147 var old: list<string> = v:oldfiles
Bram Moolenaar62aec932022-01-29 21:45:34 +00002148 v9.CheckDefFailure(['var old: list<number> = v:oldfiles'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00002149
2150 var compl: dict<string> = v:completed_item
Bram Moolenaar62aec932022-01-29 21:45:34 +00002151 v9.CheckDefFailure(['var compl: dict<number> = v:completed_item'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00002152
2153 var args: list<string> = v:argv
Bram Moolenaar62aec932022-01-29 21:45:34 +00002154 v9.CheckDefFailure(['var args: list<number> = v:argv'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00002155
2156 var colors: dict<string> = v:colornames
Bram Moolenaar62aec932022-01-29 21:45:34 +00002157 v9.CheckDefFailure(['var colors: dict<number> = v:colornames'], 'E1012:')
Bram Moolenaar5da356e2020-04-09 19:34:43 +02002158
Bram Moolenaar62aec932022-01-29 21:45:34 +00002159 v9.CheckDefFailure(["var old: list<number> = v:oldfiles"], 'E1012: Type mismatch; expected list<number> but got list<string>', 1)
2160 v9.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 +02002161 new
2162 exec "normal! afoo fo\<C-N>\<Esc>"
Bram Moolenaar62aec932022-01-29 21:45:34 +00002163 v9.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 +02002164 bwipe!
Bram Moolenaar5da356e2020-04-09 19:34:43 +02002165enddef
2166
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002167def Test_expr8_special()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002168 # special constant
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002169 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002170 assert_equal(g:special_true, true)
2171 assert_equal(g:special_false, false)
2172 assert_equal(g:special_true, v:true)
2173 assert_equal(g:special_false, v:false)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02002174 assert_equal(v:true, true)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02002175 assert_equal(v:false, false)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002176
Bram Moolenaar6e4cfff2020-08-09 22:17:55 +02002177 assert_equal(true, !false)
2178 assert_equal(false, !true)
2179 assert_equal(true, !0)
2180 assert_equal(false, !1)
2181 assert_equal(false, !!false)
2182 assert_equal(true, !!true)
2183 assert_equal(false, !!0)
2184 assert_equal(true, !!1)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002185
2186 var t = true
2187 var f = false
2188 assert_equal(true, t)
2189 assert_equal(false, f)
2190
2191 assert_equal(g:special_null, v:null)
Bram Moolenaar67977822021-01-03 21:53:53 +01002192 assert_equal(g:special_null, null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002193 assert_equal(g:special_none, v:none)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02002194 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002195 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002196
Bram Moolenaar62aec932022-01-29 21:45:34 +00002197 v9.CheckDefAndScriptFailure(['v:true = true'], 'E46:', 1)
2198 v9.CheckDefAndScriptFailure(['v:true = false'], 'E46:', 1)
2199 v9.CheckDefAndScriptFailure(['v:false = true'], 'E46:', 1)
2200 v9.CheckDefAndScriptFailure(['v:null = 11'], 'E46:', 1)
2201 v9.CheckDefAndScriptFailure(['v:none = 22'], 'E46:', 1)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02002202enddef
2203
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002204def Test_expr8_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002205 # list
Bram Moolenaar659bb222020-11-12 20:16:39 +01002206 var lines =<< trim END
2207 assert_equal(g:list_empty, [])
2208 assert_equal(g:list_empty, [ ])
Bram Moolenaar127542b2020-08-09 17:22:04 +02002209
Bram Moolenaar659bb222020-11-12 20:16:39 +01002210 var numbers: list<number> = [1, 2, 3]
2211 numbers = [1]
2212 numbers = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02002213
Bram Moolenaar659bb222020-11-12 20:16:39 +01002214 var strings: list<string> = ['a', 'b', 'c']
2215 strings = ['x']
2216 strings = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02002217
Bram Moolenaar659bb222020-11-12 20:16:39 +01002218 var mixed: list<any> = [1, 'b', false,]
2219 assert_equal(g:list_mixed, mixed)
2220 assert_equal('b', mixed[1])
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002221
Bram Moolenaar659bb222020-11-12 20:16:39 +01002222 echo [1,
2223 2] [3,
2224 4]
Bram Moolenaarbadd8482020-07-31 22:38:17 +02002225
Bram Moolenaar659bb222020-11-12 20:16:39 +01002226 var llstring: list<list<string>> = [['text'], []]
2227 llstring = [[], ['text']]
2228 llstring = [[], []]
Bram Moolenaard597ab02022-03-16 17:56:33 +00002229
2230 var ls = [null_string]
2231 assert_equal('list<string>', typename(ls))
2232 var lb = [null_blob]
2233 assert_equal('list<blob>', typename(lb))
Bram Moolenaar659bb222020-11-12 20:16:39 +01002234 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002235 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002236
Bram Moolenaar5597ba02020-09-27 17:45:03 +02002237 var rangelist: list<number> = range(3)
2238 g:rangelist = range(3)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002239 v9.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 +02002240
Bram Moolenaar62aec932022-01-29 21:45:34 +00002241 v9.CheckDefAndScriptFailure(["var x = 1234[3]"], ['E1107:', 'E1062:'], 1)
2242 v9.CheckDefExecAndScriptFailure(["var x = g:anint[3]"], 'E1062:', 1)
Bram Moolenaar56acb092020-08-16 14:48:19 +02002243
Bram Moolenaar62aec932022-01-29 21:45:34 +00002244 v9.CheckDefAndScriptFailure(["var x = g:list_mixed[xxx]"], ['E1001:', 'E121:'], 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002245
Bram Moolenaar62aec932022-01-29 21:45:34 +00002246 v9.CheckDefAndScriptFailure(["var x = [1,2,3]"], 'E1069:', 1)
2247 v9.CheckDefAndScriptFailure(["var x = [1 ,2, 3]"], 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002248
Bram Moolenaar62aec932022-01-29 21:45:34 +00002249 v9.CheckDefExecAndScriptFailure(["echo 1", "var x = [][0]", "echo 3"], 'E684:', 2)
Bram Moolenaar1d634542020-08-18 13:41:50 +02002250
Bram Moolenaar62aec932022-01-29 21:45:34 +00002251 v9.CheckDefExecAndScriptFailure(["var x = g:list_mixed['xx']"], ['E1012:', 'E1030:'], 1)
2252 v9.CheckDefFailure(["var x = g:list_mixed["], 'E1097:', 3)
2253 v9.CheckScriptFailure(['vim9script', "var x = g:list_mixed["], 'E15:', 2)
2254 v9.CheckDefFailure(["var x = g:list_mixed[0"], 'E1097:', 3)
2255 v9.CheckScriptFailure(['vim9script', "var x = g:list_mixed[0"], 'E111:', 2)
2256 v9.CheckDefExecAndScriptFailure(["var x = g:list_empty[3]"], 'E684:', 1)
2257 v9.CheckDefExecAndScriptFailure(["var l: list<number> = [234, 'x']"], 'E1012:', 1)
2258 v9.CheckDefExecAndScriptFailure(["var l: list<number> = ['x', 234]"], 'E1012:', 1)
2259 v9.CheckDefExecAndScriptFailure(["var l: list<string> = [234, 'x']"], 'E1012:', 1)
2260 v9.CheckDefExecAndScriptFailure(["var l: list<string> = ['x', 123]"], 'E1012:', 1)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02002261
Bram Moolenaar659bb222020-11-12 20:16:39 +01002262 lines =<< trim END
Bram Moolenaarc1f00662020-10-03 13:41:53 +02002263 var datalist: list<string>
2264 def Main()
2265 datalist += ['x'.
2266 enddef
2267 Main()
2268 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002269 v9.CheckDefAndScriptFailure(lines, 'E1127:')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002270
2271 lines =<< trim END
2272 var numbers = [1, 2, 3, 4]
2273 var a = 1
2274 var b = 2
2275 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002276 v9.CheckDefAndScriptFailure(lines + ['echo numbers[1:b]'],
Bram Moolenaare7a73e02021-01-01 19:17:55 +01002277 'E1004: White space required before and after '':'' at ":b]"', 4)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002278 v9.CheckDefAndScriptFailure(lines + ['echo numbers[1: b]'], 'E1004:', 4)
2279 v9.CheckDefAndScriptFailure(lines + ['echo numbers[a :b]'], 'E1004:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002280enddef
2281
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002282def Test_expr8_list_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002283 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002284 var l = [
Bram Moolenaar71478202020-06-26 22:46:27 +02002285 11,
2286 22,
2287 ]
2288 assert_equal([11, 22], l)
Bram Moolenaarbadd8482020-07-31 22:38:17 +02002289
2290 echo [1,
2291 2] [3,
2292 4]
Bram Moolenaar93be1642020-10-11 21:34:41 +02002293
2294 echo [1, # comment
2295 # comment
2296 2] [3,
2297 # comment
2298 4]
Bram Moolenaar71478202020-06-26 22:46:27 +02002299 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002300 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar71478202020-06-26 22:46:27 +02002301
2302 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002303 var l = [11,
Bram Moolenaar71478202020-06-26 22:46:27 +02002304 22]
2305 assert_equal([11, 22], l)
2306 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002307 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002308
2309 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002310 var l = [11,22]
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002311 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002312 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002313
2314 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002315 var l = [11 , 22]
Bram Moolenaardb199212020-08-12 18:01:53 +02002316 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002317 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002318
2319 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002320 var l: list<number> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002321 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002322 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002323
2324 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002325 var l: list<number> = ['x', 234]
2326 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002327 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002328
2329 lines =<< trim END
2330 var l: list<string> = ['x', 234]
2331 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002332 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002333
2334 lines =<< trim END
2335 var l: list<string> = [234, 'x']
2336 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002337 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002338
2339 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002340 def Failing()
2341 job_stop()
2342 enddef
2343 var list = [Failing]
2344 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002345 if has('channel')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002346 v9.CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002347 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00002348 v9.CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002349 endif
Bram Moolenaar71478202020-06-26 22:46:27 +02002350enddef
2351
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002352def LambdaWithComments(): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002353 return (x) =>
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002354 # some comment
2355 x == 1
2356 # some comment
2357 ||
2358 x == 2
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002359enddef
2360
Bram Moolenaarfd777482020-08-12 19:42:01 +02002361def LambdaUsingArg(x: number): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002362 return () =>
Bram Moolenaarfd777482020-08-12 19:42:01 +02002363 # some comment
2364 x == 1
2365 # some comment
2366 ||
2367 x == 2
Bram Moolenaarfd777482020-08-12 19:42:01 +02002368enddef
2369
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002370def Test_expr8_lambda()
Bram Moolenaar659bb222020-11-12 20:16:39 +01002371 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002372 var La = () => 'result'
Bram Moolenaar03717bf2021-04-28 20:00:40 +02002373 # comment
Bram Moolenaar659bb222020-11-12 20:16:39 +01002374 assert_equal('result', La())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002375 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02002376
Bram Moolenaar659bb222020-11-12 20:16:39 +01002377 # line continuation inside lambda with "cond ? expr : expr" works
2378 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002379 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002380 ['111']: 111 } : {}
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002381 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002382 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002383
Bram Moolenaar03717bf2021-04-28 20:00:40 +02002384 # comment halfway an expression
2385 var Ref = () => 4
2386 # comment
2387 + 6
2388 assert_equal(10, Ref())
2389
Bram Moolenaar659bb222020-11-12 20:16:39 +01002390 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002391 map(ll, (k, v) => v == 8 || v
Bram Moolenaar659bb222020-11-12 20:16:39 +01002392 == 9
2393 || v % 2 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002394 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01002395 assert_equal([222, 111, 222], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002396
Bram Moolenaar659bb222020-11-12 20:16:39 +01002397 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002398 map(ll, (k, v) => v != 8 && v
Bram Moolenaar659bb222020-11-12 20:16:39 +01002399 != 9
2400 && v % 2 == 0 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002401 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01002402 assert_equal([111, 222, 111], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002403
Bram Moolenaar18024052021-12-25 21:43:28 +00002404 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => !!v['key'] )
Bram Moolenaare0de1712020-12-02 17:36:54 +01002405 assert_equal([{key: 22}], dl)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02002406
Bram Moolenaare0de1712020-12-02 17:36:54 +01002407 dl = [{key: 12}, {['foo']: 34}]
2408 assert_equal([{key: 12}], filter(dl,
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002409 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
Bram Moolenaar7892b952020-07-20 22:09:34 +02002410
Bram Moolenaar62aec932022-01-29 21:45:34 +00002411 assert_equal(false, g:LambdaWithComments()(0))
2412 assert_equal(true, g:LambdaWithComments()(1))
2413 assert_equal(true, g:LambdaWithComments()(2))
2414 assert_equal(false, g:LambdaWithComments()(3))
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002415
Bram Moolenaar62aec932022-01-29 21:45:34 +00002416 assert_equal(false, g:LambdaUsingArg(0)())
2417 assert_equal(true, g:LambdaUsingArg(1)())
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01002418
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002419 var res = map([1, 2, 3], (i: number, v: number) => i + v)
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01002420 assert_equal([1, 3, 5], res)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002421 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002422 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfd777482020-08-12 19:42:01 +02002423
Bram Moolenaar62aec932022-01-29 21:45:34 +00002424 v9.CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2425 v9.CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004: White space required before and after ''=>'' at "=> a + 1"')
2426 v9.CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"], 'E1004:')
2427 v9.CheckDefAndScriptFailure(["var Ref = (a) =< a + 1"], ['E1001:', 'E121:'])
2428 v9.CheckDefAndScriptFailure(["var Ref = (a: int) => a + 1"], 'E1010:')
2429 v9.CheckDefAndScriptFailure(["var Ref = (a): int => a + 1"], 'E1010:')
Bram Moolenaar27bf7af2020-12-23 20:27:31 +01002430
Bram Moolenaar62aec932022-01-29 21:45:34 +00002431 v9.CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002432 # error is in first line of the lambda
Bram Moolenaar62aec932022-01-29 21:45:34 +00002433 v9.CheckDefAndScriptFailure(["var L = (a) => a + b"], 'E1001:', 0)
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002434
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002435 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002436
Bram Moolenaar62aec932022-01-29 21:45:34 +00002437 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"], 'E118:')
2438 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"], 'E118:')
2439 v9.CheckDefAndScriptFailure(["echo 'asdf'->((a) => a)(x)"], ['E1001:', 'E121:'], 1)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002440
Bram Moolenaar62aec932022-01-29 21:45:34 +00002441 v9.CheckDefAndScriptSuccess(['var Fx = (a) => ({k1: 0,', ' k2: 1})'])
2442 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2443 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002444
Bram Moolenaar62aec932022-01-29 21:45:34 +00002445 v9.CheckDefAndScriptSuccess(['var Fx = (a) => [0,', ' 1]'])
2446 v9.CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002447
2448 # no error for existing script variable when checking for lambda
2449 lines =<< trim END
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002450 var name = 0
2451 eval (name + 2) / 3
2452 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002453 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002454enddef
2455
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002456def Test_expr8_lambda_block()
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002457 var lines =<< trim END
2458 var Func = (s: string): string => {
2459 return 'hello ' .. s
2460 }
2461 assert_equal('hello there', Func('there'))
2462
2463 var ll = range(3)
2464 var dll = mapnew(ll, (k, v): string => {
2465 if v % 2
2466 return 'yes'
2467 endif
2468 return 'no'
2469 })
2470 assert_equal(['no', 'yes', 'no'], dll)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002471
Bram Moolenaarac2cd2b2021-07-19 21:04:23 +02002472 # ignored_inline(0, (_) => {
2473 # echo 'body'
2474 # })
2475
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002476 sandbox var Safe = (nr: number): number => {
2477 return nr + 7
2478 }
2479 assert_equal(10, Safe(3))
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002480 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002481 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare98f60a2021-03-22 18:22:30 +01002482
2483 lines =<< trim END
2484 map([1, 2], (k, v) => { redrawt })
2485 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002486 v9.CheckDefAndScriptFailure(lines, 'E488')
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002487
2488 lines =<< trim END
2489 var Func = (nr: int) => {
2490 echo nr
2491 }
2492 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002493 v9.CheckDefAndScriptFailure(lines, 'E1010', 1)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002494
2495 lines =<< trim END
2496 var Func = (nr: number): int => {
2497 return nr
2498 }
2499 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002500 v9.CheckDefAndScriptFailure(lines, 'E1010', 1)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002501
2502 lines =<< trim END
2503 var Func = (nr: number): int => {
2504 return nr
2505 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002506 v9.CheckDefFailure(lines, 'E1171', 0) # line nr is function start
2507 v9.CheckScriptFailure(['vim9script'] + lines, 'E1171', 2)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002508
2509 lines =<< trim END
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002510 var Func = (nr: number): int => {
2511 var ll =<< ENDIT
2512 nothing
2513 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002514 v9.CheckDefFailure(lines, 'E1145: Missing heredoc end marker: ENDIT', 0)
2515 v9.CheckScriptFailure(['vim9script'] + lines, 'E1145: Missing heredoc end marker: ENDIT', 2)
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002516enddef
2517
Bram Moolenaar65c44152020-12-24 15:14:01 +01002518def NewLambdaWithComments(): func
2519 return (x) =>
2520 # some comment
2521 x == 1
2522 # some comment
2523 ||
2524 x == 2
2525enddef
2526
2527def NewLambdaUsingArg(x: number): func
2528 return () =>
2529 # some comment
2530 x == 1
2531 # some comment
2532 ||
2533 x == 2
2534enddef
2535
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002536def Test_expr8_new_lambda()
Bram Moolenaar65c44152020-12-24 15:14:01 +01002537 var lines =<< trim END
2538 var La = () => 'result'
2539 assert_equal('result', La())
2540 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
2541
2542 # line continuation inside lambda with "cond ? expr : expr" works
2543 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002544 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaar65c44152020-12-24 15:14:01 +01002545 ['111']: 111 } : {}
2546 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002547 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002548
2549 ll = range(3)
2550 map(ll, (k, v) => v == 8 || v
2551 == 9
2552 || v % 2 ? 111 : 222
2553 )
2554 assert_equal([222, 111, 222], ll)
2555
2556 ll = range(3)
2557 map(ll, (k, v) => v != 8 && v
2558 != 9
2559 && v % 2 == 0 ? 111 : 222
2560 )
2561 assert_equal([111, 222, 111], ll)
2562
Bram Moolenaar18024052021-12-25 21:43:28 +00002563 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => !!v['key'] )
Bram Moolenaar65c44152020-12-24 15:14:01 +01002564 assert_equal([{key: 22}], dl)
2565
2566 dl = [{key: 12}, {['foo']: 34}]
2567 assert_equal([{key: 12}], filter(dl,
2568 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
2569
Bram Moolenaar62aec932022-01-29 21:45:34 +00002570 assert_equal(false, g:NewLambdaWithComments()(0))
2571 assert_equal(true, g:NewLambdaWithComments()(1))
2572 assert_equal(true, g:NewLambdaWithComments()(2))
2573 assert_equal(false, g:NewLambdaWithComments()(3))
Bram Moolenaar65c44152020-12-24 15:14:01 +01002574
Bram Moolenaar62aec932022-01-29 21:45:34 +00002575 assert_equal(false, g:NewLambdaUsingArg(0)())
2576 assert_equal(true, g:NewLambdaUsingArg(1)())
Bram Moolenaar65c44152020-12-24 15:14:01 +01002577
2578 var res = map([1, 2, 3], (i: number, v: number) => i + v)
2579 assert_equal([1, 3, 5], res)
2580
2581 # Lambda returning a dict
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002582 var Lmb = () => ({key: 42})
Bram Moolenaar65c44152020-12-24 15:14:01 +01002583 assert_equal({key: 42}, Lmb())
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002584
2585 var RefOne: func(number): string = (a: number): string => 'x'
2586 var RefTwo: func(number): any = (a: number): any => 'x'
2587
2588 var Fx = (a) => ({k1: 0,
2589 k2: 1})
2590 var Fy = (a) => [0,
2591 1]
Bram Moolenaar65c44152020-12-24 15:14:01 +01002592 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002593 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002594
Bram Moolenaar62aec932022-01-29 21:45:34 +00002595 v9.CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2596 v9.CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004:')
2597 v9.CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"],
Bram Moolenaare7a73e02021-01-01 19:17:55 +01002598 'E1004: White space required before and after ''=>'' at " =>a + 1"')
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002599
Bram Moolenaar62aec932022-01-29 21:45:34 +00002600 v9.CheckDefAndScriptFailure(["var Ref: func(number): number = (a: number): string => 'x'"], 'E1012:')
2601 v9.CheckDefAndScriptFailure(["var Ref: func(number): string = (a: number): string => 99"], 'E1012:')
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002602
Bram Moolenaar62aec932022-01-29 21:45:34 +00002603 v9.CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002604 # error is in first line of the lambda
Bram Moolenaar62aec932022-01-29 21:45:34 +00002605 v9.CheckDefAndScriptFailure(["var L = (a) -> a + b"], ['E1001:', 'E121:'], 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002606
Bram Moolenaar90193e62021-04-04 20:49:50 +02002607 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar65c44152020-12-24 15:14:01 +01002608
Bram Moolenaar62aec932022-01-29 21:45:34 +00002609 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"],
Bram Moolenaar90193e62021-04-04 20:49:50 +02002610 'E118: Too many arguments for function:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002611 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"],
Bram Moolenaar90193e62021-04-04 20:49:50 +02002612 'E118: Too many arguments for function:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002613 v9.CheckDefFailure(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002614
Bram Moolenaar62aec932022-01-29 21:45:34 +00002615 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2616 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002617
Bram Moolenaar62aec932022-01-29 21:45:34 +00002618 v9.CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002619enddef
2620
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002621def Test_expr8_lambda_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002622 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002623 var v = 10->((a) =>
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002624 a
2625 + 2
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002626 )()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002627 assert_equal(12, v)
2628 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002629 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002630
2631 # nested lambda with line breaks
2632 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002633 search('"', 'cW', 0, 0, () =>
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002634 synstack('.', col('.'))
Bram Moolenaar18024052021-12-25 21:43:28 +00002635 ->mapnew((_, v) => synIDattr(v, 'name'))->len())
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002636 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002637 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002638enddef
2639
Bram Moolenaara749a422022-02-12 19:52:25 +00002640def Test_expr8funcref()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002641 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002642 def RetNumber(): number
2643 return 123
2644 enddef
2645 var FuncRef = RetNumber
2646 assert_equal(123, FuncRef())
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002647 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002648 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfa596382021-04-07 21:58:16 +02002649
2650 lines =<< trim END
2651 vim9script
2652 func g:GlobalFunc()
2653 return 'global'
2654 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00002655 func ScriptFunc()
Bram Moolenaarfa596382021-04-07 21:58:16 +02002656 return 'script'
2657 endfunc
2658 def Test()
2659 var Ref = g:GlobalFunc
2660 assert_equal('global', Ref())
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002661 Ref = g:GlobalFunc
Bram Moolenaarfa596382021-04-07 21:58:16 +02002662 assert_equal('global', Ref())
2663
Bram Moolenaara749a422022-02-12 19:52:25 +00002664 Ref = ScriptFunc
Bram Moolenaarfa596382021-04-07 21:58:16 +02002665 assert_equal('script', Ref())
2666 Ref = ScriptFunc
2667 assert_equal('script', Ref())
2668 enddef
2669 Test()
2670 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002671 v9.CheckScriptSuccess(lines)
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002672enddef
2673
Bram Moolenaar2bede172020-11-19 18:53:18 +01002674let g:test_space_dict = {'': 'empty', ' ': 'space'}
2675let g:test_hash_dict = #{one: 1, two: 2}
2676
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002677def Test_expr8_dict()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002678 # dictionary
Bram Moolenaar659bb222020-11-12 20:16:39 +01002679 var lines =<< trim END
2680 assert_equal(g:dict_empty, {})
2681 assert_equal(g:dict_empty, { })
Bram Moolenaare0de1712020-12-02 17:36:54 +01002682 assert_equal(g:dict_one, {['one']: 1})
Bram Moolenaar659bb222020-11-12 20:16:39 +01002683 var key = 'one'
2684 var val = 1
Bram Moolenaar2bede172020-11-19 18:53:18 +01002685 assert_equal(g:dict_one, {[key]: val})
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002686
Bram Moolenaar2bede172020-11-19 18:53:18 +01002687 var numbers: dict<number> = {a: 1, b: 2, c: 3}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002688 numbers = {a: 1}
2689 numbers = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002690
Bram Moolenaar2bede172020-11-19 18:53:18 +01002691 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002692 strings = {a: 'x'}
2693 strings = {}
2694
2695 var dash = {xx-x: 8}
2696 assert_equal({['xx-x']: 8}, dash)
2697
2698 var dnr = {8: 8}
2699 assert_equal({['8']: 8}, dnr)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002700
Bram Moolenaar2bede172020-11-19 18:53:18 +01002701 var mixed: dict<any> = {a: 'a', b: 42}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002702 mixed = {a: 'x'}
2703 mixed = {a: 234}
2704 mixed = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002705
Bram Moolenaare0de1712020-12-02 17:36:54 +01002706 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
2707 dictlist = {absent: ['hi'], present: []}
2708 dictlist = {absent: [], present: []}
Bram Moolenaar77b20972020-09-19 14:12:34 +02002709
Bram Moolenaare0de1712020-12-02 17:36:54 +01002710 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
2711 dictdict = {one: {}, two: {a: 'text'}}
2712 dictdict = {one: {}, two: {}}
Bram Moolenaarc7f7f6d2020-11-04 13:38:28 +01002713
Bram Moolenaare0de1712020-12-02 17:36:54 +01002714 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
Bram Moolenaar2bede172020-11-19 18:53:18 +01002715
2716 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
2717 assert_equal(g:test_hash_dict, {one: 1, two: 2})
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01002718
2719 assert_equal({['a a']: 1, ['b/c']: 2}, {'a a': 1, "b/c": 2})
Bram Moolenaar6b553772020-12-31 13:31:23 +01002720
2721 var d = {a: () => 3, b: () => 7}
2722 assert_equal(3, d.a())
2723 assert_equal(7, d.b())
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002724
2725 var cd = { # comment
2726 key: 'val' # comment
2727 }
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002728
2729 # different types used for the key
2730 var dkeys = {['key']: 'string',
2731 [12]: 'numberexpr',
2732 34: 'number',
2733 [true]: 'bool'}
2734 assert_equal('string', dkeys['key'])
2735 assert_equal('numberexpr', dkeys[12])
2736 assert_equal('number', dkeys[34])
2737 assert_equal('bool', dkeys[true])
2738 if has('float')
2739 dkeys = {[1.2]: 'floatexpr', [3.4]: 'float'}
2740 assert_equal('floatexpr', dkeys[1.2])
2741 assert_equal('float', dkeys[3.4])
2742 endif
2743
2744 # automatic conversion from number to string
2745 var n = 123
2746 var dictnr = {[n]: 1}
Bram Moolenaara0399ef2021-03-20 15:00:01 +01002747
2748 # comment to start fold is OK
2749 var x1: number #{{ fold
2750 var x2 = 9 #{{ fold
Bram Moolenaard597ab02022-03-16 17:56:33 +00002751
2752 var ds = {k: null_string}
2753 assert_equal('dict<string>', typename(ds))
2754 var dl = {a: null_list}
2755 assert_equal('dict<list<unknown>>', typename(dl))
Bram Moolenaar659bb222020-11-12 20:16:39 +01002756 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002757 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002758
Bram Moolenaare0de1712020-12-02 17:36:54 +01002759 # legacy syntax doesn't work
Bram Moolenaar62aec932022-01-29 21:45:34 +00002760 v9.CheckDefAndScriptFailure(["var x = #{key: 8}"], 'E1170:', 1)
2761 v9.CheckDefAndScriptFailure(["var x = 'a' #{a: 1}"], 'E1170:', 1)
2762 v9.CheckDefAndScriptFailure(["var x = 'a' .. #{a: 1}"], 'E1170:', 1)
2763 v9.CheckDefAndScriptFailure(["var x = true ? #{a: 1}"], 'E1170:', 1)
Bram Moolenaar17a836c2020-08-12 17:35:58 +02002764
Bram Moolenaar62aec932022-01-29 21:45:34 +00002765 v9.CheckDefAndScriptFailure(["var x = {a:8}"], 'E1069:', 1)
2766 v9.CheckDefAndScriptFailure(["var x = {a : 8}"], 'E1068:', 1)
2767 v9.CheckDefAndScriptFailure(["var x = {a :8}"], 'E1068:', 1)
2768 v9.CheckDefAndScriptFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
2769 v9.CheckDefAndScriptFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002770
Bram Moolenaar62aec932022-01-29 21:45:34 +00002771 v9.CheckDefAndScriptFailure(["var x = {xxx}"], 'E720:', 1)
2772 v9.CheckDefAndScriptFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
2773 v9.CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
2774 v9.CheckScriptFailure(['vim9script', "var x = {xxx: 1,"], 'E723:', 2)
2775 v9.CheckDefAndScriptFailure(["var x = {['a']: xxx}"], ['E1001:', 'E121:'], 1)
2776 v9.CheckDefAndScriptFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
2777 v9.CheckDefExecAndScriptFailure(["var x = g:anint.member"], ['E715:', 'E488:'], 1)
2778 v9.CheckDefExecAndScriptFailure(["var x = g:dict_empty.member"], 'E716:', 1)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002779
Bram Moolenaar62aec932022-01-29 21:45:34 +00002780 v9.CheckDefExecAndScriptFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
2781 v9.CheckDefExecAndScriptFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
2782 v9.CheckDefExecAndScriptFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
2783 v9.CheckDefExecAndScriptFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002784
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002785 # invalid types for the key
Bram Moolenaar62aec932022-01-29 21:45:34 +00002786 v9.CheckDefAndScriptFailure(["var x = {[[1, 2]]: 0}"], ['E1105:', 'E730:'], 1)
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002787
Bram Moolenaar62aec932022-01-29 21:45:34 +00002788 v9.CheckDefFailure(['var x = ({'], 'E723:', 2)
2789 v9.CheckScriptFailure(['vim9script', 'var x = ({'], 'E723:', 2)
2790 v9.CheckDefExecAndScriptFailure(['{}[getftype("file")]'], 'E716: Key not present in Dictionary: ""', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002791enddef
2792
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002793def Test_expr8_dict_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002794 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002795 var d = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002796 ['one']:
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002797 1,
Bram Moolenaare0de1712020-12-02 17:36:54 +01002798 ['two']: 2,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002799 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002800 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar93be1642020-10-11 21:34:41 +02002801
2802 d = { # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002803 ['one']:
Bram Moolenaar93be1642020-10-11 21:34:41 +02002804 # comment
2805
2806 1,
2807 # comment
2808 # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002809 ['two']: 2,
Bram Moolenaar93be1642020-10-11 21:34:41 +02002810 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002811 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002812
2813 var dd = {k: 123->len()}
2814 assert_equal(3, dd.k)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002815 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002816 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002817
2818 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002819 var d = { ["one"]: "one", ["two"]: "two", }
2820 assert_equal({one: 'one', two: 'two'}, d)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002821 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002822 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002823
2824 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002825 var d = {one: 1,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002826 two: 2,
2827 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002828 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002829 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002830 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002831
2832 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002833 var d = {one:1, two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002834 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002835 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002836
2837 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002838 var d = {one: 1,two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002839 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002840 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002841
2842 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002843 var d = {one : 1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002844 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002845 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002846
2847 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002848 var d = {one:1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002849 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002850 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002851
2852 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002853 var d = {one: 1 , two: 2}
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002854 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002855 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002856
2857 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002858 var l: dict<number> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002859 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002860 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002861
2862 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002863 var l: dict<number> = {a: 'x', b: 234}
2864 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002865 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002866
2867 lines =<< trim END
2868 var l: dict<string> = {a: 'x', b: 234}
2869 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002870 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002871
2872 lines =<< trim END
2873 var l: dict<string> = {a: 234, b: 'x'}
2874 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002875 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002876
2877 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002878 var d = {['a']: 234, ['b': 'x'}
2879 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002880 v9.CheckDefAndScriptFailure(lines, 'E1139:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002881
Bram Moolenaar918a4242020-12-06 14:37:08 +01002882 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002883 def Func()
2884 var d = {['a']: 234, ['b': 'x'}
2885 enddef
2886 defcompile
2887 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002888 v9.CheckDefAndScriptFailure(lines, 'E1139:', 0)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002889
Bram Moolenaar918a4242020-12-06 14:37:08 +01002890 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002891 var d = {'a':
2892 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002893 v9.CheckDefFailure(lines, 'E723:', 2)
2894 v9.CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002895
Bram Moolenaar918a4242020-12-06 14:37:08 +01002896 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002897 def Func()
2898 var d = {'a':
2899 enddef
2900 defcompile
2901 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002902 v9.CheckDefAndScriptFailure(lines, 'E723:', 0)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002903
2904 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002905 def Failing()
2906 job_stop()
2907 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002908 var dict = {name: Failing}
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002909 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002910 if has('channel')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002911 v9.CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002912 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00002913 v9.CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002914 endif
Bram Moolenaar11005b02021-07-11 20:59:00 +02002915
2916 lines =<< trim END
2917 vim9script
2918 var x = 99
2919 assert_equal({x: 99}, s:)
2920 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002921 v9.CheckScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002922enddef
2923
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002924def Test_expr8_dict_in_block()
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002925 var lines =<< trim END
2926 vim9script
2927 command MyCommand {
2928 echo {
2929 k: 0, }
2930 }
2931 MyCommand
Bram Moolenaar259f4432021-12-17 12:45:22 +00002932
2933 command YourCommand {
2934 g:global = {
2935 key: 'value' }
2936 }
2937 YourCommand
2938 assert_equal({key: 'value'}, g:global)
2939 unlet g:global
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002940 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002941 v9.CheckScriptSuccess(lines)
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002942
2943 delcommand MyCommand
Bram Moolenaar259f4432021-12-17 12:45:22 +00002944 delcommand YourCommand
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002945enddef
2946
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002947def Test_expr8_call_2bool()
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002948 var lines =<< trim END
2949 vim9script
2950
2951 def BrokenCall(nr: number, mode: bool, use: string): void
2952 assert_equal(3, nr)
2953 assert_equal(false, mode)
2954 assert_equal('ab', use)
2955 enddef
2956
2957 def TestBrokenCall(): void
2958 BrokenCall(3, 0, 'ab')
2959 enddef
2960
2961 TestBrokenCall()
2962 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002963 v9.CheckScriptSuccess(lines)
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002964enddef
2965
Bram Moolenaar50788ef2020-07-05 16:51:26 +02002966let g:oneString = 'one'
2967
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002968def Test_expr_member()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002969 var lines =<< trim END
2970 assert_equal(1, g:dict_one.one)
2971 var d: dict<number> = g:dict_one
2972 assert_equal(1, d['one'])
2973 assert_equal(1, d[
2974 'one'
2975 ])
2976 assert_equal(1, d
2977 .one)
2978 d = {1: 1, _: 2}
2979 assert_equal(1, d
2980 .1)
2981 assert_equal(2, d
2982 ._)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002983
Bram Moolenaar90193e62021-04-04 20:49:50 +02002984 # getting the one member should clear the dict after getting the item
2985 assert_equal('one', {one: 'one'}.one)
2986 assert_equal('one', {one: 'one'}[g:oneString])
2987 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002988 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002989
Bram Moolenaar62aec932022-01-29 21:45:34 +00002990 v9.CheckDefAndScriptFailure(["var x = g:dict_one.#$!"], ['E1002:', 'E15:'], 1)
2991 v9.CheckDefExecAndScriptFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2992 v9.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 +02002993enddef
2994
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002995def Test_expr8_any_index_slice()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002996 var lines =<< trim END
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002997 # getting the one member should clear the list only after getting the item
2998 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
2999
3000 # string is permissive, index out of range accepted
3001 g:teststring = 'abcdef'
3002 assert_equal('b', g:teststring[1])
Bram Moolenaare7525c52021-01-09 13:20:37 +01003003 assert_equal('f', g:teststring[-1])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003004 assert_equal('', g:teststring[99])
3005
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003006 assert_equal('b', g:teststring[1 : 1])
3007 assert_equal('bcdef', g:teststring[1 :])
3008 assert_equal('abcd', g:teststring[: 3])
3009 assert_equal('cdef', g:teststring[-4 :])
3010 assert_equal('abcdef', g:teststring[-9 :])
3011 assert_equal('abcd', g:teststring[: -3])
3012 assert_equal('', g:teststring[: -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003013
Bram Moolenaar0289a092021-03-14 18:40:19 +01003014 # composing characters are included
3015 g:teststring = 'àéû'
3016 assert_equal('à', g:teststring[0])
3017 assert_equal('é', g:teststring[1])
3018 assert_equal('û', g:teststring[2])
3019 assert_equal('', g:teststring[3])
3020 assert_equal('', g:teststring[4])
3021
3022 assert_equal('û', g:teststring[-1])
3023 assert_equal('é', g:teststring[-2])
3024 assert_equal('à', g:teststring[-3])
3025 assert_equal('', g:teststring[-4])
3026 assert_equal('', g:teststring[-5])
3027
3028 assert_equal('à', g:teststring[0 : 0])
3029 assert_equal('é', g:teststring[1 : 1])
3030 assert_equal('àé', g:teststring[0 : 1])
3031 assert_equal('àéû', g:teststring[0 : -1])
3032 assert_equal('àé', g:teststring[0 : -2])
3033 assert_equal('à', g:teststring[0 : -3])
3034 assert_equal('', g:teststring[0 : -4])
3035 assert_equal('', g:teststring[0 : -5])
3036 assert_equal('àéû', g:teststring[ : ])
3037 assert_equal('àéû', g:teststring[0 : ])
3038 assert_equal('éû', g:teststring[1 : ])
3039 assert_equal('û', g:teststring[2 : ])
3040 assert_equal('', g:teststring[3 : ])
3041 assert_equal('', g:teststring[4 : ])
3042
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003043 # blob index cannot be out of range
3044 g:testblob = 0z01ab
3045 assert_equal(0x01, g:testblob[0])
3046 assert_equal(0xab, g:testblob[1])
3047 assert_equal(0xab, g:testblob[-1])
3048 assert_equal(0x01, g:testblob[-2])
3049
3050 # blob slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003051 assert_equal(0z01ab, g:testblob[0 : 1])
3052 assert_equal(0z01, g:testblob[0 : 0])
3053 assert_equal(0z01, g:testblob[-2 : -2])
3054 assert_equal(0zab, g:testblob[1 : 1])
3055 assert_equal(0zab, g:testblob[-1 : -1])
3056 assert_equal(0z, g:testblob[2 : 2])
3057 assert_equal(0z, g:testblob[0 : -3])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003058
3059 # list index cannot be out of range
3060 g:testlist = [0, 1, 2, 3]
3061 assert_equal(0, g:testlist[0])
3062 assert_equal(1, g:testlist[1])
3063 assert_equal(3, g:testlist[3])
3064 assert_equal(3, g:testlist[-1])
3065 assert_equal(0, g:testlist[-4])
3066 assert_equal(1, g:testlist[g:theone])
3067
3068 # list slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003069 assert_equal([0], g:testlist[0 : 0])
3070 assert_equal([3], g:testlist[3 : 3])
3071 assert_equal([0, 1], g:testlist[0 : 1])
3072 assert_equal([0, 1, 2, 3], g:testlist[0 : 3])
3073 assert_equal([0, 1, 2, 3], g:testlist[0 : 9])
3074 assert_equal([], g:testlist[-1 : 1])
3075 assert_equal([1], g:testlist[-3 : 1])
3076 assert_equal([0, 1], g:testlist[-4 : 1])
3077 assert_equal([0, 1], g:testlist[-9 : 1])
3078 assert_equal([1, 2, 3], g:testlist[1 : -1])
3079 assert_equal([1], g:testlist[1 : -3])
3080 assert_equal([], g:testlist[1 : -4])
3081 assert_equal([], g:testlist[1 : -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003082
Bram Moolenaare0de1712020-12-02 17:36:54 +01003083 g:testdict = {a: 1, b: 2}
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003084 assert_equal(1, g:testdict['a'])
3085 assert_equal(2, g:testdict['b'])
3086 END
3087
Bram Moolenaar62aec932022-01-29 21:45:34 +00003088 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003089
Bram Moolenaar1983f1a2022-02-28 20:55:02 +00003090 lines =<< trim END
3091 vim9script
3092
3093 def PosIdx(s: string): string
3094 return s[1]
3095 enddef
3096 def NegIdx(s: string): string
3097 return s[-1]
3098 enddef
3099
3100 set enc=latin1
3101 assert_equal("\xe4", PosIdx("a\xe4\xe5"))
3102 assert_equal("\xe5", NegIdx("a\xe4\xe5"))
3103 set enc=utf-8
3104 END
3105 v9.CheckScriptSuccess(lines)
3106
Bram Moolenaar62aec932022-01-29 21:45:34 +00003107 v9.CheckDefExecAndScriptFailure(['echo g:testblob[2]'], 'E979:', 1)
3108 v9.CheckDefExecAndScriptFailure(['echo g:testblob[-3]'], 'E979:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003109
Bram Moolenaar62aec932022-01-29 21:45:34 +00003110 v9.CheckDefExecAndScriptFailure(['echo g:testlist[4]'], 'E684: list index out of range: 4', 1)
3111 v9.CheckDefExecAndScriptFailure(['echo g:testlist[-5]'], 'E684:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003112
Bram Moolenaar62aec932022-01-29 21:45:34 +00003113 v9.CheckDefExecAndScriptFailure(['echo g:testdict["a" : "b"]'], 'E719:', 1)
3114 v9.CheckDefExecAndScriptFailure(['echo g:testdict[1]'], 'E716:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02003115
3116 unlet g:teststring
3117 unlet g:testblob
3118 unlet g:testlist
Bram Moolenaar435d8972020-07-05 16:42:13 +02003119enddef
3120
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003121def Test_expr_member_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003122 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01003123 var d = {one:
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003124 'one',
Bram Moolenaarb13ab992020-07-27 21:43:28 +02003125 two: 'two',
3126 1: 1,
3127 _: 2}
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003128 assert_equal('one', d.one)
3129 assert_equal('one', d
3130 .one)
Bram Moolenaarb13ab992020-07-27 21:43:28 +02003131 assert_equal(1, d
3132 .1)
3133 assert_equal(2, d
3134 ._)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003135 assert_equal('one', d[
3136 'one'
3137 ])
3138 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003139 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003140
3141 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003142 var l = [1,
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003143 2,
3144 3, 4
3145 ]
3146 assert_equal(2, l[
3147 1
3148 ])
3149 assert_equal([2, 3], l[1 : 2])
3150 assert_equal([1, 2, 3], l[
3151 :
3152 2
3153 ])
3154 assert_equal([3, 4], l[
3155 2
3156 :
3157 ])
3158 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003159 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02003160enddef
3161
Bram Moolenaara79925a2021-01-05 17:50:28 +01003162def SetSomeVar()
3163 b:someVar = &fdm
3164enddef
3165
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003166def Test_expr8_option()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003167 var lines =<< trim END
3168 # option
3169 set ts=11
3170 assert_equal(11, &ts)
3171 &ts = 9
3172 assert_equal(9, &ts)
3173 set ts=8
3174 set grepprg=some\ text
3175 assert_equal('some text', &grepprg)
3176 &grepprg = test_null_string()
3177 assert_equal('', &grepprg)
3178 set grepprg&
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01003179
Bram Moolenaar90193e62021-04-04 20:49:50 +02003180 # check matching type
3181 var bval: bool = &tgc
3182 var nval: number = &ts
3183 var sval: string = &path
Bram Moolenaara79925a2021-01-05 17:50:28 +01003184
Bram Moolenaar90193e62021-04-04 20:49:50 +02003185 # check v_lock is cleared (requires using valgrind, doesn't always show)
Bram Moolenaar62aec932022-01-29 21:45:34 +00003186 g:SetSomeVar()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003187 b:someVar = 0
3188 unlet b:someVar
3189 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003190 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003191enddef
3192
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003193def Test_expr8_environment()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003194 var lines =<< trim END
3195 # environment variable
3196 assert_equal('testvar', $TESTVAR)
3197 assert_equal('', $ASDF_ASD_XXX)
3198 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003199 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc58164c2020-03-29 18:40:30 +02003200
Bram Moolenaar62aec932022-01-29 21:45:34 +00003201 v9.CheckDefAndScriptFailure(["var x = $$$"], ['E1002:', 'E15:'], 1)
3202 v9.CheckDefAndScriptFailure(["$"], ['E1002:', 'E15:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003203enddef
3204
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003205def Test_expr8_register()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003206 var lines =<< trim END
3207 @a = 'register a'
3208 assert_equal('register a', @a)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02003209
Bram Moolenaar90193e62021-04-04 20:49:50 +02003210 var fname = expand('%')
3211 assert_equal(fname, @%)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02003212
Bram Moolenaar90193e62021-04-04 20:49:50 +02003213 feedkeys(":echo 'some'\<CR>", "xt")
3214 assert_equal("echo 'some'", @:)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02003215
Bram Moolenaar90193e62021-04-04 20:49:50 +02003216 normal axyz
3217 assert_equal("xyz", @.)
Bram Moolenaar65821722020-08-02 18:58:54 +02003218
Bram Moolenaar90193e62021-04-04 20:49:50 +02003219 @/ = 'slash'
3220 assert_equal('slash', @/)
Bram Moolenaar65821722020-08-02 18:58:54 +02003221
Bram Moolenaar90193e62021-04-04 20:49:50 +02003222 @= = 'equal'
3223 assert_equal('equal', @=)
3224 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003225 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003226
Bram Moolenaar62aec932022-01-29 21:45:34 +00003227 v9.CheckDefAndScriptFailure(["@. = 'yes'"], ['E354:', 'E488:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003228enddef
3229
Bram Moolenaar886e5e72021-04-05 13:36:34 +02003230" This is slow when run under valgrind.
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003231def Test_expr8_namespace()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003232 var lines =<< trim END
3233 g:some_var = 'some'
3234 assert_equal('some', get(g:, 'some_var'))
3235 assert_equal('some', get(g:, 'some_var', 'xxx'))
3236 assert_equal('xxx', get(g:, 'no_var', 'xxx'))
3237 unlet g:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003238
Bram Moolenaar90193e62021-04-04 20:49:50 +02003239 b:some_var = 'some'
3240 assert_equal('some', get(b:, 'some_var'))
3241 assert_equal('some', get(b:, 'some_var', 'xxx'))
3242 assert_equal('xxx', get(b:, 'no_var', 'xxx'))
3243 unlet b:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003244
Bram Moolenaar90193e62021-04-04 20:49:50 +02003245 w:some_var = 'some'
3246 assert_equal('some', get(w:, 'some_var'))
3247 assert_equal('some', get(w:, 'some_var', 'xxx'))
3248 assert_equal('xxx', get(w:, 'no_var', 'xxx'))
3249 unlet w:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003250
Bram Moolenaar90193e62021-04-04 20:49:50 +02003251 t:some_var = 'some'
3252 assert_equal('some', get(t:, 'some_var'))
3253 assert_equal('some', get(t:, 'some_var', 'xxx'))
3254 assert_equal('xxx', get(t:, 'no_var', 'xxx'))
3255 unlet t:some_var
Bram Moolenaar90193e62021-04-04 20:49:50 +02003256 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003257 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02003258enddef
3259
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003260def Test_expr8_namespace_loop_def()
Bram Moolenaardae453f2021-08-07 17:20:16 +02003261 var lines =<< trim END
3262 # check using g: in a for loop more than DO_NOT_FREE_CNT times
3263 var exists = 0
3264 var exists_not = 0
3265 for i in range(100000)
3266 if has_key(g:, 'does-not-exist')
3267 exists += 1
3268 else
3269 exists_not += 1
3270 endif
3271 endfor
3272 assert_equal(0, exists)
3273 assert_equal(100000, exists_not)
3274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003275 v9.CheckDefSuccess(lines)
Bram Moolenaardae453f2021-08-07 17:20:16 +02003276enddef
3277
3278" NOTE: this is known to be slow. To skip use:
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003279" :let $TEST_SKIP_PAT = 'Test_expr8_namespace_loop_script'
3280def Test_expr8_namespace_loop_script()
Bram Moolenaardae453f2021-08-07 17:20:16 +02003281 var lines =<< trim END
3282 vim9script
3283 # check using g: in a for loop more than DO_NOT_FREE_CNT times
3284 var exists = 0
3285 var exists_not = 0
3286 for i in range(100000)
3287 if has_key(g:, 'does-not-exist')
3288 exists += 1
3289 else
3290 exists_not += 1
3291 endif
3292 endfor
3293 assert_equal(0, exists)
3294 assert_equal(100000, exists_not)
3295 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003296 v9.CheckScriptSuccess(lines)
Bram Moolenaardae453f2021-08-07 17:20:16 +02003297enddef
3298
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003299def Test_expr8_parens()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02003300 # (expr)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003301 var lines =<< trim END
Bram Moolenaar24156692021-01-14 20:35:49 +01003302 assert_equal(4, (6 * 4) / 6)
3303 assert_equal(0, 6 * ( 4 / 6 ))
3304
3305 assert_equal(6, +6)
3306 assert_equal(-6, -6)
3307 assert_equal(false, !-3)
3308 assert_equal(true, !+0)
3309
3310 assert_equal(7, 5 + (
3311 2))
3312 assert_equal(7, 5 + (
3313 2
3314 ))
3315 assert_equal(7, 5 + ( # comment
3316 2))
3317 assert_equal(7, 5 + ( # comment
3318 # comment
3319 2))
3320
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003321 var s = (
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02003322 'one'
3323 ..
3324 'two'
3325 )
3326 assert_equal('onetwo', s)
3327 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003328 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02003329enddef
3330
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003331def Test_expr8_negate_add()
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003332 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003333 assert_equal(-99, -99)
3334 assert_equal(-99, - 99)
3335 assert_equal(99, +99)
3336
3337 var nr = 88
3338 assert_equal(-88, -nr)
3339 assert_equal(-88, - nr)
3340 assert_equal(88, + nr)
3341 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003342 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003343
3344 lines =<< trim END
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003345 var n = 12
3346 echo ++n
3347 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003348 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003349 lines =<< trim END
3350 var n = 12
3351 echo --n
3352 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003353 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003354 lines =<< trim END
3355 var n = 12
3356 echo +-n
3357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003358 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003359 lines =<< trim END
3360 var n = 12
3361 echo -+n
3362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003363 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003364 lines =<< trim END
3365 var n = 12
3366 echo - -n
3367 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003368 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003369 lines =<< trim END
3370 var n = 12
3371 echo + +n
3372 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003373 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003374enddef
3375
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003376def LegacyReturn(): string
3377 legacy return #{key: 'ok'}.key
3378enddef
3379
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003380def Test_expr8_legacy_script()
Bram Moolenaar15e5e532021-04-07 21:21:13 +02003381 var lines =<< trim END
3382 let s:legacy = 'legacy'
3383 def GetLocal(): string
3384 return legacy
3385 enddef
3386 def GetLocalPrefix(): string
3387 return s:legacy
3388 enddef
3389 call assert_equal('legacy', GetLocal())
3390 call assert_equal('legacy', GetLocalPrefix())
3391 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003392 v9.CheckScriptSuccess(lines)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003393
Bram Moolenaar62aec932022-01-29 21:45:34 +00003394 assert_equal('ok', g:LegacyReturn())
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003395
3396 lines =<< trim END
3397 vim9script
3398 def GetNumber(): number
3399 legacy return range(3)->map('v:val + 1')
3400 enddef
3401 echo GetNumber()
3402 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003403 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<number>')
Bram Moolenaar15e5e532021-04-07 21:21:13 +02003404enddef
3405
Bram Moolenaar6e949782020-04-13 17:21:00 +02003406def Echo(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003407 return arg
3408enddef
3409
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02003410def s:Echo4Arg(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003411 return arg
3412enddef
3413
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003414def Test_expr8_call()
Bram Moolenaar659bb222020-11-12 20:16:39 +01003415 var lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003416 assert_equal('yes', 'yes'->g:Echo())
Bram Moolenaar659bb222020-11-12 20:16:39 +01003417 assert_equal(true, !range(5)->empty())
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003418 assert_equal([0, 1, 2], 3->range())
Bram Moolenaar659bb222020-11-12 20:16:39 +01003419 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003420 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar659bb222020-11-12 20:16:39 +01003421
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003422 assert_equal('yes', 'yes'
Bram Moolenaar659bb222020-11-12 20:16:39 +01003423 ->s:Echo4Arg())
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003424
Bram Moolenaar62aec932022-01-29 21:45:34 +00003425 v9.CheckDefAndScriptFailure(["var x = 'yes'->g:Echo"], 'E107:', 1)
3426 v9.CheckDefAndScriptFailure([
Bram Moolenaar90193e62021-04-04 20:49:50 +02003427 "var x = substitute ('x', 'x', 'x', 'x')"
Bram Moolenaar86b3ab42021-12-19 18:33:23 +00003428 ], ['E1001:', 'E121:'], 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00003429 v9.CheckDefAndScriptFailure(["var Ref = function('len' [1, 2])"], ['E1123:', 'E116:'], 1)
3430enddef
Bram Moolenaara1773442020-08-12 15:21:22 +02003431
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003432def g:ExistingGlobal(): string
Bram Moolenaar62aec932022-01-29 21:45:34 +00003433 return 'existing'
3434enddef
3435
3436def Test_expr8_call_global()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003437 assert_equal('existing', g:ExistingGlobal())
Bram Moolenaar62aec932022-01-29 21:45:34 +00003438
3439 def g:DefinedLater(): string
3440 return 'later'
3441 enddef
3442 assert_equal('later', g:DefinedLater())
3443
3444 var lines =<< trim END
3445 echo ExistingGlobal()
3446 END
3447 v9.CheckDefAndScriptFailure(lines, 'E117: Unknown function: ExistingGlobal')
3448enddef
3449
Bram Moolenaar397a87a2022-03-20 21:14:15 +00003450def Test_expr8_autoload_var()
3451 var auto_lines =<< trim END
3452 let autofile#var = 'found'
3453 END
3454 mkdir('Xruntime/autoload', 'p')
3455 writefile(auto_lines, 'Xruntime/autoload/autofile.vim')
3456 var save_rtp = &rtp
3457 &rtp = getcwd() .. '/Xruntime,' .. &rtp
3458
3459 var lines =<< trim END
3460 assert_equal('found', autofile#var)
3461 END
3462 v9.CheckDefAndScriptSuccess(lines)
3463
3464 lines =<< trim END
3465 echo autofile#other
3466 END
3467 v9.CheckDefExecAndScriptFailure(lines, 'E121: Undefined variable: autofile#other')
3468
3469 &rtp = save_rtp
3470 delete('Xruntime', 'rf')
3471enddef
3472
Bram Moolenaar62aec932022-01-29 21:45:34 +00003473def Test_expr8_call_autoload()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003474 var auto_lines =<< trim END
Bram Moolenaara1773442020-08-12 15:21:22 +02003475 def g:some#func(): string
3476 return 'found'
3477 enddef
3478 END
3479 mkdir('Xruntime/autoload', 'p')
3480 writefile(auto_lines, 'Xruntime/autoload/some.vim')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003481 var save_rtp = &rtp
Bram Moolenaara1773442020-08-12 15:21:22 +02003482 &rtp = getcwd() .. '/Xruntime,' .. &rtp
3483 assert_equal('found', g:some#func())
3484 assert_equal('found', some#func())
3485
3486 &rtp = save_rtp
3487 delete('Xruntime', 'rf')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003488enddef
3489
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003490def Test_expr8_method_call()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003491 var lines =<< trim END
3492 new
3493 setline(1, ['first', 'last'])
3494 'second'->append(1)
3495 "third"->append(2)
3496 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
3497 bwipe!
Bram Moolenaar7e368202020-12-25 21:56:57 +01003498
Bram Moolenaar90193e62021-04-04 20:49:50 +02003499 var bufnr = bufnr()
3500 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
3501 loclist->setloclist(0)
3502 assert_equal([{bufnr: bufnr,
3503 lnum: 42,
thinca6864efa2021-06-19 20:45:20 +02003504 end_lnum: 0,
Bram Moolenaar90193e62021-04-04 20:49:50 +02003505 col: 17,
thinca6864efa2021-06-19 20:45:20 +02003506 end_col: 0,
Bram Moolenaar90193e62021-04-04 20:49:50 +02003507 text: 'wrong',
3508 pattern: '',
3509 valid: 1,
3510 vcol: 0,
3511 nr: 0,
3512 type: '',
3513 module: ''}
3514 ], getloclist(0))
Bram Moolenaar7e368202020-12-25 21:56:57 +01003515
Bram Moolenaar90193e62021-04-04 20:49:50 +02003516 var result: bool = get({n: 0}, 'n', 0)
3517 assert_equal(false, result)
Bram Moolenaar7e368202020-12-25 21:56:57 +01003518
Bram Moolenaar90193e62021-04-04 20:49:50 +02003519 assert_equal('+string+', 'string'->((s) => '+' .. s .. '+')())
3520 assert_equal('-text-', 'text'->((s, c) => c .. s .. c)('-'))
Bram Moolenaar7e368202020-12-25 21:56:57 +01003521
Bram Moolenaar90193e62021-04-04 20:49:50 +02003522 var Join = (l) => join(l, 'x')
3523 assert_equal('axb', ['a', 'b']->(Join)())
Bram Moolenaara7330422021-06-08 20:46:45 +02003524
3525 var sorted = [3, 1, 2]
3526 -> sort()
3527 assert_equal([1, 2, 3], sorted)
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003528 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003529 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003530
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003531 lines =<< trim END
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003532 def SetNumber(n: number)
3533 g:number = n
3534 enddef
3535 const Setit = SetNumber
3536 len('text')->Setit()
3537 assert_equal(4, g:number)
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003538
3539 const SetFuncref = funcref(SetNumber)
3540 len('longer')->SetFuncref()
3541 assert_equal(6, g:number)
3542
3543 const SetList = [SetNumber, SetFuncref]
3544 len('xx')->SetList[0]()
3545 assert_equal(2, g:number)
3546 len('xxx')->SetList[1]()
3547 assert_equal(3, g:number)
3548
3549 const SetDict = {key: SetNumber}
3550 len('xxxx')->SetDict['key']()
3551 assert_equal(4, g:number)
3552 len('xxxxx')->SetDict.key()
3553 assert_equal(5, g:number)
3554
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003555 unlet g:number
Bram Moolenaar90193e62021-04-04 20:49:50 +02003556 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003557 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003558
3559 lines =<< trim END
3560 def RetVoid()
3561 enddef
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003562 RetVoid()->byteidx(3)
3563 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003564 v9.CheckDefExecFailure(lines, 'E1013:')
Bram Moolenaar7e368202020-12-25 21:56:57 +01003565enddef
3566
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003567def Test_expr8_method_call_linebreak()
Bram Moolenaar5e6b9882022-01-10 18:50:52 +00003568 # this was giving an error when skipping over the expression
3569 var lines =<< trim END
3570 vim9script
3571 def Test()
3572 var a: dict<any> = {b: {}}
3573 a.b->extend({f1: 1,
3574 f2: 2})
3575 echo a
3576 enddef
3577 defcompile
3578 assert_equal('', v:errmsg)
3579 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003580 v9.CheckScriptSuccess(lines)
Bram Moolenaar5e6b9882022-01-10 18:50:52 +00003581enddef
3582
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003583def Test_expr8_method_call_import()
3584 var lines =<< trim END
3585 vim9script
3586 export def Square(items: list<number>): list<number>
3587 return map(items, (_, i) => i * i)
3588 enddef
3589 END
3590 call writefile(lines, 'Xsquare.vim')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003591
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003592 lines =<< trim END
3593 vim9script
3594 import './Xsquare.vim'
3595
3596 def Test(): list<number>
3597 return range(5)
3598 ->Xsquare.Square()
3599 ->map((_, i) => i * 10)
3600 enddef
3601
3602 assert_equal([0, 10, 40, 90, 160], Test())
3603 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003604 v9.CheckScriptSuccess(lines)
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003605
Bram Moolenaar64283d52022-01-18 10:37:29 +00003606 lines =<< trim END
3607 vim9script
3608 import './Xsquare.vim'
3609
3610 echo range(5)->Xsquare.NoSuchFunc()
3611 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003612 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: NoSuchFunc')
Bram Moolenaar64283d52022-01-18 10:37:29 +00003613
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003614 delete('Xsquare.vim')
3615enddef
3616
3617
3618def Test_expr8_not()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003619 var lines =<< trim END
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003620 assert_equal(true, !'')
3621 assert_equal(true, ![])
3622 assert_equal(false, !'asdf')
3623 assert_equal(false, ![2])
3624 assert_equal(true, !!'asdf')
3625 assert_equal(true, !![2])
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003626
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003627 assert_equal(true, ! false)
3628 assert_equal(true, !! true)
3629 assert_equal(true, ! ! true)
3630 assert_equal(true, !!! false)
3631 assert_equal(true, ! ! ! false)
3632
3633 g:true = true
3634 g:false = false
3635 assert_equal(true, ! g:false)
3636 assert_equal(true, !! g:true)
3637 assert_equal(true, ! ! g:true)
3638 assert_equal(true, !!! g:false)
3639 assert_equal(true, ! ! ! g:false)
3640 unlet g:true
3641 unlet g:false
3642
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003643 assert_equal(true, !test_null_partial())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003644 assert_equal(false, !() => 'yes')
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003645
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003646 assert_equal(true, !test_null_dict())
3647 assert_equal(true, !{})
Bram Moolenaare0de1712020-12-02 17:36:54 +01003648 assert_equal(false, !{yes: 'no'})
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003649
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003650 if has('channel')
3651 assert_equal(true, !test_null_job())
3652 assert_equal(true, !test_null_channel())
3653 endif
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003654
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003655 assert_equal(true, !test_null_blob())
3656 assert_equal(true, !0z)
3657 assert_equal(false, !0z01)
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003658
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003659 assert_equal(true, !test_void())
3660 assert_equal(true, !test_unknown())
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003661
3662 assert_equal(false, ![1, 2, 3]->reverse())
3663 assert_equal(true, ![]->reverse())
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003664 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003665 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003666enddef
3667
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003668let g:anumber = 42
3669
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003670def Test_expr8_negate()
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003671 var lines =<< trim END
3672 var nr = 1
3673 assert_equal(-1, -nr)
3674 assert_equal(-42, -g:anumber)
3675 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003676 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003677enddef
3678
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003679func Test_expr8_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003680 call v9.CheckDefFailure(["var x = (12"], "E1097:", 3)
3681 call v9.CheckScriptFailure(['vim9script', "var x = (12"], 'E110:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003682
Bram Moolenaar62aec932022-01-29 21:45:34 +00003683 call v9.CheckDefAndScriptFailure(["var x = -'xx'"], "E1030:", 1)
3684 call v9.CheckDefAndScriptFailure(["var x = +'xx'"], "E1030:", 1)
3685 call v9.CheckDefAndScriptFailure(["var x = -0z12"], "E974:", 1)
3686 call v9.CheckDefExecAndScriptFailure(["var x = -[8]"], ["E1012:", 'E745:'], 1)
3687 call v9.CheckDefExecAndScriptFailure(["var x = -{a: 1}"], ["E1012:", 'E728:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003688
Bram Moolenaar62aec932022-01-29 21:45:34 +00003689 call v9.CheckDefAndScriptFailure(["var x = @"], "E1002:", 1)
3690 call v9.CheckDefAndScriptFailure(["var x = @<"], "E354:", 1)
Bram Moolenaar58ceca52020-01-28 22:46:22 +01003691
Bram Moolenaar62aec932022-01-29 21:45:34 +00003692 call v9.CheckDefFailure(["var x = [1, 2"], "E697:", 2)
3693 call v9.CheckScriptFailure(['vim9script', "var x = [1, 2"], 'E696:', 2)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003694
Bram Moolenaar62aec932022-01-29 21:45:34 +00003695 call v9.CheckDefAndScriptFailure(["var x = [notfound]"], ["E1001:", 'E121:'], 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003696
Bram Moolenaar62aec932022-01-29 21:45:34 +00003697 call v9.CheckDefAndScriptFailure(["var X = () => 123)"], 'E488:', 1)
3698 call v9.CheckDefAndScriptFailure(["var x = 123->((x) => x + 5)"], "E107:", 1)
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01003699
Bram Moolenaar62aec932022-01-29 21:45:34 +00003700 call v9.CheckDefAndScriptFailure(["var x = &notexist"], 'E113:', 1)
3701 call v9.CheckDefAndScriptFailure(["&grepprg = [343]"], ['E1012:', 'E730:'], 1)
Bram Moolenaar09f28f42020-02-20 23:08:34 +01003702
Bram Moolenaara749a422022-02-12 19:52:25 +00003703 call v9.CheckDefExecAndScriptFailure(["echo s:doesnt_exist"], ['E121:', 'E1268:'], 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00003704 call v9.CheckDefExecAndScriptFailure(["echo g:doesnt_exist"], 'E121:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003705
Bram Moolenaar62aec932022-01-29 21:45:34 +00003706 call v9.CheckDefAndScriptFailure(["echo a:somevar"], ['E1075:', 'E121:'], 1)
3707 call v9.CheckDefAndScriptFailure(["echo l:somevar"], ['E1075:', 'E121:'], 1)
3708 call v9.CheckDefAndScriptFailure(["echo x:somevar"], ['E1075:', 'E121:'], 1)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01003709
Bram Moolenaar62aec932022-01-29 21:45:34 +00003710 call v9.CheckDefExecAndScriptFailure(["var x = +g:astring"], ['E1012:', 'E1030:'], 1)
3711 call v9.CheckDefExecAndScriptFailure(["var x = +g:ablob"], ['E1012:', 'E974:'], 1)
3712 call v9.CheckDefExecAndScriptFailure(["var x = +g:alist"], ['E1012:', 'E745:'], 1)
3713 call v9.CheckDefExecAndScriptFailure(["var x = +g:adict"], ['E1012:', 'E728:'], 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003714
Bram Moolenaar62aec932022-01-29 21:45:34 +00003715 call v9.CheckDefAndScriptFailure(["var x = ''", "var y = x.memb"], ['E1229: Expected dictionary for using key "memb", but got string', 'E488:'], 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003716
Bram Moolenaar62aec932022-01-29 21:45:34 +00003717 call v9.CheckDefAndScriptFailure(["'yes'->", "Echo()"], ['E488: Trailing characters: ->', 'E260: Missing name after ->'], 1)
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003718
Bram Moolenaar62aec932022-01-29 21:45:34 +00003719 call v9.CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
3720 call v9.CheckScriptFailure(['vim9script', "[1, 2->len()"], 'E696:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003721
Bram Moolenaar62aec932022-01-29 21:45:34 +00003722 call v9.CheckDefFailure(["{a: 1->len()"], 'E723:', 2)
3723 call v9.CheckScriptFailure(['vim9script', "{a: 1->len()"], 'E722:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003724
Bram Moolenaar62aec932022-01-29 21:45:34 +00003725 call v9.CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
3726 call v9.CheckScriptFailure(['vim9script', "{['a']: 1->len()"], 'E722:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003727endfunc
3728
3729let g:Funcrefs = [function('add')]
3730
3731func CallMe(arg)
3732 return a:arg
3733endfunc
3734
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003735func CallMe2(one, two)
3736 return a:one .. a:two
3737endfunc
3738
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003739def Test_expr8_trailing()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003740 var lines =<< trim END
3741 # user function call
3742 assert_equal(123, g:CallMe(123))
3743 assert_equal(123, g:CallMe( 123))
3744 assert_equal(123, g:CallMe(123 ))
3745 assert_equal('yesno', g:CallMe2('yes', 'no'))
3746 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
3747 assert_equal('nothing', g:CallMe('nothing'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003748
Bram Moolenaar90193e62021-04-04 20:49:50 +02003749 # partial call
3750 var Part = function('g:CallMe')
3751 assert_equal('yes', Part('yes'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003752
Bram Moolenaar90193e62021-04-04 20:49:50 +02003753 # funcref call, using list index
3754 var l = []
3755 g:Funcrefs[0](l, 2)
3756 assert_equal([2], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003757
Bram Moolenaar90193e62021-04-04 20:49:50 +02003758 # method call
3759 l = [2, 5, 6]
3760 l->map((k, v) => k + v)
3761 assert_equal([2, 6, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003762
Bram Moolenaar90193e62021-04-04 20:49:50 +02003763 # lambda method call
3764 l = [2, 5]
3765 l->((ll) => add(ll, 8))()
3766 assert_equal([2, 5, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003767
Bram Moolenaar90193e62021-04-04 20:49:50 +02003768 # dict member
3769 var d = {key: 123}
3770 assert_equal(123, d.key)
3771 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003772 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003773enddef
3774
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003775def Test_expr8_string_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003776 var lines =<< trim END
3777 var text = 'abcdef'
Bram Moolenaare7525c52021-01-09 13:20:37 +01003778 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003779 assert_equal('a', text[0])
3780 assert_equal('e', text[4])
3781 assert_equal('f', text[5])
3782 assert_equal('', text[6])
3783
Bram Moolenaare7525c52021-01-09 13:20:37 +01003784 text = 'ábçdë'
3785 assert_equal('ë', text[-1])
3786 assert_equal('d', text[-2])
3787 assert_equal('ç', text[-3])
3788 assert_equal('b', text[-4])
3789 assert_equal('á', text[-5])
3790 assert_equal('', text[-6])
3791
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003792 text = 'ábçdëf'
3793 assert_equal('', text[-999])
Bram Moolenaare7525c52021-01-09 13:20:37 +01003794 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003795 assert_equal('á', text[0])
3796 assert_equal('b', text[1])
3797 assert_equal('ç', text[2])
3798 assert_equal('d', text[3])
3799 assert_equal('ë', text[4])
3800 assert_equal('f', text[5])
3801 assert_equal('', text[6])
3802 assert_equal('', text[999])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003803
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003804 assert_equal('ábçdëf', text[0 : -1])
3805 assert_equal('ábçdëf', text[0 : -1])
3806 assert_equal('ábçdëf', text[0 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003807 assert_equal('ábçdëf', text[0 : -1])
3808 assert_equal('ábçdëf', text[0
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003809 : -1])
3810 assert_equal('ábçdëf', text[0 :
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003811 -1])
3812 assert_equal('ábçdëf', text[0 : -1
3813 ])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003814 assert_equal('bçdëf', text[1 : -1])
3815 assert_equal('çdëf', text[2 : -1])
3816 assert_equal('dëf', text[3 : -1])
3817 assert_equal('ëf', text[4 : -1])
3818 assert_equal('f', text[5 : -1])
3819 assert_equal('', text[6 : -1])
3820 assert_equal('', text[999 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003821
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003822 assert_equal('ábçd', text[: 3])
3823 assert_equal('bçdëf', text[1 :])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003824 assert_equal('ábçdëf', text[:])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003825
3826 assert_equal('a', g:astring[0])
3827 assert_equal('sd', g:astring[1 : 2])
3828 assert_equal('asdf', g:astring[:])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003829 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003830 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar918a4242020-12-06 14:37:08 +01003831
3832 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003833 var d = 'asdf'[1 :
Bram Moolenaar918a4242020-12-06 14:37:08 +01003834 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003835 v9.CheckDefFailure(lines, 'E1097:', 3)
3836 v9.CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003837
Bram Moolenaar918a4242020-12-06 14:37:08 +01003838 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003839 var d = 'asdf'[1 : xxx]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003840 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003841 v9.CheckDefAndScriptFailure(lines, ['E1001:', 'E121:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003842
Bram Moolenaar918a4242020-12-06 14:37:08 +01003843 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003844 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003845 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003846 v9.CheckDefFailure(lines, 'E1097:', 3)
3847 v9.CheckScriptFailure(['vim9script'] + lines, 'E111:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003848
Bram Moolenaar918a4242020-12-06 14:37:08 +01003849 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003850 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003851 echo d
3852 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003853 v9.CheckDefAndScriptFailure(lines, 'E111:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003854
Bram Moolenaar918a4242020-12-06 14:37:08 +01003855 lines =<< trim END
3856 var d = 'asdf'['1']
3857 echo d
3858 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003859 v9.CheckDefAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "1"'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003860
Bram Moolenaar918a4242020-12-06 14:37:08 +01003861 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003862 var d = 'asdf'['1' : 2]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003863 echo d
3864 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003865 v9.CheckDefAndScriptFailure(lines, ['E1012: Type mismatch; expected number but got string', 'E1030: Using a String as a Number: "1"'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003866
Bram Moolenaar918a4242020-12-06 14:37:08 +01003867 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003868 var d = 'asdf'[1 : '2']
Bram Moolenaar918a4242020-12-06 14:37:08 +01003869 echo d
3870 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003871 v9.CheckDefAndScriptFailure(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 +02003872enddef
3873
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003874def Test_expr8_list_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003875 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003876 var list = [0, 1, 2, 3, 4]
3877 assert_equal(0, list[0])
3878 assert_equal(4, list[4])
3879 assert_equal(4, list[-1])
3880 assert_equal(0, list[-5])
Bram Moolenaared591872020-08-15 22:14:53 +02003881
Bram Moolenaar90193e62021-04-04 20:49:50 +02003882 assert_equal([0, 1, 2, 3, 4], list[0 : 4])
3883 assert_equal([0, 1, 2, 3, 4], list[:])
3884 assert_equal([1, 2, 3, 4], list[1 :])
3885 assert_equal([2, 3, 4], list[2 : -1])
3886 assert_equal([4], list[4 : -1])
3887 assert_equal([], list[5 : -1])
3888 assert_equal([], list[999 : -1])
3889 assert_equal([1, 2, 3, 4], list[g:theone : g:thefour])
Bram Moolenaared591872020-08-15 22:14:53 +02003890
Bram Moolenaar90193e62021-04-04 20:49:50 +02003891 assert_equal([0, 1, 2, 3], list[0 : 3])
3892 assert_equal([0], list[0 : 0])
3893 assert_equal([0, 1, 2, 3, 4], list[0 : -1])
3894 assert_equal([0, 1, 2], list[0 : -3])
3895 assert_equal([0], list[0 : -5])
3896 assert_equal([], list[0 : -6])
3897 assert_equal([], list[0 : -99])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003898
3899 assert_equal(2, g:alist[0])
3900 assert_equal([2, 3, 4], g:alist[:])
Bram Moolenaared591872020-08-15 22:14:53 +02003901 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003902 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003903
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003904 lines = ['var l = [0, 1, 2]', 'echo l[g:astring : g:theone]']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003905 v9.CheckDefExecAndScriptFailure(lines, ['E1012:', 'E1030:'], 2)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003906
3907 lines =<< trim END
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003908 var ld = []
3909 def Func()
3910 eval ld[0].key
3911 enddef
3912 defcompile
3913 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003914 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaared591872020-08-15 22:14:53 +02003915enddef
3916
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003917def Test_expr8_dict_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003918 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01003919 var l = [{lnum: 2}, {lnum: 1}]
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003920 var res = l[0].lnum > l[1].lnum
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003921 assert_true(res)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003922
Bram Moolenaar261417b2021-05-06 21:04:55 +02003923 assert_equal(2, g:adict['aaa'])
3924 assert_equal(8, g:adict.bbb)
3925
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003926 var dd = {}
3927 def Func1()
3928 eval dd.key1.key2
3929 enddef
3930 def Func2()
3931 eval dd['key1'].key2
3932 enddef
3933 defcompile
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003934 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003935 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003936enddef
3937
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003938def Test_expr8_blob_subscript()
Bram Moolenaar261417b2021-05-06 21:04:55 +02003939 var lines =<< trim END
3940 var b = 0z112233
3941 assert_equal(0x11, b[0])
3942 assert_equal(0z112233, b[:])
3943
3944 assert_equal(0x01, g:ablob[0])
3945 assert_equal(0z01ab, g:ablob[:])
3946 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003947 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar261417b2021-05-06 21:04:55 +02003948enddef
3949
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003950def Test_expr8_subscript_linebreak()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003951 var lines =<< trim END
3952 var range = range(
3953 3)
3954 var l = range
3955 ->mapnew('string(v:key)')
3956 assert_equal(['0', '1', '2'], l)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003957
Bram Moolenaar90193e62021-04-04 20:49:50 +02003958 l = range
3959 ->mapnew('string(v:key)')
3960 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003961
Bram Moolenaar90193e62021-04-04 20:49:50 +02003962 l = range # comment
3963 ->mapnew('string(v:key)')
3964 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003965
Bram Moolenaar90193e62021-04-04 20:49:50 +02003966 l = range
Bram Moolenaar23c55272020-06-21 16:58:13 +02003967
Bram Moolenaar90193e62021-04-04 20:49:50 +02003968 ->mapnew('string(v:key)')
3969 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003970
Bram Moolenaar90193e62021-04-04 20:49:50 +02003971 l = range
3972 # comment
3973 ->mapnew('string(v:key)')
3974 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003975
Bram Moolenaar90193e62021-04-04 20:49:50 +02003976 assert_equal('1', l[
3977 1])
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003978
Bram Moolenaar90193e62021-04-04 20:49:50 +02003979 var d = {one: 33}
3980 assert_equal(33, d
3981 .one)
3982 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003983 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003984
3985 lines =<< trim END
3986 var d = {one: 33}
3987 assert_equal(33, d.
3988 one)
3989 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003990 v9.CheckDefAndScriptFailure(lines, ['E1127:', 'E116:'], 2)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003991enddef
3992
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003993func Test_expr8_trailing_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003994 call v9.CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8))'], 'E107:', 2)
3995 call v9.CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8)) ()'], 'E274:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003996endfunc
3997
3998func Test_expr_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003999 call v9.CheckDefAndScriptFailure(["var x = '1'is2"], 'E488:', 1)
4000 call v9.CheckDefAndScriptFailure(["var x = '1'isnot2"], 'E488:', 1)
Bram Moolenaar38a5f512020-02-19 12:40:39 +01004001
Bram Moolenaar62aec932022-01-29 21:45:34 +00004002 call v9.CheckDefAndScriptFailure(["CallMe ('yes')"], ['E476:', 'E492:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02004003
Bram Moolenaar62aec932022-01-29 21:45:34 +00004004 call v9.CheckDefAndScriptFailure(["CallMe2('yes','no')"], 'E1069:', 1)
Bram Moolenaar0c2ca582020-02-25 22:58:29 +01004005
Bram Moolenaar62aec932022-01-29 21:45:34 +00004006 call v9.CheckDefAndScriptFailure(["v:nosuch += 3"], ['E1001:', 'E121:'], 1)
4007 call v9.CheckDefAndScriptFailure(["var v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:', 1)
4008 call v9.CheckDefAndScriptFailure(["var asdf = v:nosuch"], ['E1001:', 'E121:'], 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01004009
Bram Moolenaar62aec932022-01-29 21:45:34 +00004010 call v9.CheckDefFailure(["echo len('asdf'"], 'E110:', 2)
4011 call v9.CheckScriptFailure(['vim9script', "echo len('asdf'"], 'E116:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02004012
Bram Moolenaara6c18d32022-03-31 20:02:56 +01004013 call v9.CheckDefAndScriptFailure(["echo Func01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], ['E1011:', 'E117:'], 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00004014 call v9.CheckDefAndScriptFailure(["echo doesnotexist()"], 'E117:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01004015endfunc
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02004016
4017" vim: shiftwidth=2 sts=2 expandtab