blob: 8399b69fa87ab580432e11b596ed5ec0dde91fec [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
Bram Moolenaar92f26c22020-10-03 20:17:30 +020015def Test_expr1_trinary()
Bram Moolenaar659bb222020-11-12 20:16:39 +010016 var lines =<< trim END
17 assert_equal('one', true ? 'one' : 'two')
18 assert_equal('one', 1 ?
19 'one' :
20 'two')
21 if has('float')
22 assert_equal('one', !!0.1 ? 'one' : 'two')
23 endif
24 assert_equal('one', !!'x' ? 'one' : 'two')
25 assert_equal('one', !!'x'
26 ? 'one'
27 : 'two')
28 assert_equal('one', !!0z1234 ? 'one' : 'two')
29 assert_equal('one', !![0] ? 'one' : 'two')
Bram Moolenaare0de1712020-12-02 17:36:54 +010030 assert_equal('one', !!{x: 0} ? 'one' : 'two')
Bram Moolenaar659bb222020-11-12 20:16:39 +010031 var name = 1
32 assert_equal('one', name ? 'one' : 'two')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +010033
Bram Moolenaar659bb222020-11-12 20:16:39 +010034 assert_equal('two', false ? 'one' : 'two')
35 assert_equal('two', 0 ? 'one' : 'two')
36 if has('float')
37 assert_equal('two', !!0.0 ? 'one' : 'two')
38 endif
39 assert_equal('two', !!'' ? 'one' : 'two')
40 assert_equal('two', !!0z ? 'one' : 'two')
41 assert_equal('two', !![] ? 'one' : 'two')
42 assert_equal('two', !!{} ? 'one' : 'two')
43 name = 0
44 assert_equal('two', name ? 'one' : 'two')
Bram Moolenaar939b5db2020-04-28 22:49:08 +020045
Bram Moolenaar5afd0812021-01-03 18:33:13 +010046 echo ['a'] + (1 ? ['b'] : ['c']
47 )
48 echo ['a'] + (1 ? ['b'] : ['c'] # comment
49 )
50
Bram Moolenaar659bb222020-11-12 20:16:39 +010051 # with constant condition expression is not evaluated
52 assert_equal('one', 1 ? 'one' : xxx)
Bram Moolenaar749639e2020-08-27 23:08:47 +020053
Bram Moolenaar659bb222020-11-12 20:16:39 +010054 var Some: func = function('len')
55 var Other: func = function('winnr')
56 var Res: func = g:atrue ? Some : Other
57 assert_equal(function('len'), Res)
Bram Moolenaar939b5db2020-04-28 22:49:08 +020058
Bram Moolenaar659bb222020-11-12 20:16:39 +010059 var RetOne: func(string): number = function('len')
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
Bram Moolenaar92f26c22020-10-03 20:17:30 +020077def Test_expr1_trinary_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
Bram Moolenaar92f26c22020-10-03 20:17:30 +0200173func Test_expr1_trinary_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
566" test == comperator
567def 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 Moolenaar0c357522021-07-18 14:43:43 +0200715def Test_expr4_wrong_type()
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100716 for op in ['>', '>=', '<', '<=', '=~', '!~']
Bram Moolenaar62aec932022-01-29 21:45:34 +0000717 v9.CheckDefExecAndScriptFailure([
Bram Moolenaarcff40ff2021-01-09 16:21:37 +0100718 "var a: any = 'a'",
719 'var b: any = true',
720 'echo a ' .. op .. ' b'], 'E1072:', 3)
721 endfor
Bram Moolenaar0c357522021-07-18 14:43:43 +0200722 for op in ['>', '>=', '<', '<=']
Bram Moolenaar62aec932022-01-29 21:45:34 +0000723 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200724 "var n: any = 2",
Bram Moolenaar86b3ab42021-12-19 18:33:23 +0000725 'echo n ' .. op .. ' "3"'], ['E1030:', 'E1072:'], 2)
Bram Moolenaar0c357522021-07-18 14:43:43 +0200726 endfor
727 for op in ['=~', '!~']
Bram Moolenaar62aec932022-01-29 21:45:34 +0000728 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200729 "var n: any = 2",
730 'echo n ' .. op .. ' "3"'], 'E1072:', 2)
731 endfor
732
Bram Moolenaar62aec932022-01-29 21:45:34 +0000733 v9.CheckDefAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200734 'echo v:none == true'], 'E1072:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000735 v9.CheckDefAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200736 'echo false >= true'], 'E1072:', 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000737 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200738 "var n: any = v:none",
739 'echo n == true'], 'E1072:', 2)
Bram Moolenaar62aec932022-01-29 21:45:34 +0000740 v9.CheckDefExecAndScriptFailure([
Bram Moolenaar0c357522021-07-18 14:43:43 +0200741 "var n: any = v:none",
742 'echo n < true'], 'E1072:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100743enddef
744
745" test != comperator
746def Test_expr4_notequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100747 var lines =<< trim END
748 var trueVar = true
749 var falseVar = false
750 assert_equal(false, true != true)
751 assert_equal(true, true !=
752 false)
753 assert_equal(false, true
754 != trueVar)
755 assert_equal(true, true != falseVar)
756 assert_equal(false, true != g:atrue)
757 assert_equal(true, g:atrue != false)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100758
Bram Moolenaar659bb222020-11-12 20:16:39 +0100759 assert_equal(false, v:none != v:none)
760 assert_equal(true, v:none != v:null)
761 assert_equal(false, g:anone != v:none)
762 assert_equal(true, v:none != g:anull)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100763
Bram Moolenaar659bb222020-11-12 20:16:39 +0100764 var nr55 = 55
765 var nr0 = 55
766 assert_equal(true, 2 != 0)
767 assert_equal(true, 2 != nr0)
768 assert_equal(false, 55 != 55)
769 assert_equal(false, 55 != nr55)
770 assert_equal(false, g:anint != 10)
771 assert_equal(true, 61 != g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100772
Bram Moolenaar659bb222020-11-12 20:16:39 +0100773 if has('float')
774 var ff = 0.3
775 assert_equal(false, 0.3 != ff)
776 assert_equal(true, 0.4 != ff)
777 assert_equal(false, 0.1 != g:afloat)
778 assert_equal(true, g:afloat != 0.3)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100779
Bram Moolenaar659bb222020-11-12 20:16:39 +0100780 ff = 3.0
781 assert_equal(false, ff != 3)
782 assert_equal(false, 3 != ff)
783 ff = 3.1
784 assert_equal(true, ff != 3)
785 assert_equal(true, 3 != ff)
786 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100787
Bram Moolenaar659bb222020-11-12 20:16:39 +0100788 assert_equal(false, 'abc' != 'abc')
789 assert_equal(true, 'xyz' != 'abc')
790 assert_equal(false, g:astring != 'asdf')
791 assert_equal(true, 'xyz' != g:astring)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100792
Bram Moolenaar659bb222020-11-12 20:16:39 +0100793 assert_equal(true, 'abc' != 'ABC')
794 set ignorecase
795 assert_equal(true, 'abc' != 'ABC')
796 assert_equal(true, 'abc' !=# 'ABC')
797 assert_equal(false, 'abc' !=? 'ABC')
798 set noignorecase
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100799
Bram Moolenaar659bb222020-11-12 20:16:39 +0100800 var bb = 0z3f
801 assert_equal(false, 0z3f != bb)
802 assert_equal(true, bb != 0z4f)
803 assert_equal(false, g:ablob != 0z01ab)
804 assert_equal(true, 0z3f != g:ablob)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100805
Bram Moolenaar659bb222020-11-12 20:16:39 +0100806 assert_equal(false, [1, 2, 3] != [1, 2, 3])
807 assert_equal(true, [1, 2, 3] != [2, 3, 1])
808 assert_equal(false, [2, 3, 4] != g:alist)
809 assert_equal(true, g:alist != [2, 3, 1])
810 assert_equal(true, [1, 2, 3] != [])
811 assert_equal(true, [1, 2, 3] != ['1', '2', '3'])
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100812
Bram Moolenaare0de1712020-12-02 17:36:54 +0100813 assert_equal(false, {one: 1, two: 2} != {one: 1, two: 2})
814 assert_equal(true, {one: 1, two: 2} != {one: 2, two: 2})
815 assert_equal(true, {one: 1, two: 2} != {two: 2})
816 assert_equal(true, {one: 1, two: 2} != {})
817 assert_equal(false, g:adict != {bbb: 8, aaa: 2})
818 assert_equal(true, {ccc: 9, aaa: 2} != g:adict)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100819
Bram Moolenaar659bb222020-11-12 20:16:39 +0100820 assert_equal(false, function('g:Test_expr4_equal') != function('g:Test_expr4_equal'))
821 assert_equal(true, function('g:Test_expr4_equal') != function('g:Test_expr4_is'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100822
Bram Moolenaar659bb222020-11-12 20:16:39 +0100823 assert_equal(false, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [123]))
824 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_is', [123]))
825 assert_equal(true, function('g:Test_expr4_equal', [123]) != function('g:Test_expr4_equal', [999]))
826 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000827 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100828enddef
829
830" test > comperator
831def Test_expr4_greater()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100832 var lines =<< trim END
833 assert_true(2 > 0)
834 assert_true(2 >
835 1)
836 assert_false(2 > 2)
837 assert_false(2 > 3)
838 var nr2 = 2
839 assert_true(nr2 > 0)
840 assert_true(nr2 >
841 1)
842 assert_false(nr2 > 2)
843 assert_false(nr2
844 > 3)
845 if has('float')
846 var ff = 2.0
847 assert_true(ff > 0.0)
848 assert_true(ff > 1.0)
849 assert_false(ff > 2.0)
850 assert_false(ff > 3.0)
851 endif
852 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000853 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100854enddef
855
856" test >= comperator
857def Test_expr4_greaterequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100858 var lines =<< trim END
859 assert_true(2 >= 0)
860 assert_true(2 >=
861 2)
862 assert_false(2 >= 3)
863 var nr2 = 2
864 assert_true(nr2 >= 0)
865 assert_true(nr2 >= 2)
866 assert_false(nr2 >= 3)
867 if has('float')
868 var ff = 2.0
869 assert_true(ff >= 0.0)
870 assert_true(ff >= 2.0)
871 assert_false(ff >= 3.0)
872 endif
873 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000874 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100875enddef
876
877" test < comperator
878def Test_expr4_smaller()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100879 var lines =<< trim END
880 assert_false(2 < 0)
881 assert_false(2 <
882 2)
883 assert_true(2
884 < 3)
885 var nr2 = 2
886 assert_false(nr2 < 0)
887 assert_false(nr2 < 2)
888 assert_true(nr2 < 3)
889 if has('float')
890 var ff = 2.0
891 assert_false(ff < 0.0)
892 assert_false(ff < 2.0)
893 assert_true(ff < 3.0)
894 endif
895 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000896 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100897enddef
898
899" test <= comperator
900def Test_expr4_smallerequal()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100901 var lines =<< trim END
902 assert_false(2 <= 0)
903 assert_false(2 <=
904 1)
905 assert_true(2
906 <= 2)
907 assert_true(2 <= 3)
908 var nr2 = 2
909 assert_false(nr2 <= 0)
910 assert_false(nr2 <= 1)
911 assert_true(nr2 <= 2)
912 assert_true(nr2 <= 3)
913 if has('float')
914 var ff = 2.0
915 assert_false(ff <= 0.0)
916 assert_false(ff <= 1.0)
917 assert_true(ff <= 2.0)
918 assert_true(ff <= 3.0)
919 endif
920 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000921 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100922enddef
923
924" test =~ comperator
925def Test_expr4_match()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100926 var lines =<< trim END
927 assert_equal(false, '2' =~ '0')
928 assert_equal(false, ''
929 =~ '0')
930 assert_equal(true, '2' =~
931 '[0-9]')
932 set ignorecase
933 assert_equal(false, 'abc' =~ 'ABC')
934 assert_equal(false, 'abc' =~# 'ABC')
935 assert_equal(true, 'abc' =~? 'ABC')
936 set noignorecase
937 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000938 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100939enddef
940
941" test !~ comperator
942def Test_expr4_nomatch()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100943 var lines =<< trim END
944 assert_equal(true, '2' !~ '0')
945 assert_equal(true, ''
946 !~ '0')
947 assert_equal(false, '2' !~
948 '[0-9]')
949 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000950 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100951enddef
952
953" test is comperator
954def Test_expr4_is()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100955 var lines =<< trim END
956 var mylist = [2]
957 assert_false(mylist is [2])
958 var other = mylist
959 assert_true(mylist is
960 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100961
Bram Moolenaar659bb222020-11-12 20:16:39 +0100962 var myblob = 0z1234
963 assert_false(myblob
964 is 0z1234)
965 var otherblob = myblob
966 assert_true(myblob is otherblob)
967 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000968 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100969enddef
970
971" test isnot comperator
972def Test_expr4_isnot()
Bram Moolenaar659bb222020-11-12 20:16:39 +0100973 var lines =<< trim END
974 var mylist = [2]
975 assert_true('2' isnot '0')
976 assert_true(mylist isnot [2])
977 var other = mylist
978 assert_false(mylist isnot
979 other)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +0100980
Bram Moolenaar659bb222020-11-12 20:16:39 +0100981 var myblob = 0z1234
982 assert_true(myblob
983 isnot 0z1234)
984 var otherblob = myblob
985 assert_false(myblob isnot otherblob)
986 END
Bram Moolenaar62aec932022-01-29 21:45:34 +0000987 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100988enddef
989
Bram Moolenaar62aec932022-01-29 21:45:34 +0000990def g:RetVoid()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200991 var x = 1
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100992enddef
993
Bram Moolenaar8294d492020-08-10 22:40:56 +0200994def Test_expr4_vim9script()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +0200995 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +0200996 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +0200997 var name = 0
Bram Moolenaare6536aa2020-06-26 22:00:38 +0200998 < 1
Bram Moolenaar98309382020-09-27 21:58:45 +0200999 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001000 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001001 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001002
1003 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001004 var name = 123
Bram Moolenaar93be1642020-10-11 21:34:41 +02001005 # comment
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001006 != 123
Bram Moolenaar98309382020-09-27 21:58:45 +02001007 assert_equal(false, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001008 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001009 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001010
1011 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001012 var name = 123 ==
Bram Moolenaar9215f012020-06-27 21:18:00 +02001013 123
Bram Moolenaar98309382020-09-27 21:58:45 +02001014 assert_equal(true, name)
Bram Moolenaar9215f012020-06-27 21:18:00 +02001015 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001016 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar9215f012020-06-27 21:18:00 +02001017
1018 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001019 var list = [1, 2, 3]
1020 var name = list
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001021 is list
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001022 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001023 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001024 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001025
1026 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001027 var list = [1, 2, 3]
1028 var name = list # comment
1029 # comment
1030 is list
1031 assert_equal(true, name)
1032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001033 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001034
1035 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001036 var myblob = 0z1234
1037 var name = myblob
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001038 isnot 0z11
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001039 assert_equal(true, name)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001040 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001041 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001042
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001043 # spot check mismatching types
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001044 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001045 echo '' == 0
1046 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001047 v9.CheckDefAndScriptFailure(lines, 'E1072:', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001048
1049 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001050 echo v:true > v:false
1051 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001052 v9.CheckDefAndScriptFailure(lines, 'Cannot compare bool with bool', 1)
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001053
1054 lines =<< trim END
Bram Moolenaar543e6f32020-07-10 22:45:38 +02001055 echo 123 is 123
1056 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001057 v9.CheckDefAndScriptFailure(lines, 'Cannot use "is" with number', 1)
Bram Moolenaarc71f36a2020-07-21 21:31:00 +02001058
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001059 # check missing white space
1060 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001061 echo 2>3
1062 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001063 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''>'' at ">3"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001064
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001065 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001066 echo 2 >3
1067 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001068 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001069
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001070 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001071 echo 2> 3
1072 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001073 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001074
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001075 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001076 echo 2!=3
1077 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001078 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001079
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001080 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001081 echo 2 !=3
1082 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001083 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''!='' at "!=3"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001084
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001085 lines =<< trim END
Bram Moolenaarff1cd392020-08-05 11:51:30 +02001086 echo 2!= 3
1087 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001088 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar8294d492020-08-10 22:40:56 +02001089
mityu4ac198c2021-05-28 17:52:40 +02001090 for op in ['==', '>', '>=', '<', '<=', '=~', '!~', 'is', 'isnot']
1091 lines = ["echo 'aaa'", op .. "'bbb'", '# comment']
1092 var msg = printf("E1004: White space required before and after '%s'", op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001093 v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02001094 endfor
1095
Bram Moolenaar8294d492020-08-10 22:40:56 +02001096 lines =<< trim END
Bram Moolenaar8294d492020-08-10 22:40:56 +02001097 echo len('xxx') == 3
1098 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001099 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf9235712020-08-16 18:42:53 +02001100
1101 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001102 var line = 'abc'
Bram Moolenaarf9235712020-08-16 18:42:53 +02001103 echo line[1] =~ '\w'
1104 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001105 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6536aa2020-06-26 22:00:38 +02001106enddef
1107
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001108func Test_expr4_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001109 let msg = "White space required before and after '>'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001110 call v9.CheckDefAndScriptFailure(["var x = 1>2"], msg, 1)
1111 call v9.CheckDefAndScriptFailure(["var x = 1 >2"], msg, 1)
1112 call v9.CheckDefAndScriptFailure(["var x = 1> 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001113
Bram Moolenaar77072282020-09-16 17:55:40 +02001114 let msg = "White space required before and after '=='"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001115 call v9.CheckDefAndScriptFailure(["var x = 1==2"], msg, 1)
1116 call v9.CheckDefAndScriptFailure(["var x = 1 ==2"], msg, 1)
1117 call v9.CheckDefAndScriptFailure(["var x = 1== 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001118
Bram Moolenaar77072282020-09-16 17:55:40 +02001119 let msg = "White space required before and after 'is'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001120 call v9.CheckDefAndScriptFailure(["var x = '1'is'2'"], msg, 1)
1121 call v9.CheckDefAndScriptFailure(["var x = '1' is'2'"], msg, 1)
1122 call v9.CheckDefAndScriptFailure(["var x = '1'is '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001123
Bram Moolenaar77072282020-09-16 17:55:40 +02001124 let msg = "White space required before and after 'isnot'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001125 call v9.CheckDefAndScriptFailure(["var x = '1'isnot'2'"], msg, 1)
1126 call v9.CheckDefAndScriptFailure(["var x = '1' isnot'2'"], msg, 1)
1127 call v9.CheckDefAndScriptFailure(["var x = '1'isnot '2'"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001128
Bram Moolenaar62aec932022-01-29 21:45:34 +00001129 call v9.CheckDefAndScriptFailure(["var x = 1 is# 2"], 'E15:', 1)
1130 call v9.CheckDefAndScriptFailure(["var x = 1 is? 2"], 'E15:', 1)
1131 call v9.CheckDefAndScriptFailure(["var x = 1 isnot# 2"], 'E15:', 1)
1132 call v9.CheckDefAndScriptFailure(["var x = 1 isnot? 2"], 'E15:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001133
Bram Moolenaar62aec932022-01-29 21:45:34 +00001134 call v9.CheckDefAndScriptFailure(["var x = 1 == '2'"], 'Cannot compare number with string', 1)
1135 call v9.CheckDefAndScriptFailure(["var x = '1' == 2"], 'Cannot compare string with number', 1)
1136 call v9.CheckDefAndScriptFailure(["var x = 1 == g:RetVoid()"], 'Cannot compare number with void', 1)
1137 call v9.CheckDefAndScriptFailure(["var x = g:RetVoid() == 1"], 'Cannot compare void with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001138
Bram Moolenaar62aec932022-01-29 21:45:34 +00001139 call v9.CheckDefAndScriptFailure(["var x = true > false"], 'Cannot compare bool with bool', 1)
1140 call v9.CheckDefAndScriptFailure(["var x = true >= false"], 'Cannot compare bool with bool', 1)
1141 call v9.CheckDefAndScriptFailure(["var x = true < false"], 'Cannot compare bool with bool', 1)
1142 call v9.CheckDefAndScriptFailure(["var x = true <= false"], 'Cannot compare bool with bool', 1)
1143 call v9.CheckDefAndScriptFailure(["var x = true =~ false"], 'Cannot compare bool with bool', 1)
1144 call v9.CheckDefAndScriptFailure(["var x = true !~ false"], 'Cannot compare bool with bool', 1)
1145 call v9.CheckDefAndScriptFailure(["var x = true is false"], 'Cannot use "is" with bool', 1)
1146 call v9.CheckDefAndScriptFailure(["var x = true isnot false"], 'Cannot use "isnot" with bool', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001147
Bram Moolenaar62aec932022-01-29 21:45:34 +00001148 call v9.CheckDefAndScriptFailure(["var x = v:none is v:null"], 'Cannot use "is" with special', 1)
1149 call v9.CheckDefAndScriptFailure(["var x = v:none isnot v:null"], 'Cannot use "isnot" with special', 1)
1150 call v9.CheckDefAndScriptFailure(["var x = 123 is 123"], 'Cannot use "is" with number', 1)
1151 call v9.CheckDefAndScriptFailure(["var x = 123 isnot 123"], 'Cannot use "isnot" with number', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001152 if has('float')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001153 call v9.CheckDefAndScriptFailure(["var x = 1.3 is 1.3"], 'Cannot use "is" with float', 1)
1154 call v9.CheckDefAndScriptFailure(["var x = 1.3 isnot 1.3"], 'Cannot use "isnot" with float', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001155 endif
1156
Bram Moolenaar62aec932022-01-29 21:45:34 +00001157 call v9.CheckDefAndScriptFailure(["var x = 0za1 > 0z34"], 'Cannot compare blob with blob', 1)
1158 call v9.CheckDefAndScriptFailure(["var x = 0za1 >= 0z34"], 'Cannot compare blob with blob', 1)
1159 call v9.CheckDefAndScriptFailure(["var x = 0za1 < 0z34"], 'Cannot compare blob with blob', 1)
1160 call v9.CheckDefAndScriptFailure(["var x = 0za1 <= 0z34"], 'Cannot compare blob with blob', 1)
1161 call v9.CheckDefAndScriptFailure(["var x = 0za1 =~ 0z34"], 'Cannot compare blob with blob', 1)
1162 call v9.CheckDefAndScriptFailure(["var x = 0za1 !~ 0z34"], 'Cannot compare blob with blob', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001163
Bram Moolenaar62aec932022-01-29 21:45:34 +00001164 call v9.CheckDefAndScriptFailure(["var x = [13] > [88]"], 'Cannot compare list with list', 1)
1165 call v9.CheckDefAndScriptFailure(["var x = [13] >= [88]"], 'Cannot compare list with list', 1)
1166 call v9.CheckDefAndScriptFailure(["var x = [13] < [88]"], 'Cannot compare list with list', 1)
1167 call v9.CheckDefAndScriptFailure(["var x = [13] <= [88]"], 'Cannot compare list with list', 1)
1168 call v9.CheckDefAndScriptFailure(["var x = [13] =~ [88]"], 'Cannot compare list with list', 1)
1169 call v9.CheckDefAndScriptFailure(["var x = [13] !~ [88]"], 'Cannot compare list with list', 1)
Bram Moolenaar5381c7a2020-03-02 22:53:32 +01001170
Bram Moolenaar62aec932022-01-29 21:45:34 +00001171 call v9.CheckDefAndScriptFailure(['var j: job', 'var chan: channel', 'var r = j == chan'], 'Cannot compare job with channel', 3)
1172 call v9.CheckDefAndScriptFailure(['var j: job', 'var x: list<any>', 'var r = j == x'], 'Cannot compare job with list', 3)
1173 call v9.CheckDefAndScriptFailure(['var j: job', 'var Xx: func', 'var r = j == Xx'], 'Cannot compare job with func', 3)
1174 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 +01001175endfunc
1176
1177" test addition, subtraction, concatenation
1178def Test_expr5()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001179 var lines =<< trim END
1180 assert_equal(66, 60 + 6)
1181 assert_equal(70, 60 +
1182 g:anint)
1183 assert_equal(9, g:thefour
1184 + 5)
1185 assert_equal(14, g:thefour + g:anint)
1186 assert_equal([1, 2, 3, 4], [1] + g:alist)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001187
Bram Moolenaar659bb222020-11-12 20:16:39 +01001188 assert_equal(54, 60 - 6)
1189 assert_equal(50, 60 -
1190 g:anint)
1191 assert_equal(-1, g:thefour
1192 - 5)
1193 assert_equal(-6, g:thefour - g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001194
Bram Moolenaar659bb222020-11-12 20:16:39 +01001195 assert_equal('hello', 'hel' .. 'lo')
1196 assert_equal('hello 123', 'hello ' ..
1197 123)
1198 assert_equal('hello 123', 'hello '
1199 .. 123)
1200 assert_equal('123 hello', 123 .. ' hello')
1201 assert_equal('123456', 123 .. 456)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001202
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001203 assert_equal('atrue', 'a' .. true)
1204 assert_equal('afalse', 'a' .. false)
Bram Moolenaar67977822021-01-03 21:53:53 +01001205 assert_equal('anull', 'a' .. v:null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001206 assert_equal('av:none', 'a' .. v:none)
1207 if has('float')
1208 assert_equal('a0.123', 'a' .. 0.123)
1209 endif
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001210
Bram Moolenaare507ff12021-01-31 21:47:42 +01001211 assert_equal(3, 1 + [2, 3, 4][0])
1212 assert_equal(5, 2 + {key: 3}['key'])
1213
Bram Moolenaara8b8af12021-01-01 15:11:04 +01001214 set digraph
1215 assert_equal('val: true', 'val: ' .. &digraph)
1216 set nodigraph
1217 assert_equal('val: false', 'val: ' .. &digraph)
1218
Bram Moolenaar659bb222020-11-12 20:16:39 +01001219 assert_equal([1, 2, 3, 4], [1, 2] + [3, 4])
1220 assert_equal(0z11223344, 0z1122 + 0z3344)
1221 assert_equal(0z112201ab, 0z1122
1222 + g:ablob)
1223 assert_equal(0z01ab3344, g:ablob + 0z3344)
1224 assert_equal(0z01ab01ab, g:ablob + g:ablob)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001225
Bram Moolenaar659bb222020-11-12 20:16:39 +01001226 # concatenate non-constant to constant
1227 var save_path = &path
1228 &path = 'b'
1229 assert_equal('ab', 'a' .. &path)
1230 &path = save_path
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001231
Bram Moolenaar659bb222020-11-12 20:16:39 +01001232 @b = 'b'
1233 assert_equal('ab', 'a' .. @b)
Bram Moolenaar3fc71282020-08-21 20:43:17 +02001234
Bram Moolenaar659bb222020-11-12 20:16:39 +01001235 $ENVVAR = 'env'
1236 assert_equal('aenv', 'a' .. $ENVVAR)
Bram Moolenaard62d87d2021-01-04 17:40:12 +01001237
1238 assert_equal('val', '' .. {key: 'val'}['key'])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001239 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001240 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001241enddef
1242
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001243def Test_expr5_vim9script()
Bram Moolenaar696ba232020-07-29 21:20:41 +02001244 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001245 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001246 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001247 + 77
1248 - 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001249 assert_equal(66, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001250 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001251 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001252
1253 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001254 var name = 11 +
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001255 77 -
1256 22
Bram Moolenaar98309382020-09-27 21:58:45 +02001257 assert_equal(66, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001258 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001259 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001260
1261 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001262 var name = 11 + # comment
1263 77 -
1264 # comment
1265 22
1266 assert_equal(66, name)
1267 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001268 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001269
1270 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001271 var name = 'one'
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001272 .. 'two'
Bram Moolenaar98309382020-09-27 21:58:45 +02001273 assert_equal('onetwo', name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001274 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001275 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001276
1277 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001278 echo 'abc' is# 'abc'
1279 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001280 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001281
1282 lines =<< trim END
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001283 echo {} - 22
1284 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001285 v9.CheckDefAndScriptFailure(lines, ['E1036:', 'E728:'], 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001286
1287 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001288 echo [] - 33
1289 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001290 v9.CheckDefAndScriptFailure(lines, ['E1036:', 'E745:'], 1)
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001291
1292 lines =<< trim END
Bram Moolenaar081db1a2020-10-22 20:09:43 +02001293 echo 0z1234 - 44
1294 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001295 v9.CheckDefAndScriptFailure(lines, ['E1036', 'E974:'], 1)
Bram Moolenaarb07a39d2020-10-22 19:00:01 +02001296
1297 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001298 echo 'abc' is? 'abc'
1299 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001300 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001301
1302 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001303 echo 'abc' isnot# 'abc'
1304 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001305 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaar696ba232020-07-29 21:20:41 +02001306
1307 lines =<< trim END
Bram Moolenaar696ba232020-07-29 21:20:41 +02001308 echo 'abc' isnot? 'abc'
1309 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001310 v9.CheckDefAndScriptFailure(lines, 'E15:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001311
1312 # check white space
1313 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001314 echo 5+6
1315 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001316 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001317 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001318 echo 5 +6
1319 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001320 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001321
1322 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001323 echo 5+ 6
1324 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001325 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001326
1327 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001328 echo 'a'..'b'
1329 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001330 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001331
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001332 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001333 echo 'a' ..'b'
1334 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001335 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001336
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001337 lines =<< trim END
Bram Moolenaarbb1b5e22020-08-05 10:53:21 +02001338 echo 'a'.. 'b'
1339 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001340 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at ".. ''b''"', 1)
mityu89dcb4d2021-05-28 13:50:17 +02001341
1342 lines =<< trim END
1343 echo 'a'
1344 ..'b'
1345 # comment
1346 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001347 v9.CheckDefAndScriptFailure(lines, 'E1004: White space required before and after ''..'' at "..''b''"', 2)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001348
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001349 # check invalid string concatenation
1350 lines =<< trim END
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001351 echo 'a' .. [1]
1352 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001353 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E730:'], 1)
Bram Moolenaara9749532021-03-06 18:18:19 +01001354
1355 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02001356 echo 'a' .. {a: 1}
1357 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001358 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E731:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001359
1360 lines =<< trim END
1361 echo 'a' .. test_void()
1362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001363 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001364
1365 lines =<< trim END
1366 echo 'a' .. 0z33
1367 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001368 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E976:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001369
1370 lines =<< trim END
1371 echo 'a' .. function('len')
1372 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001373 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E729:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001374
1375 lines =<< trim END
Bram Moolenaara9749532021-03-06 18:18:19 +01001376 new
1377 ['']->setline(1)
1378 /pattern
1379
1380 eval 0
1381 bwipe!
1382 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001383 v9.CheckDefAndScriptFailure(lines, "E1004: White space required before and after '/' at \"/pattern", 3)
mityu4ac198c2021-05-28 17:52:40 +02001384
1385 for op in ['+', '-']
1386 lines = ['var x = 1', op .. '2', '# comment']
1387 var msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001388 v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02001389 endfor
Bram Moolenaar79182382020-09-05 20:06:33 +02001390enddef
1391
1392def Test_expr5_vim9script_channel()
1393 if !has('channel')
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001394 MissingFeature 'channel'
Bram Moolenaar79182382020-09-05 20:06:33 +02001395 else
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001396 var lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001397 echo 'a' .. test_null_job()
1398 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001399 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001400 lines =<< trim END
Bram Moolenaar79182382020-09-05 20:06:33 +02001401 echo 'a' .. test_null_channel()
1402 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001403 v9.CheckDefAndScriptFailure(lines, ['E1105:', 'E908:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001404 endif
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001405enddef
1406
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001407def Test_expr5_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001408 if !has('float')
1409 MissingFeature 'float'
1410 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001411 var lines =<< trim END
1412 assert_equal(66.0, 60.0 + 6.0)
1413 assert_equal(66.0, 60.0 + 6)
1414 assert_equal(66.0, 60 +
1415 6.0)
1416 assert_equal(5.1, g:afloat
1417 + 5)
1418 assert_equal(8.1, 8 + g:afloat)
1419 assert_equal(10.1, g:anint + g:afloat)
1420 assert_equal(10.1, g:afloat + g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001421
Bram Moolenaar659bb222020-11-12 20:16:39 +01001422 assert_equal(54.0, 60.0 - 6.0)
1423 assert_equal(54.0, 60.0
1424 - 6)
1425 assert_equal(54.0, 60 - 6.0)
1426 assert_equal(-4.9, g:afloat - 5)
1427 assert_equal(7.9, 8 - g:afloat)
1428 assert_equal(9.9, g:anint - g:afloat)
1429 assert_equal(-9.9, g:afloat - g:anint)
1430 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001431 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001432 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001433enddef
1434
1435func Test_expr5_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001436 let msg = "White space required before and after '+'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001437 call v9.CheckDefAndScriptFailure(["var x = 1+2"], msg, 1)
1438 call v9.CheckDefAndScriptFailure(["var x = 1 +2"], msg, 1)
1439 call v9.CheckDefAndScriptFailure(["var x = 1+ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001440
Bram Moolenaar77072282020-09-16 17:55:40 +02001441 let msg = "White space required before and after '-'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001442 call v9.CheckDefAndScriptFailure(["var x = 1-2"], msg, 1)
1443 call v9.CheckDefAndScriptFailure(["var x = 1 -2"], msg, 1)
1444 call v9.CheckDefAndScriptFailure(["var x = 1- 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001445
Bram Moolenaar77072282020-09-16 17:55:40 +02001446 let msg = "White space required before and after '..'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001447 call v9.CheckDefAndScriptFailure(["var x = '1'..'2'"], msg, 1)
1448 call v9.CheckDefAndScriptFailure(["var x = '1' ..'2'"], msg, 1)
1449 call v9.CheckDefAndScriptFailure(["var x = '1'.. '2'"], msg, 1)
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001450
Bram Moolenaar62aec932022-01-29 21:45:34 +00001451 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + 33"], ['E1051:', 'E974:'], 1)
1452 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + [3]"], ['E1051:', 'E974:'], 1)
1453 call v9.CheckDefAndScriptFailure(["var x = 0z1122 + 'asd'"], ['E1051:', 'E974:'], 1)
1454 call v9.CheckDefAndScriptFailure(["var x = 33 + 0z1122"], ['E1051:', 'E974:'], 1)
1455 call v9.CheckDefAndScriptFailure(["var x = [3] + 0z1122"], ['E1051:', 'E745:'], 1)
1456 call v9.CheckDefAndScriptFailure(["var x = 'asdf' + 0z1122"], ['E1051:', 'E1030:'], 1)
1457 call v9.CheckDefAndScriptFailure(["var x = 6 + xxx"], ['E1001:', 'E121:'], 1)
Bram Moolenaar418f1df2020-08-12 21:34:49 +02001458
Bram Moolenaar62aec932022-01-29 21:45:34 +00001459 call v9.CheckDefAndScriptFailure(["var x = 'a' .. [1]"], ['E1105:', 'E730:'], 1)
1460 call v9.CheckDefAndScriptFailure(["var x = 'a' .. {a: 1}"], ['E1105:', 'E731:'], 1)
1461 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_void()"], ['E1105:', 'E908:'], 1)
1462 call v9.CheckDefAndScriptFailure(["var x = 'a' .. 0z32"], ['E1105:', 'E976:'], 1)
1463 call v9.CheckDefAndScriptFailure(["var x = 'a' .. function('len')"], ['E1105:', 'E729:'], 1)
1464 call v9.CheckDefAndScriptFailure(["var x = 'a' .. function('len', ['a'])"], ['E1105:', 'E729:'], 1)
Bram Moolenaard92cc132020-11-18 17:17:15 +01001465
Bram Moolenaar62aec932022-01-29 21:45:34 +00001466 call v9.CheckDefAndScriptFailure(['var x = 1 + v:none'], ['E1051:', 'E611:'], 1)
1467 call v9.CheckDefAndScriptFailure(['var x = 1 + v:null'], ['E1051:', 'E611:'], 1)
1468 call v9.CheckDefAndScriptFailure(['var x = 1 + v:true'], ['E1051:', 'E1138:'], 1)
1469 call v9.CheckDefAndScriptFailure(['var x = 1 + v:false'], ['E1051:', 'E1138:'], 1)
1470 call v9.CheckDefAndScriptFailure(['var x = 1 + true'], ['E1051:', 'E1138:'], 1)
1471 call v9.CheckDefAndScriptFailure(['var x = 1 + false'], ['E1051:', 'E1138:'], 1)
Bram Moolenaar79182382020-09-05 20:06:33 +02001472endfunc
1473
1474func Test_expr5_fails_channel()
Bram Moolenaareb6c2762022-01-31 13:36:36 +00001475 CheckFeature channel
1476
Bram Moolenaar62aec932022-01-29 21:45:34 +00001477 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_null_job()"], ['E1105:', 'E908:'], 1)
1478 call v9.CheckDefAndScriptFailure(["var x = 'a' .. test_null_channel()"], ['E1105:', 'E908:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001479endfunc
1480
Bram Moolenaar399ea812020-12-15 21:28:57 +01001481def Test_expr5_list_add()
Bram Moolenaar90193e62021-04-04 20:49:50 +02001482 var lines =<< trim END
1483 # concatenating two lists with same member types is OK
1484 var d = {}
1485 for i in ['a'] + ['b']
1486 d = {[i]: 0}
1487 endfor
Bram Moolenaar399ea812020-12-15 21:28:57 +01001488
Bram Moolenaar90193e62021-04-04 20:49:50 +02001489 # concatenating two lists with different member types results in "any"
1490 var dany = {}
1491 for i in ['a'] + [12]
1492 dany[i] = i
1493 endfor
1494 assert_equal({a: 'a', 12: 12}, dany)
Bram Moolenaard345fb92021-03-10 18:43:09 +01001495
Bram Moolenaar90193e62021-04-04 20:49:50 +02001496 # result of glob() is "any", runtime type check
1497 var sl: list<string> = glob('*.txt', false, true) + ['']
Bram Moolenaar7676c152022-02-03 21:47:34 +00001498
1499 var lln: list<list<number>> = [[1] + [2]]
1500 assert_equal([[1, 2]], lln)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001501 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001502 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar46950b22022-02-04 11:36:51 +00001503
1504 lines =<< trim END
1505 var ln: list<number> = [0]
1506 var lln: list<list<number>> = [ln + []]
1507 END
1508 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar399ea812020-12-15 21:28:57 +01001509enddef
1510
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001511" test multiply, divide, modulo
1512def Test_expr6()
Bram Moolenaar659bb222020-11-12 20:16:39 +01001513 var lines =<< trim END
1514 assert_equal(36, 6 * 6)
1515 assert_equal(24, 6 *
1516 g:thefour)
1517 assert_equal(24, g:thefour
1518 * 6)
1519 assert_equal(40, g:anint * g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001520
Bram Moolenaar659bb222020-11-12 20:16:39 +01001521 assert_equal(10, 60 / 6)
1522 assert_equal(6, 60 /
1523 g:anint)
1524 assert_equal(1, g:anint / 6)
1525 assert_equal(2, g:anint
1526 / g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001527
Bram Moolenaar659bb222020-11-12 20:16:39 +01001528 assert_equal(5, 11 % 6)
1529 assert_equal(4, g:anint % 6)
1530 assert_equal(3, 13 %
1531 g:anint)
1532 assert_equal(2, g:anint
1533 % g:thefour)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001534
Bram Moolenaar659bb222020-11-12 20:16:39 +01001535 assert_equal(4, 6 * 4 / 6)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001536
Bram Moolenaar659bb222020-11-12 20:16:39 +01001537 var x = [2]
1538 var y = [3]
1539 assert_equal(5, x[0] + y[0])
1540 assert_equal(6, x[0] * y[0])
1541 if has('float')
1542 var xf = [2.0]
1543 var yf = [3.0]
1544 assert_equal(5.0, xf[0]
1545 + yf[0])
1546 assert_equal(6.0, xf[0]
1547 * yf[0])
1548 endif
1549 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001550 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001551
Bram Moolenaar62aec932022-01-29 21:45:34 +00001552 v9.CheckDefAndScriptFailure(["var x = 6 * xxx"], ['E1001:', 'E121:'], 1)
1553 v9.CheckDefFailure(["var d = 6 * "], 'E1097:', 3)
1554 v9.CheckScriptFailure(['vim9script', "var d = 6 * "], 'E15:', 2)
Bram Moolenaar99880f92021-01-20 21:23:14 +01001555
Bram Moolenaar62aec932022-01-29 21:45:34 +00001556 v9.CheckDefExecAndScriptFailure(['echo 1 / 0'], 'E1154', 1)
1557 v9.CheckDefExecAndScriptFailure(['echo 1 % 0'], 'E1154', 1)
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001558
1559 lines =<< trim END
1560 var n = 0
1561 eval 1 / n
1562 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001563 v9.CheckDefExecAndScriptFailure(lines, 'E1154', 2)
Bram Moolenaarfbeefb12021-08-07 15:50:23 +02001564
1565 lines =<< trim END
1566 var n = 0
1567 eval 1 % n
1568 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001569 v9.CheckDefExecAndScriptFailure(lines, 'E1154', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001570enddef
1571
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001572def Test_expr6_vim9script()
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001573 # check line continuation
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001574 var lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001575 var name = 11
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001576 * 22
1577 / 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001578 assert_equal(80, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001579 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001580 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001581
1582 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001583 var name = 25
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001584 % 10
Bram Moolenaar98309382020-09-27 21:58:45 +02001585 assert_equal(5, name)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001586 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001587 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001588
1589 lines =<< trim END
Bram Moolenaar93be1642020-10-11 21:34:41 +02001590 var name = 25
1591 # comment
1592
1593 # comment
1594 % 10
1595 assert_equal(5, name)
1596 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001597 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar93be1642020-10-11 21:34:41 +02001598
1599 lines =<< trim END
Bram Moolenaar98309382020-09-27 21:58:45 +02001600 var name = 11 *
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001601 22 /
1602 3
Bram Moolenaar98309382020-09-27 21:58:45 +02001603 assert_equal(80, name)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001604 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001605 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001606
1607 # check white space
1608 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001609 echo 5*6
1610 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001611 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001612
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001613 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001614 echo 5 *6
1615 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001616 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02001617
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001618 lines =<< trim END
Bram Moolenaarb4caa162020-08-05 11:36:52 +02001619 echo 5* 6
1620 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001621 v9.CheckDefAndScriptFailure(lines, 'E1004:', 1)
Bram Moolenaar5409f5d2020-06-24 18:37:35 +02001622enddef
1623
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001624def Test_expr6_float()
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001625 if !has('float')
1626 MissingFeature 'float'
1627 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001628 var lines =<< trim END
1629 assert_equal(36.0, 6.0 * 6)
1630 assert_equal(36.0, 6 *
1631 6.0)
1632 assert_equal(36.0, 6.0 * 6.0)
1633 assert_equal(1.0, g:afloat * g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001634
Bram Moolenaar659bb222020-11-12 20:16:39 +01001635 assert_equal(10.0, 60 / 6.0)
1636 assert_equal(10.0, 60.0 /
1637 6)
1638 assert_equal(10.0, 60.0 / 6.0)
1639 assert_equal(0.01, g:afloat / g:anint)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001640
Bram Moolenaar659bb222020-11-12 20:16:39 +01001641 assert_equal(4.0, 6.0 * 4 / 6)
1642 assert_equal(4.0, 6 *
1643 4.0 /
1644 6)
1645 assert_equal(4.0, 6 * 4 / 6.0)
1646 assert_equal(4.0, 6.0 * 4.0 / 6)
1647 assert_equal(4.0, 6 * 4.0 / 6.0)
1648 assert_equal(4.0, 6.0 * 4 / 6.0)
1649 assert_equal(4.0, 6.0 * 4.0 / 6.0)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001650
Bram Moolenaar659bb222020-11-12 20:16:39 +01001651 assert_equal(4.0, 6.0 * 4.0 / 6.0)
1652 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001653 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001654 endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001655enddef
1656
1657func Test_expr6_fails()
Bram Moolenaar77072282020-09-16 17:55:40 +02001658 let msg = "White space required before and after '*'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001659 call v9.CheckDefAndScriptFailure(["var x = 1*2"], msg, 1)
1660 call v9.CheckDefAndScriptFailure(["var x = 1 *2"], msg, 1)
1661 call v9.CheckDefAndScriptFailure(["var x = 1* 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001662
Bram Moolenaar77072282020-09-16 17:55:40 +02001663 let msg = "White space required before and after '/'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001664 call v9.CheckDefAndScriptFailure(["var x = 1/2"], msg, 1)
1665 call v9.CheckDefAndScriptFailure(["var x = 1 /2"], msg, 1)
1666 call v9.CheckDefAndScriptFailure(["var x = 1/ 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001667
Bram Moolenaar77072282020-09-16 17:55:40 +02001668 let msg = "White space required before and after '%'"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001669 call v9.CheckDefAndScriptFailure(["var x = 1%2"], msg, 1)
1670 call v9.CheckDefAndScriptFailure(["var x = 1 %2"], msg, 1)
1671 call v9.CheckDefAndScriptFailure(["var x = 1% 2"], msg, 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001672
Bram Moolenaar62aec932022-01-29 21:45:34 +00001673 call v9.CheckDefAndScriptFailure(["var x = '1' * '2'"], ['E1036:', 'E1030:'], 1)
1674 call v9.CheckDefAndScriptFailure(["var x = '1' / '2'"], ['E1036:', 'E1030:'], 1)
1675 call v9.CheckDefAndScriptFailure(["var x = '1' % '2'"], ['E1035:', 'E1030:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001676
Bram Moolenaar62aec932022-01-29 21:45:34 +00001677 call v9.CheckDefAndScriptFailure(["var x = 0z01 * 0z12"], ['E1036:', 'E974:'], 1)
1678 call v9.CheckDefAndScriptFailure(["var x = 0z01 / 0z12"], ['E1036:', 'E974:'], 1)
1679 call v9.CheckDefAndScriptFailure(["var x = 0z01 % 0z12"], ['E1035:', 'E974:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001680
Bram Moolenaar62aec932022-01-29 21:45:34 +00001681 call v9.CheckDefAndScriptFailure(["var x = [1] * [2]"], ['E1036:', 'E745:'], 1)
1682 call v9.CheckDefAndScriptFailure(["var x = [1] / [2]"], ['E1036:', 'E745:'], 1)
1683 call v9.CheckDefAndScriptFailure(["var x = [1] % [2]"], ['E1035:', 'E745:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001684
Bram Moolenaar62aec932022-01-29 21:45:34 +00001685 call v9.CheckDefAndScriptFailure(["var x = {one: 1} * {two: 2}"], ['E1036:', 'E728:'], 1)
1686 call v9.CheckDefAndScriptFailure(["var x = {one: 1} / {two: 2}"], ['E1036:', 'E728:'], 1)
1687 call v9.CheckDefAndScriptFailure(["var x = {one: 1} % {two: 2}"], ['E1035:', 'E728:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001688
Bram Moolenaar62aec932022-01-29 21:45:34 +00001689 call v9.CheckDefAndScriptFailure(["var x = 0xff[1]"], ['E1107:', 'E1062:'], 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001690 if has('float')
Bram Moolenaar62aec932022-01-29 21:45:34 +00001691 call v9.CheckDefAndScriptFailure(["var x = 0.7[1]"], ['E1107:', 'E806:'], 1)
Bram Moolenaarb13af502020-02-17 21:12:08 +01001692 endif
mityu4ac198c2021-05-28 17:52:40 +02001693
1694 for op in ['*', '/', '%']
1695 let lines = ['var x = 1', op .. '2', '# comment']
1696 let msg = printf("E1004: White space required before and after '%s' at \"%s2\"", op, op)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001697 call v9.CheckDefAndScriptFailure(lines, msg, 2)
mityu4ac198c2021-05-28 17:52:40 +02001698 endfor
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001699endfunc
1700
1701func Test_expr6_float_fails()
Bram Moolenaareb6c2762022-01-31 13:36:36 +00001702 CheckFeature float
Bram Moolenaar62aec932022-01-29 21:45:34 +00001703 call v9.CheckDefAndScriptFailure(["var x = 1.0 % 2"], ['E1035:', 'E804:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001704endfunc
1705
1706" define here to use old style parsing
1707if has('float')
1708 let g:float_zero = 0.0
1709 let g:float_neg = -9.8
1710 let g:float_big = 9.9e99
1711endif
1712let g:blob_empty = 0z
1713let g:blob_one = 0z01
1714let g:blob_long = 0z0102.0304
1715
1716let g:string_empty = ''
1717let g:string_short = 'x'
1718let g:string_long = 'abcdefghijklm'
1719let g:string_special = "ab\ncd\ref\ekk"
1720
1721let g:special_true = v:true
1722let g:special_false = v:false
1723let g:special_null = v:null
1724let g:special_none = v:none
1725
1726let g:list_empty = []
1727let g:list_mixed = [1, 'b', v:false]
1728
1729let g:dict_empty = {}
1730let g:dict_one = #{one: 1}
1731
1732let $TESTVAR = 'testvar'
1733
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001734" type casts
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001735def Test_expr7()
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001736 var lines =<< trim END
1737 var ls: list<string> = ['a', <string>g:string_empty]
1738 var ln: list<number> = [<number>g:anint, <number>g:thefour]
1739 var nr = <number>234
1740 assert_equal(234, nr)
Yegappan Lakshmanan34fcb692021-05-25 20:14:00 +02001741 var b: bool = <bool>1
1742 assert_equal(true, b)
Bram Moolenaar459fbdb2021-04-21 17:57:26 +02001743 var text =
1744 <string>
1745 'text'
1746 if false
1747 text = <number>'xxx'
1748 endif
1749 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001750 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaard1103582020-08-14 22:44:25 +02001751
Bram Moolenaar62aec932022-01-29 21:45:34 +00001752 v9.CheckDefAndScriptFailure(["var x = <nr>123"], 'E1010:', 1)
1753 v9.CheckDefFailure(["var x = <number>"], 'E1097:', 3)
1754 v9.CheckDefFailure(["var x = <number>string(1)"], 'E1012:', 1)
1755 v9.CheckScriptFailure(['vim9script', "var x = <number>"], 'E15:', 2)
1756 v9.CheckDefAndScriptFailure(["var x = <number >123"], 'E1068:', 1)
1757 v9.CheckDefAndScriptFailure(["var x = <number 123"], 'E1104:', 1)
Bram Moolenaar64d662d2020-08-09 19:02:50 +02001758enddef
1759
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001760" test low level expression
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001761def Test_expr8_number()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001762 # number constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001763 var lines =<< trim END
1764 assert_equal(0, 0)
1765 assert_equal(654, 0654)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001766
Bram Moolenaar659bb222020-11-12 20:16:39 +01001767 assert_equal(6, 0x6)
1768 assert_equal(15, 0xf)
1769 assert_equal(255, 0xff)
1770 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001771 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001772enddef
1773
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001774def Test_expr8_float()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001775 # float constant
Bram Moolenaar7f829ca2020-01-31 22:12:41 +01001776 if !has('float')
1777 MissingFeature 'float'
1778 else
Bram Moolenaar659bb222020-11-12 20:16:39 +01001779 var lines =<< trim END
1780 assert_equal(g:float_zero, .0)
1781 assert_equal(g:float_zero, 0.0)
1782 assert_equal(g:float_neg, -9.8)
1783 assert_equal(g:float_big, 9.9e99)
1784 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001785 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001786 endif
1787enddef
1788
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001789def Test_expr8_blob()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001790 # blob constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001791 var lines =<< trim END
1792 assert_equal(g:blob_empty, 0z)
1793 assert_equal(g:blob_one, 0z01)
1794 assert_equal(g:blob_long, 0z0102.0304)
Bram Moolenaarcfc30232021-04-11 20:26:34 +02001795
1796 var testblob = 0z010203
1797 assert_equal(0x01, testblob[0])
1798 assert_equal(0x02, testblob[1])
1799 assert_equal(0x03, testblob[-1])
1800 assert_equal(0x02, testblob[-2])
1801
1802 assert_equal(0z01, testblob[0 : 0])
1803 assert_equal(0z0102, testblob[0 : 1])
1804 assert_equal(0z010203, testblob[0 : 2])
1805 assert_equal(0z010203, testblob[0 : ])
1806 assert_equal(0z0203, testblob[1 : ])
1807 assert_equal(0z0203, testblob[1 : 2])
1808 assert_equal(0z0203, testblob[1 : -1])
1809 assert_equal(0z03, testblob[-1 : -1])
1810 assert_equal(0z02, testblob[-2 : -2])
1811
1812 # blob slice accepts out of range
1813 assert_equal(0z, testblob[3 : 3])
1814 assert_equal(0z, testblob[0 : -4])
Bram Moolenaar659bb222020-11-12 20:16:39 +01001815 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001816 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001817
Bram Moolenaar62aec932022-01-29 21:45:34 +00001818 v9.CheckDefAndScriptFailure(["var x = 0z123"], 'E973:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001819enddef
1820
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001821def Test_expr8_string()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001822 # string constant
Bram Moolenaar659bb222020-11-12 20:16:39 +01001823 var lines =<< trim END
1824 assert_equal(g:string_empty, '')
1825 assert_equal(g:string_empty, "")
1826 assert_equal(g:string_short, 'x')
1827 assert_equal(g:string_short, "x")
1828 assert_equal(g:string_long, 'abcdefghijklm')
1829 assert_equal(g:string_long, "abcdefghijklm")
1830 assert_equal(g:string_special, "ab\ncd\ref\ekk")
1831 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001832 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar92dba362020-03-30 21:22:56 +02001833
Bram Moolenaar62aec932022-01-29 21:45:34 +00001834 v9.CheckDefAndScriptFailure(['var x = "abc'], 'E114:', 1)
1835 v9.CheckDefAndScriptFailure(["var x = 'abc"], 'E115:', 1)
Bram Moolenaar83d0cec2022-02-04 21:17:58 +00001836 v9.CheckDefFailure(["if 0", "echo 'xx", "endif"], 'E115', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001837enddef
1838
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001839def Test_expr8_vimvar()
Bram Moolenaard787e402021-12-24 21:36:12 +00001840 v:errors = []
1841 var errs: list<string> = v:errors
Bram Moolenaar62aec932022-01-29 21:45:34 +00001842 v9.CheckDefFailure(['var errs: list<number> = v:errors'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00001843
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001844 var old: list<string> = v:oldfiles
Bram Moolenaar62aec932022-01-29 21:45:34 +00001845 v9.CheckDefFailure(['var old: list<number> = v:oldfiles'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00001846
1847 var compl: dict<string> = v:completed_item
Bram Moolenaar62aec932022-01-29 21:45:34 +00001848 v9.CheckDefFailure(['var compl: dict<number> = v:completed_item'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00001849
1850 var args: list<string> = v:argv
Bram Moolenaar62aec932022-01-29 21:45:34 +00001851 v9.CheckDefFailure(['var args: list<number> = v:argv'], 'E1012:')
Bram Moolenaard787e402021-12-24 21:36:12 +00001852
1853 var colors: dict<string> = v:colornames
Bram Moolenaar62aec932022-01-29 21:45:34 +00001854 v9.CheckDefFailure(['var colors: dict<number> = v:colornames'], 'E1012:')
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001855
Bram Moolenaar62aec932022-01-29 21:45:34 +00001856 v9.CheckDefFailure(["var old: list<number> = v:oldfiles"], 'E1012: Type mismatch; expected list<number> but got list<string>', 1)
1857 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 +02001858 new
1859 exec "normal! afoo fo\<C-N>\<Esc>"
Bram Moolenaar62aec932022-01-29 21:45:34 +00001860 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 +02001861 bwipe!
Bram Moolenaar5da356e2020-04-09 19:34:43 +02001862enddef
1863
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001864def Test_expr8_special()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001865 # special constant
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001866 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01001867 assert_equal(g:special_true, true)
1868 assert_equal(g:special_false, false)
1869 assert_equal(g:special_true, v:true)
1870 assert_equal(g:special_false, v:false)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001871 assert_equal(v:true, true)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001872 assert_equal(v:false, false)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001873
Bram Moolenaar6e4cfff2020-08-09 22:17:55 +02001874 assert_equal(true, !false)
1875 assert_equal(false, !true)
1876 assert_equal(true, !0)
1877 assert_equal(false, !1)
1878 assert_equal(false, !!false)
1879 assert_equal(true, !!true)
1880 assert_equal(false, !!0)
1881 assert_equal(true, !!1)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001882
1883 var t = true
1884 var f = false
1885 assert_equal(true, t)
1886 assert_equal(false, f)
1887
1888 assert_equal(g:special_null, v:null)
Bram Moolenaar67977822021-01-03 21:53:53 +01001889 assert_equal(g:special_null, null)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001890 assert_equal(g:special_none, v:none)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001891 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001892 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar659bb222020-11-12 20:16:39 +01001893
Bram Moolenaar62aec932022-01-29 21:45:34 +00001894 v9.CheckDefAndScriptFailure(['v:true = true'], 'E46:', 1)
1895 v9.CheckDefAndScriptFailure(['v:true = false'], 'E46:', 1)
1896 v9.CheckDefAndScriptFailure(['v:false = true'], 'E46:', 1)
1897 v9.CheckDefAndScriptFailure(['v:null = 11'], 'E46:', 1)
1898 v9.CheckDefAndScriptFailure(['v:none = 22'], 'E46:', 1)
Bram Moolenaar5d2eb0f2020-07-13 21:59:33 +02001899enddef
1900
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001901def Test_expr8_list()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001902 # list
Bram Moolenaar659bb222020-11-12 20:16:39 +01001903 var lines =<< trim END
1904 assert_equal(g:list_empty, [])
1905 assert_equal(g:list_empty, [ ])
Bram Moolenaar127542b2020-08-09 17:22:04 +02001906
Bram Moolenaar659bb222020-11-12 20:16:39 +01001907 var numbers: list<number> = [1, 2, 3]
1908 numbers = [1]
1909 numbers = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001910
Bram Moolenaar659bb222020-11-12 20:16:39 +01001911 var strings: list<string> = ['a', 'b', 'c']
1912 strings = ['x']
1913 strings = []
Bram Moolenaar127542b2020-08-09 17:22:04 +02001914
Bram Moolenaar659bb222020-11-12 20:16:39 +01001915 var mixed: list<any> = [1, 'b', false,]
1916 assert_equal(g:list_mixed, mixed)
1917 assert_equal('b', mixed[1])
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01001918
Bram Moolenaar659bb222020-11-12 20:16:39 +01001919 echo [1,
1920 2] [3,
1921 4]
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001922
Bram Moolenaar659bb222020-11-12 20:16:39 +01001923 var llstring: list<list<string>> = [['text'], []]
1924 llstring = [[], ['text']]
1925 llstring = [[], []]
1926 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001927 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02001928
Bram Moolenaar5597ba02020-09-27 17:45:03 +02001929 var rangelist: list<number> = range(3)
1930 g:rangelist = range(3)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001931 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 +02001932
Bram Moolenaar62aec932022-01-29 21:45:34 +00001933 v9.CheckDefAndScriptFailure(["var x = 1234[3]"], ['E1107:', 'E1062:'], 1)
1934 v9.CheckDefExecAndScriptFailure(["var x = g:anint[3]"], 'E1062:', 1)
Bram Moolenaar56acb092020-08-16 14:48:19 +02001935
Bram Moolenaar62aec932022-01-29 21:45:34 +00001936 v9.CheckDefAndScriptFailure(["var x = g:list_mixed[xxx]"], ['E1001:', 'E121:'], 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001937
Bram Moolenaar62aec932022-01-29 21:45:34 +00001938 v9.CheckDefAndScriptFailure(["var x = [1,2,3]"], 'E1069:', 1)
1939 v9.CheckDefAndScriptFailure(["var x = [1 ,2, 3]"], 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02001940
Bram Moolenaar62aec932022-01-29 21:45:34 +00001941 v9.CheckDefExecAndScriptFailure(["echo 1", "var x = [][0]", "echo 3"], 'E684:', 2)
Bram Moolenaar1d634542020-08-18 13:41:50 +02001942
Bram Moolenaar62aec932022-01-29 21:45:34 +00001943 v9.CheckDefExecAndScriptFailure(["var x = g:list_mixed['xx']"], ['E1012:', 'E1030:'], 1)
1944 v9.CheckDefFailure(["var x = g:list_mixed["], 'E1097:', 3)
1945 v9.CheckScriptFailure(['vim9script', "var x = g:list_mixed["], 'E15:', 2)
1946 v9.CheckDefFailure(["var x = g:list_mixed[0"], 'E1097:', 3)
1947 v9.CheckScriptFailure(['vim9script', "var x = g:list_mixed[0"], 'E111:', 2)
1948 v9.CheckDefExecAndScriptFailure(["var x = g:list_empty[3]"], 'E684:', 1)
1949 v9.CheckDefExecAndScriptFailure(["var l: list<number> = [234, 'x']"], 'E1012:', 1)
1950 v9.CheckDefExecAndScriptFailure(["var l: list<number> = ['x', 234]"], 'E1012:', 1)
1951 v9.CheckDefExecAndScriptFailure(["var l: list<string> = [234, 'x']"], 'E1012:', 1)
1952 v9.CheckDefExecAndScriptFailure(["var l: list<string> = ['x', 123]"], 'E1012:', 1)
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001953
Bram Moolenaar659bb222020-11-12 20:16:39 +01001954 lines =<< trim END
Bram Moolenaarc1f00662020-10-03 13:41:53 +02001955 var datalist: list<string>
1956 def Main()
1957 datalist += ['x'.
1958 enddef
1959 Main()
1960 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001961 v9.CheckDefAndScriptFailure(lines, 'E1127:')
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01001962
1963 lines =<< trim END
1964 var numbers = [1, 2, 3, 4]
1965 var a = 1
1966 var b = 2
1967 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001968 v9.CheckDefAndScriptFailure(lines + ['echo numbers[1:b]'],
Bram Moolenaare7a73e02021-01-01 19:17:55 +01001969 'E1004: White space required before and after '':'' at ":b]"', 4)
Bram Moolenaar62aec932022-01-29 21:45:34 +00001970 v9.CheckDefAndScriptFailure(lines + ['echo numbers[1: b]'], 'E1004:', 4)
1971 v9.CheckDefAndScriptFailure(lines + ['echo numbers[a :b]'], 'E1004:', 4)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001972enddef
1973
Bram Moolenaar6389baa2022-01-17 20:50:40 +00001974def Test_expr8_list_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001975 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001976 var l = [
Bram Moolenaar71478202020-06-26 22:46:27 +02001977 11,
1978 22,
1979 ]
1980 assert_equal([11, 22], l)
Bram Moolenaarbadd8482020-07-31 22:38:17 +02001981
1982 echo [1,
1983 2] [3,
1984 4]
Bram Moolenaar93be1642020-10-11 21:34:41 +02001985
1986 echo [1, # comment
1987 # comment
1988 2] [3,
1989 # comment
1990 4]
Bram Moolenaar71478202020-06-26 22:46:27 +02001991 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001992 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar71478202020-06-26 22:46:27 +02001993
1994 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02001995 var l = [11,
Bram Moolenaar71478202020-06-26 22:46:27 +02001996 22]
1997 assert_equal([11, 22], l)
1998 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00001999 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002000
2001 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002002 var l = [11,22]
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002003 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002004 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002005
2006 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002007 var l = [11 , 22]
Bram Moolenaardb199212020-08-12 18:01:53 +02002008 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002009 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002010
2011 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002012 var l: list<number> = [234, 'x']
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002013 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002014 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002015
2016 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002017 var l: list<number> = ['x', 234]
2018 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002019 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002020
2021 lines =<< trim END
2022 var l: list<string> = ['x', 234]
2023 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002024 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002025
2026 lines =<< trim END
2027 var l: list<string> = [234, 'x']
2028 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002029 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002030
2031 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002032 def Failing()
2033 job_stop()
2034 enddef
2035 var list = [Failing]
2036 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002037 if has('channel')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002038 v9.CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002039 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00002040 v9.CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002041 endif
Bram Moolenaar71478202020-06-26 22:46:27 +02002042enddef
2043
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002044def LambdaWithComments(): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002045 return (x) =>
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002046 # some comment
2047 x == 1
2048 # some comment
2049 ||
2050 x == 2
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002051enddef
2052
Bram Moolenaarfd777482020-08-12 19:42:01 +02002053def LambdaUsingArg(x: number): func
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002054 return () =>
Bram Moolenaarfd777482020-08-12 19:42:01 +02002055 # some comment
2056 x == 1
2057 # some comment
2058 ||
2059 x == 2
Bram Moolenaarfd777482020-08-12 19:42:01 +02002060enddef
2061
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002062def Test_expr8_lambda()
Bram Moolenaar659bb222020-11-12 20:16:39 +01002063 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002064 var La = () => 'result'
Bram Moolenaar03717bf2021-04-28 20:00:40 +02002065 # comment
Bram Moolenaar659bb222020-11-12 20:16:39 +01002066 assert_equal('result', La())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002067 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
Bram Moolenaar914e7ea2020-07-11 15:20:48 +02002068
Bram Moolenaar659bb222020-11-12 20:16:39 +01002069 # line continuation inside lambda with "cond ? expr : expr" works
2070 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002071 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002072 ['111']: 111 } : {}
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002073 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002074 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002075
Bram Moolenaar03717bf2021-04-28 20:00:40 +02002076 # comment halfway an expression
2077 var Ref = () => 4
2078 # comment
2079 + 6
2080 assert_equal(10, Ref())
2081
Bram Moolenaar659bb222020-11-12 20:16:39 +01002082 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002083 map(ll, (k, v) => v == 8 || v
Bram Moolenaar659bb222020-11-12 20:16:39 +01002084 == 9
2085 || v % 2 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002086 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01002087 assert_equal([222, 111, 222], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002088
Bram Moolenaar659bb222020-11-12 20:16:39 +01002089 ll = range(3)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002090 map(ll, (k, v) => v != 8 && v
Bram Moolenaar659bb222020-11-12 20:16:39 +01002091 != 9
2092 && v % 2 == 0 ? 111 : 222
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002093 )
Bram Moolenaar659bb222020-11-12 20:16:39 +01002094 assert_equal([111, 222, 111], ll)
Bram Moolenaar8af81d62020-07-12 16:32:19 +02002095
Bram Moolenaar18024052021-12-25 21:43:28 +00002096 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => !!v['key'] )
Bram Moolenaare0de1712020-12-02 17:36:54 +01002097 assert_equal([{key: 22}], dl)
Bram Moolenaar6802cce2020-07-19 15:49:49 +02002098
Bram Moolenaare0de1712020-12-02 17:36:54 +01002099 dl = [{key: 12}, {['foo']: 34}]
2100 assert_equal([{key: 12}], filter(dl,
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002101 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
Bram Moolenaar7892b952020-07-20 22:09:34 +02002102
Bram Moolenaar62aec932022-01-29 21:45:34 +00002103 assert_equal(false, g:LambdaWithComments()(0))
2104 assert_equal(true, g:LambdaWithComments()(1))
2105 assert_equal(true, g:LambdaWithComments()(2))
2106 assert_equal(false, g:LambdaWithComments()(3))
Bram Moolenaarba60cc42020-08-12 19:15:33 +02002107
Bram Moolenaar62aec932022-01-29 21:45:34 +00002108 assert_equal(false, g:LambdaUsingArg(0)())
2109 assert_equal(true, g:LambdaUsingArg(1)())
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01002110
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002111 var res = map([1, 2, 3], (i: number, v: number) => i + v)
Bram Moolenaarc2ca9352020-11-25 21:30:11 +01002112 assert_equal([1, 3, 5], res)
Bram Moolenaar659bb222020-11-12 20:16:39 +01002113 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002114 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfd777482020-08-12 19:42:01 +02002115
Bram Moolenaar62aec932022-01-29 21:45:34 +00002116 v9.CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2117 v9.CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004: White space required before and after ''=>'' at "=> a + 1"')
2118 v9.CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"], 'E1004:')
2119 v9.CheckDefAndScriptFailure(["var Ref = (a) =< a + 1"], ['E1001:', 'E121:'])
2120 v9.CheckDefAndScriptFailure(["var Ref = (a: int) => a + 1"], 'E1010:')
2121 v9.CheckDefAndScriptFailure(["var Ref = (a): int => a + 1"], 'E1010:')
Bram Moolenaar27bf7af2020-12-23 20:27:31 +01002122
Bram Moolenaar62aec932022-01-29 21:45:34 +00002123 v9.CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar3affe7a2020-08-18 20:34:13 +02002124 # error is in first line of the lambda
Bram Moolenaar62aec932022-01-29 21:45:34 +00002125 v9.CheckDefAndScriptFailure(["var L = (a) => a + b"], 'E1001:', 0)
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002126
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002127 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar79e8db92020-08-14 22:16:33 +02002128
Bram Moolenaar62aec932022-01-29 21:45:34 +00002129 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"], 'E118:')
2130 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"], 'E118:')
2131 v9.CheckDefAndScriptFailure(["echo 'asdf'->((a) => a)(x)"], ['E1001:', 'E121:'], 1)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002132
Bram Moolenaar62aec932022-01-29 21:45:34 +00002133 v9.CheckDefAndScriptSuccess(['var Fx = (a) => ({k1: 0,', ' k2: 1})'])
2134 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2135 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaara2c026d2020-10-18 18:03:17 +02002136
Bram Moolenaar62aec932022-01-29 21:45:34 +00002137 v9.CheckDefAndScriptSuccess(['var Fx = (a) => [0,', ' 1]'])
2138 v9.CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002139
2140 # no error for existing script variable when checking for lambda
2141 lines =<< trim END
Bram Moolenaarbc327cc2021-02-23 12:05:46 +01002142 var name = 0
2143 eval (name + 2) / 3
2144 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002145 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002146enddef
2147
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002148def Test_expr8_lambda_block()
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002149 var lines =<< trim END
2150 var Func = (s: string): string => {
2151 return 'hello ' .. s
2152 }
2153 assert_equal('hello there', Func('there'))
2154
2155 var ll = range(3)
2156 var dll = mapnew(ll, (k, v): string => {
2157 if v % 2
2158 return 'yes'
2159 endif
2160 return 'no'
2161 })
2162 assert_equal(['no', 'yes', 'no'], dll)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002163
Bram Moolenaarac2cd2b2021-07-19 21:04:23 +02002164 # ignored_inline(0, (_) => {
2165 # echo 'body'
2166 # })
2167
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002168 sandbox var Safe = (nr: number): number => {
2169 return nr + 7
2170 }
2171 assert_equal(10, Safe(3))
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002172 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002173 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare98f60a2021-03-22 18:22:30 +01002174
2175 lines =<< trim END
2176 map([1, 2], (k, v) => { redrawt })
2177 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002178 v9.CheckDefAndScriptFailure(lines, 'E488')
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002179
2180 lines =<< trim END
2181 var Func = (nr: int) => {
2182 echo nr
2183 }
2184 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002185 v9.CheckDefAndScriptFailure(lines, 'E1010', 1)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002186
2187 lines =<< trim END
2188 var Func = (nr: number): int => {
2189 return nr
2190 }
2191 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002192 v9.CheckDefAndScriptFailure(lines, 'E1010', 1)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002193
2194 lines =<< trim END
2195 var Func = (nr: number): int => {
2196 return nr
2197 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002198 v9.CheckDefFailure(lines, 'E1171', 0) # line nr is function start
2199 v9.CheckScriptFailure(['vim9script'] + lines, 'E1171', 2)
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002200
2201 lines =<< trim END
Bram Moolenaar49f1e9e2021-03-22 20:49:02 +01002202 var Func = (nr: number): int => {
2203 var ll =<< ENDIT
2204 nothing
2205 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002206 v9.CheckDefFailure(lines, 'E1145: Missing heredoc end marker: ENDIT', 0)
2207 v9.CheckScriptFailure(['vim9script'] + lines, 'E1145: Missing heredoc end marker: ENDIT', 2)
Bram Moolenaar7a6eaa02021-03-21 20:53:29 +01002208enddef
2209
Bram Moolenaar65c44152020-12-24 15:14:01 +01002210def NewLambdaWithComments(): func
2211 return (x) =>
2212 # some comment
2213 x == 1
2214 # some comment
2215 ||
2216 x == 2
2217enddef
2218
2219def NewLambdaUsingArg(x: number): func
2220 return () =>
2221 # some comment
2222 x == 1
2223 # some comment
2224 ||
2225 x == 2
2226enddef
2227
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002228def Test_expr8_new_lambda()
Bram Moolenaar65c44152020-12-24 15:14:01 +01002229 var lines =<< trim END
2230 var La = () => 'result'
2231 assert_equal('result', La())
2232 assert_equal([1, 3, 5], [1, 2, 3]->map((key, val) => key + val))
2233
2234 # line continuation inside lambda with "cond ? expr : expr" works
2235 var ll = range(3)
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002236 var dll = mapnew(ll, (k, v) => v % 2 ? {
Bram Moolenaar65c44152020-12-24 15:14:01 +01002237 ['111']: 111 } : {}
2238 )
Bram Moolenaar75ab91f2021-01-10 22:42:50 +01002239 assert_equal([{}, {111: 111}, {}], dll)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002240
2241 ll = range(3)
2242 map(ll, (k, v) => v == 8 || v
2243 == 9
2244 || v % 2 ? 111 : 222
2245 )
2246 assert_equal([222, 111, 222], ll)
2247
2248 ll = range(3)
2249 map(ll, (k, v) => v != 8 && v
2250 != 9
2251 && v % 2 == 0 ? 111 : 222
2252 )
2253 assert_equal([111, 222, 111], ll)
2254
Bram Moolenaar18024052021-12-25 21:43:28 +00002255 var dl = [{key: 0}, {key: 22}]->filter(( _, v) => !!v['key'] )
Bram Moolenaar65c44152020-12-24 15:14:01 +01002256 assert_equal([{key: 22}], dl)
2257
2258 dl = [{key: 12}, {['foo']: 34}]
2259 assert_equal([{key: 12}], filter(dl,
2260 (_, v) => has_key(v, 'key') ? v['key'] == 12 : 0))
2261
Bram Moolenaar62aec932022-01-29 21:45:34 +00002262 assert_equal(false, g:NewLambdaWithComments()(0))
2263 assert_equal(true, g:NewLambdaWithComments()(1))
2264 assert_equal(true, g:NewLambdaWithComments()(2))
2265 assert_equal(false, g:NewLambdaWithComments()(3))
Bram Moolenaar65c44152020-12-24 15:14:01 +01002266
Bram Moolenaar62aec932022-01-29 21:45:34 +00002267 assert_equal(false, g:NewLambdaUsingArg(0)())
2268 assert_equal(true, g:NewLambdaUsingArg(1)())
Bram Moolenaar65c44152020-12-24 15:14:01 +01002269
2270 var res = map([1, 2, 3], (i: number, v: number) => i + v)
2271 assert_equal([1, 3, 5], res)
2272
2273 # Lambda returning a dict
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002274 var Lmb = () => ({key: 42})
Bram Moolenaar65c44152020-12-24 15:14:01 +01002275 assert_equal({key: 42}, Lmb())
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002276
2277 var RefOne: func(number): string = (a: number): string => 'x'
2278 var RefTwo: func(number): any = (a: number): any => 'x'
2279
2280 var Fx = (a) => ({k1: 0,
2281 k2: 1})
2282 var Fy = (a) => [0,
2283 1]
Bram Moolenaar65c44152020-12-24 15:14:01 +01002284 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002285 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002286
Bram Moolenaar62aec932022-01-29 21:45:34 +00002287 v9.CheckDefAndScriptFailure(["var Ref = (a)=>a + 1"], 'E1004:')
2288 v9.CheckDefAndScriptFailure(["var Ref = (a)=> a + 1"], 'E1004:')
2289 v9.CheckDefAndScriptFailure(["var Ref = (a) =>a + 1"],
Bram Moolenaare7a73e02021-01-01 19:17:55 +01002290 'E1004: White space required before and after ''=>'' at " =>a + 1"')
Bram Moolenaarc754b4c2020-12-25 15:24:23 +01002291
Bram Moolenaar62aec932022-01-29 21:45:34 +00002292 v9.CheckDefAndScriptFailure(["var Ref: func(number): number = (a: number): string => 'x'"], 'E1012:')
2293 v9.CheckDefAndScriptFailure(["var Ref: func(number): string = (a: number): string => 99"], 'E1012:')
Bram Moolenaar9e68c322020-12-25 12:38:04 +01002294
Bram Moolenaar62aec932022-01-29 21:45:34 +00002295 v9.CheckDefAndScriptFailure(["filter([1, 2], (k,v) => 1)"], 'E1069:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002296 # error is in first line of the lambda
Bram Moolenaar62aec932022-01-29 21:45:34 +00002297 v9.CheckDefAndScriptFailure(["var L = (a) -> a + b"], ['E1001:', 'E121:'], 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002298
Bram Moolenaar90193e62021-04-04 20:49:50 +02002299 assert_equal('xxxyyy', 'xxx'->((a, b) => a .. b)('yyy'))
Bram Moolenaar65c44152020-12-24 15:14:01 +01002300
Bram Moolenaar62aec932022-01-29 21:45:34 +00002301 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x')"],
Bram Moolenaar90193e62021-04-04 20:49:50 +02002302 'E118: Too many arguments for function:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002303 v9.CheckDefExecFailure(["var s = 'asdf'->((a) => a)('x', 'y')"],
Bram Moolenaar90193e62021-04-04 20:49:50 +02002304 'E118: Too many arguments for function:')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002305 v9.CheckDefFailure(["echo 'asdf'->((a) => a)(x)"], 'E1001:', 1)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002306
Bram Moolenaar62aec932022-01-29 21:45:34 +00002307 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0', ' k2: 1})'], 'E722:', 2)
2308 v9.CheckDefAndScriptFailure(['var Fx = (a) => ({k1: 0,', ' k2 1})'], 'E720:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002309
Bram Moolenaar62aec932022-01-29 21:45:34 +00002310 v9.CheckDefAndScriptFailure(['var Fx = (a) => [0', ' 1]'], 'E696:', 2)
Bram Moolenaar65c44152020-12-24 15:14:01 +01002311enddef
2312
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002313def Test_expr8_lambda_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002314 var lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002315 var v = 10->((a) =>
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002316 a
2317 + 2
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002318 )()
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002319 assert_equal(12, v)
2320 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002321 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002322
2323 # nested lambda with line breaks
2324 lines =<< trim END
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002325 search('"', 'cW', 0, 0, () =>
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002326 synstack('.', col('.'))
Bram Moolenaar18024052021-12-25 21:43:28 +00002327 ->mapnew((_, v) => synIDattr(v, 'name'))->len())
Bram Moolenaaraeb2bdd2020-08-18 22:32:03 +02002328 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002329 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare40fbc22020-06-27 18:06:45 +02002330enddef
2331
Bram Moolenaara749a422022-02-12 19:52:25 +00002332def Test_expr8funcref()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002333 var lines =<< trim END
Bram Moolenaar659bb222020-11-12 20:16:39 +01002334 def RetNumber(): number
2335 return 123
2336 enddef
2337 var FuncRef = RetNumber
2338 assert_equal(123, FuncRef())
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002339 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002340 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfa596382021-04-07 21:58:16 +02002341
2342 lines =<< trim END
2343 vim9script
2344 func g:GlobalFunc()
2345 return 'global'
2346 endfunc
Bram Moolenaara749a422022-02-12 19:52:25 +00002347 func ScriptFunc()
Bram Moolenaarfa596382021-04-07 21:58:16 +02002348 return 'script'
2349 endfunc
2350 def Test()
2351 var Ref = g:GlobalFunc
2352 assert_equal('global', Ref())
Bram Moolenaar848fadd2022-01-30 15:28:30 +00002353 Ref = g:GlobalFunc
Bram Moolenaarfa596382021-04-07 21:58:16 +02002354 assert_equal('global', Ref())
2355
Bram Moolenaara749a422022-02-12 19:52:25 +00002356 Ref = ScriptFunc
Bram Moolenaarfa596382021-04-07 21:58:16 +02002357 assert_equal('script', Ref())
2358 Ref = ScriptFunc
2359 assert_equal('script', Ref())
2360 enddef
2361 Test()
2362 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002363 v9.CheckScriptSuccess(lines)
Bram Moolenaar601e76a2020-08-27 21:33:10 +02002364enddef
2365
Bram Moolenaar2bede172020-11-19 18:53:18 +01002366let g:test_space_dict = {'': 'empty', ' ': 'space'}
2367let g:test_hash_dict = #{one: 1, two: 2}
2368
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002369def Test_expr8_dict()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002370 # dictionary
Bram Moolenaar659bb222020-11-12 20:16:39 +01002371 var lines =<< trim END
2372 assert_equal(g:dict_empty, {})
2373 assert_equal(g:dict_empty, { })
Bram Moolenaare0de1712020-12-02 17:36:54 +01002374 assert_equal(g:dict_one, {['one']: 1})
Bram Moolenaar659bb222020-11-12 20:16:39 +01002375 var key = 'one'
2376 var val = 1
Bram Moolenaar2bede172020-11-19 18:53:18 +01002377 assert_equal(g:dict_one, {[key]: val})
Bram Moolenaar0062c2d2020-02-20 22:14:31 +01002378
Bram Moolenaar2bede172020-11-19 18:53:18 +01002379 var numbers: dict<number> = {a: 1, b: 2, c: 3}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002380 numbers = {a: 1}
2381 numbers = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002382
Bram Moolenaar2bede172020-11-19 18:53:18 +01002383 var strings: dict<string> = {a: 'a', b: 'b', c: 'c'}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002384 strings = {a: 'x'}
2385 strings = {}
2386
2387 var dash = {xx-x: 8}
2388 assert_equal({['xx-x']: 8}, dash)
2389
2390 var dnr = {8: 8}
2391 assert_equal({['8']: 8}, dnr)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002392
Bram Moolenaar2bede172020-11-19 18:53:18 +01002393 var mixed: dict<any> = {a: 'a', b: 42}
Bram Moolenaare0de1712020-12-02 17:36:54 +01002394 mixed = {a: 'x'}
2395 mixed = {a: 234}
2396 mixed = {}
Bram Moolenaar127542b2020-08-09 17:22:04 +02002397
Bram Moolenaare0de1712020-12-02 17:36:54 +01002398 var dictlist: dict<list<string>> = {absent: [], present: ['hi']}
2399 dictlist = {absent: ['hi'], present: []}
2400 dictlist = {absent: [], present: []}
Bram Moolenaar77b20972020-09-19 14:12:34 +02002401
Bram Moolenaare0de1712020-12-02 17:36:54 +01002402 var dictdict: dict<dict<string>> = {one: {a: 'text'}, two: {}}
2403 dictdict = {one: {}, two: {a: 'text'}}
2404 dictdict = {one: {}, two: {}}
Bram Moolenaarc7f7f6d2020-11-04 13:38:28 +01002405
Bram Moolenaare0de1712020-12-02 17:36:54 +01002406 assert_equal({['']: 0}, {[matchstr('string', 'wont match')]: 0})
Bram Moolenaar2bede172020-11-19 18:53:18 +01002407
2408 assert_equal(g:test_space_dict, {['']: 'empty', [' ']: 'space'})
2409 assert_equal(g:test_hash_dict, {one: 1, two: 2})
Bram Moolenaarc5e6a712020-12-04 19:12:14 +01002410
2411 assert_equal({['a a']: 1, ['b/c']: 2}, {'a a': 1, "b/c": 2})
Bram Moolenaar6b553772020-12-31 13:31:23 +01002412
2413 var d = {a: () => 3, b: () => 7}
2414 assert_equal(3, d.a())
2415 assert_equal(7, d.b())
Bram Moolenaar5afd0812021-01-03 18:33:13 +01002416
2417 var cd = { # comment
2418 key: 'val' # comment
2419 }
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002420
2421 # different types used for the key
2422 var dkeys = {['key']: 'string',
2423 [12]: 'numberexpr',
2424 34: 'number',
2425 [true]: 'bool'}
2426 assert_equal('string', dkeys['key'])
2427 assert_equal('numberexpr', dkeys[12])
2428 assert_equal('number', dkeys[34])
2429 assert_equal('bool', dkeys[true])
2430 if has('float')
2431 dkeys = {[1.2]: 'floatexpr', [3.4]: 'float'}
2432 assert_equal('floatexpr', dkeys[1.2])
2433 assert_equal('float', dkeys[3.4])
2434 endif
2435
2436 # automatic conversion from number to string
2437 var n = 123
2438 var dictnr = {[n]: 1}
Bram Moolenaara0399ef2021-03-20 15:00:01 +01002439
2440 # comment to start fold is OK
2441 var x1: number #{{ fold
2442 var x2 = 9 #{{ fold
Bram Moolenaar659bb222020-11-12 20:16:39 +01002443 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002444 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar77b20972020-09-19 14:12:34 +02002445
Bram Moolenaare0de1712020-12-02 17:36:54 +01002446 # legacy syntax doesn't work
Bram Moolenaar62aec932022-01-29 21:45:34 +00002447 v9.CheckDefAndScriptFailure(["var x = #{key: 8}"], 'E1170:', 1)
2448 v9.CheckDefAndScriptFailure(["var x = 'a' #{a: 1}"], 'E1170:', 1)
2449 v9.CheckDefAndScriptFailure(["var x = 'a' .. #{a: 1}"], 'E1170:', 1)
2450 v9.CheckDefAndScriptFailure(["var x = true ? #{a: 1}"], 'E1170:', 1)
Bram Moolenaar17a836c2020-08-12 17:35:58 +02002451
Bram Moolenaar62aec932022-01-29 21:45:34 +00002452 v9.CheckDefAndScriptFailure(["var x = {a:8}"], 'E1069:', 1)
2453 v9.CheckDefAndScriptFailure(["var x = {a : 8}"], 'E1068:', 1)
2454 v9.CheckDefAndScriptFailure(["var x = {a :8}"], 'E1068:', 1)
2455 v9.CheckDefAndScriptFailure(["var x = {a: 8 , b: 9}"], 'E1068:', 1)
2456 v9.CheckDefAndScriptFailure(["var x = {a: 1,b: 2}"], 'E1069:', 1)
Bram Moolenaare0de1712020-12-02 17:36:54 +01002457
Bram Moolenaar62aec932022-01-29 21:45:34 +00002458 v9.CheckDefAndScriptFailure(["var x = {xxx}"], 'E720:', 1)
2459 v9.CheckDefAndScriptFailure(["var x = {xxx: 1", "var y = 2"], 'E722:', 2)
2460 v9.CheckDefFailure(["var x = {xxx: 1,"], 'E723:', 2)
2461 v9.CheckScriptFailure(['vim9script', "var x = {xxx: 1,"], 'E723:', 2)
2462 v9.CheckDefAndScriptFailure(["var x = {['a']: xxx}"], ['E1001:', 'E121:'], 1)
2463 v9.CheckDefAndScriptFailure(["var x = {a: 1, a: 2}"], 'E721:', 1)
2464 v9.CheckDefExecAndScriptFailure(["var x = g:anint.member"], ['E715:', 'E488:'], 1)
2465 v9.CheckDefExecAndScriptFailure(["var x = g:dict_empty.member"], 'E716:', 1)
Bram Moolenaar127542b2020-08-09 17:22:04 +02002466
Bram Moolenaar62aec932022-01-29 21:45:34 +00002467 v9.CheckDefExecAndScriptFailure(['var x: dict<number> = {a: 234, b: "1"}'], 'E1012:', 1)
2468 v9.CheckDefExecAndScriptFailure(['var x: dict<number> = {a: "x", b: 134}'], 'E1012:', 1)
2469 v9.CheckDefExecAndScriptFailure(['var x: dict<string> = {a: 234, b: "1"}'], 'E1012:', 1)
2470 v9.CheckDefExecAndScriptFailure(['var x: dict<string> = {a: "x", b: 134}'], 'E1012:', 1)
Bram Moolenaar44aefff2020-10-05 19:23:59 +02002471
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002472 # invalid types for the key
Bram Moolenaar62aec932022-01-29 21:45:34 +00002473 v9.CheckDefAndScriptFailure(["var x = {[[1, 2]]: 0}"], ['E1105:', 'E730:'], 1)
Bram Moolenaar2e5910b2021-02-03 17:41:24 +01002474
Bram Moolenaar62aec932022-01-29 21:45:34 +00002475 v9.CheckDefFailure(['var x = ({'], 'E723:', 2)
2476 v9.CheckScriptFailure(['vim9script', 'var x = ({'], 'E723:', 2)
2477 v9.CheckDefExecAndScriptFailure(['{}[getftype("file")]'], 'E716: Key not present in Dictionary: ""', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002478enddef
2479
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002480def Test_expr8_dict_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002481 var lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002482 var d = {
Bram Moolenaare0de1712020-12-02 17:36:54 +01002483 ['one']:
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002484 1,
Bram Moolenaare0de1712020-12-02 17:36:54 +01002485 ['two']: 2,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002486 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002487 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar93be1642020-10-11 21:34:41 +02002488
2489 d = { # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002490 ['one']:
Bram Moolenaar93be1642020-10-11 21:34:41 +02002491 # comment
2492
2493 1,
2494 # comment
2495 # comment
Bram Moolenaare0de1712020-12-02 17:36:54 +01002496 ['two']: 2,
Bram Moolenaar93be1642020-10-11 21:34:41 +02002497 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002498 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01002499
2500 var dd = {k: 123->len()}
2501 assert_equal(3, dd.k)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002502 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002503 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002504
2505 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002506 var d = { ["one"]: "one", ["two"]: "two", }
2507 assert_equal({one: 'one', two: 'two'}, d)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002508 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002509 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaare6b53242020-07-01 17:28:33 +02002510
2511 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002512 var d = {one: 1,
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002513 two: 2,
2514 }
Bram Moolenaare0de1712020-12-02 17:36:54 +01002515 assert_equal({one: 1, two: 2}, d)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002516 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002517 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002518
2519 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002520 var d = {one:1, two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002521 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002522 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002523
2524 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002525 var d = {one: 1,two: 2}
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002526 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002527 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002528
2529 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002530 var d = {one : 1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002531 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002532 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaardb199212020-08-12 18:01:53 +02002533
2534 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002535 var d = {one:1}
Bram Moolenaardb199212020-08-12 18:01:53 +02002536 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002537 v9.CheckDefAndScriptFailure(lines, 'E1069:', 1)
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002538
2539 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002540 var d = {one: 1 , two: 2}
Bram Moolenaarc3d6e8a2020-08-12 18:34:28 +02002541 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002542 v9.CheckDefAndScriptFailure(lines, 'E1068:', 1)
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002543
2544 lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002545 var l: dict<number> = {a: 234, b: 'x'}
Bram Moolenaar41fab3e2020-08-14 21:27:37 +02002546 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002547 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002548
2549 lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02002550 var l: dict<number> = {a: 'x', b: 234}
2551 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002552 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002553
2554 lines =<< trim END
2555 var l: dict<string> = {a: 'x', b: 234}
2556 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002557 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002558
2559 lines =<< trim END
2560 var l: dict<string> = {a: 234, b: 'x'}
2561 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002562 v9.CheckDefAndScriptFailure(lines, 'E1012:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002563
2564 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002565 var d = {['a']: 234, ['b': 'x'}
2566 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002567 v9.CheckDefAndScriptFailure(lines, 'E1139:', 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002568
Bram Moolenaar918a4242020-12-06 14:37:08 +01002569 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002570 def Func()
2571 var d = {['a']: 234, ['b': 'x'}
2572 enddef
2573 defcompile
2574 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002575 v9.CheckDefAndScriptFailure(lines, 'E1139:', 0)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002576
Bram Moolenaar918a4242020-12-06 14:37:08 +01002577 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002578 var d = {'a':
2579 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002580 v9.CheckDefFailure(lines, 'E723:', 2)
2581 v9.CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002582
Bram Moolenaar918a4242020-12-06 14:37:08 +01002583 lines =<< trim END
Bram Moolenaar918a4242020-12-06 14:37:08 +01002584 def Func()
2585 var d = {'a':
2586 enddef
2587 defcompile
2588 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002589 v9.CheckDefAndScriptFailure(lines, 'E723:', 0)
Bram Moolenaar918a4242020-12-06 14:37:08 +01002590
2591 lines =<< trim END
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002592 def Failing()
2593 job_stop()
2594 enddef
Bram Moolenaare0de1712020-12-02 17:36:54 +01002595 var dict = {name: Failing}
Bram Moolenaar9c13f762020-11-04 12:00:53 +01002596 END
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002597 if has('channel')
Bram Moolenaar62aec932022-01-29 21:45:34 +00002598 v9.CheckDefAndScriptFailure(lines, 'E119:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002599 else
Bram Moolenaar62aec932022-01-29 21:45:34 +00002600 v9.CheckDefAndScriptFailure(lines, 'E117:', 0)
Bram Moolenaar46f479c2020-11-07 13:09:18 +01002601 endif
Bram Moolenaar11005b02021-07-11 20:59:00 +02002602
2603 lines =<< trim END
2604 vim9script
2605 var x = 99
2606 assert_equal({x: 99}, s:)
2607 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002608 v9.CheckScriptSuccess(lines)
Bram Moolenaar8ea93902020-06-27 14:11:53 +02002609enddef
2610
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002611def Test_expr8_dict_in_block()
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002612 var lines =<< trim END
2613 vim9script
2614 command MyCommand {
2615 echo {
2616 k: 0, }
2617 }
2618 MyCommand
Bram Moolenaar259f4432021-12-17 12:45:22 +00002619
2620 command YourCommand {
2621 g:global = {
2622 key: 'value' }
2623 }
2624 YourCommand
2625 assert_equal({key: 'value'}, g:global)
2626 unlet g:global
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002627 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002628 v9.CheckScriptSuccess(lines)
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002629
2630 delcommand MyCommand
Bram Moolenaar259f4432021-12-17 12:45:22 +00002631 delcommand YourCommand
Bram Moolenaarce7eada2021-12-15 15:41:44 +00002632enddef
2633
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002634def Test_expr8_call_2bool()
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002635 var lines =<< trim END
2636 vim9script
2637
2638 def BrokenCall(nr: number, mode: bool, use: string): void
2639 assert_equal(3, nr)
2640 assert_equal(false, mode)
2641 assert_equal('ab', use)
2642 enddef
2643
2644 def TestBrokenCall(): void
2645 BrokenCall(3, 0, 'ab')
2646 enddef
2647
2648 TestBrokenCall()
2649 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002650 v9.CheckScriptSuccess(lines)
Bram Moolenaar5fa9b242021-06-04 21:00:32 +02002651enddef
2652
Bram Moolenaar50788ef2020-07-05 16:51:26 +02002653let g:oneString = 'one'
2654
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002655def Test_expr_member()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002656 var lines =<< trim END
2657 assert_equal(1, g:dict_one.one)
2658 var d: dict<number> = g:dict_one
2659 assert_equal(1, d['one'])
2660 assert_equal(1, d[
2661 'one'
2662 ])
2663 assert_equal(1, d
2664 .one)
2665 d = {1: 1, _: 2}
2666 assert_equal(1, d
2667 .1)
2668 assert_equal(2, d
2669 ._)
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02002670
Bram Moolenaar90193e62021-04-04 20:49:50 +02002671 # getting the one member should clear the dict after getting the item
2672 assert_equal('one', {one: 'one'}.one)
2673 assert_equal('one', {one: 'one'}[g:oneString])
2674 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002675 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarfb9d5c52020-07-04 19:19:43 +02002676
Bram Moolenaar62aec932022-01-29 21:45:34 +00002677 v9.CheckDefAndScriptFailure(["var x = g:dict_one.#$!"], ['E1002:', 'E15:'], 1)
2678 v9.CheckDefExecAndScriptFailure(["var d: dict<any>", "echo d['a']"], 'E716:', 2)
2679 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 +02002680enddef
2681
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002682def Test_expr8_any_index_slice()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002683 var lines =<< trim END
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002684 # getting the one member should clear the list only after getting the item
2685 assert_equal('bbb', ['aaa', 'bbb', 'ccc'][1])
2686
2687 # string is permissive, index out of range accepted
2688 g:teststring = 'abcdef'
2689 assert_equal('b', g:teststring[1])
Bram Moolenaare7525c52021-01-09 13:20:37 +01002690 assert_equal('f', g:teststring[-1])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002691 assert_equal('', g:teststring[99])
2692
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002693 assert_equal('b', g:teststring[1 : 1])
2694 assert_equal('bcdef', g:teststring[1 :])
2695 assert_equal('abcd', g:teststring[: 3])
2696 assert_equal('cdef', g:teststring[-4 :])
2697 assert_equal('abcdef', g:teststring[-9 :])
2698 assert_equal('abcd', g:teststring[: -3])
2699 assert_equal('', g:teststring[: -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002700
Bram Moolenaar0289a092021-03-14 18:40:19 +01002701 # composing characters are included
2702 g:teststring = 'àéû'
2703 assert_equal('à', g:teststring[0])
2704 assert_equal('é', g:teststring[1])
2705 assert_equal('û', g:teststring[2])
2706 assert_equal('', g:teststring[3])
2707 assert_equal('', g:teststring[4])
2708
2709 assert_equal('û', g:teststring[-1])
2710 assert_equal('é', g:teststring[-2])
2711 assert_equal('à', g:teststring[-3])
2712 assert_equal('', g:teststring[-4])
2713 assert_equal('', g:teststring[-5])
2714
2715 assert_equal('à', g:teststring[0 : 0])
2716 assert_equal('é', g:teststring[1 : 1])
2717 assert_equal('àé', g:teststring[0 : 1])
2718 assert_equal('àéû', g:teststring[0 : -1])
2719 assert_equal('àé', g:teststring[0 : -2])
2720 assert_equal('à', g:teststring[0 : -3])
2721 assert_equal('', g:teststring[0 : -4])
2722 assert_equal('', g:teststring[0 : -5])
2723 assert_equal('àéû', g:teststring[ : ])
2724 assert_equal('àéû', g:teststring[0 : ])
2725 assert_equal('éû', g:teststring[1 : ])
2726 assert_equal('û', g:teststring[2 : ])
2727 assert_equal('', g:teststring[3 : ])
2728 assert_equal('', g:teststring[4 : ])
2729
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002730 # blob index cannot be out of range
2731 g:testblob = 0z01ab
2732 assert_equal(0x01, g:testblob[0])
2733 assert_equal(0xab, g:testblob[1])
2734 assert_equal(0xab, g:testblob[-1])
2735 assert_equal(0x01, g:testblob[-2])
2736
2737 # blob slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002738 assert_equal(0z01ab, g:testblob[0 : 1])
2739 assert_equal(0z01, g:testblob[0 : 0])
2740 assert_equal(0z01, g:testblob[-2 : -2])
2741 assert_equal(0zab, g:testblob[1 : 1])
2742 assert_equal(0zab, g:testblob[-1 : -1])
2743 assert_equal(0z, g:testblob[2 : 2])
2744 assert_equal(0z, g:testblob[0 : -3])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002745
2746 # list index cannot be out of range
2747 g:testlist = [0, 1, 2, 3]
2748 assert_equal(0, g:testlist[0])
2749 assert_equal(1, g:testlist[1])
2750 assert_equal(3, g:testlist[3])
2751 assert_equal(3, g:testlist[-1])
2752 assert_equal(0, g:testlist[-4])
2753 assert_equal(1, g:testlist[g:theone])
2754
2755 # list slice accepts out of range
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01002756 assert_equal([0], g:testlist[0 : 0])
2757 assert_equal([3], g:testlist[3 : 3])
2758 assert_equal([0, 1], g:testlist[0 : 1])
2759 assert_equal([0, 1, 2, 3], g:testlist[0 : 3])
2760 assert_equal([0, 1, 2, 3], g:testlist[0 : 9])
2761 assert_equal([], g:testlist[-1 : 1])
2762 assert_equal([1], g:testlist[-3 : 1])
2763 assert_equal([0, 1], g:testlist[-4 : 1])
2764 assert_equal([0, 1], g:testlist[-9 : 1])
2765 assert_equal([1, 2, 3], g:testlist[1 : -1])
2766 assert_equal([1], g:testlist[1 : -3])
2767 assert_equal([], g:testlist[1 : -4])
2768 assert_equal([], g:testlist[1 : -9])
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002769
Bram Moolenaare0de1712020-12-02 17:36:54 +01002770 g:testdict = {a: 1, b: 2}
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002771 assert_equal(1, g:testdict['a'])
2772 assert_equal(2, g:testdict['b'])
2773 END
2774
Bram Moolenaar62aec932022-01-29 21:45:34 +00002775 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002776
Bram Moolenaar62aec932022-01-29 21:45:34 +00002777 v9.CheckDefExecAndScriptFailure(['echo g:testblob[2]'], 'E979:', 1)
2778 v9.CheckDefExecAndScriptFailure(['echo g:testblob[-3]'], 'E979:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002779
Bram Moolenaar62aec932022-01-29 21:45:34 +00002780 v9.CheckDefExecAndScriptFailure(['echo g:testlist[4]'], 'E684: list index out of range: 4', 1)
2781 v9.CheckDefExecAndScriptFailure(['echo g:testlist[-5]'], 'E684:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002782
Bram Moolenaar62aec932022-01-29 21:45:34 +00002783 v9.CheckDefExecAndScriptFailure(['echo g:testdict["a" : "b"]'], 'E719:', 1)
2784 v9.CheckDefExecAndScriptFailure(['echo g:testdict[1]'], 'E716:', 1)
Bram Moolenaarcc673e72020-08-16 17:33:35 +02002785
2786 unlet g:teststring
2787 unlet g:testblob
2788 unlet g:testlist
Bram Moolenaar435d8972020-07-05 16:42:13 +02002789enddef
2790
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002791def Test_expr_member_vim9script()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002792 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01002793 var d = {one:
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002794 'one',
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002795 two: 'two',
2796 1: 1,
2797 _: 2}
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002798 assert_equal('one', d.one)
2799 assert_equal('one', d
2800 .one)
Bram Moolenaarb13ab992020-07-27 21:43:28 +02002801 assert_equal(1, d
2802 .1)
2803 assert_equal(2, d
2804 ._)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002805 assert_equal('one', d[
2806 'one'
2807 ])
2808 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002809 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002810
2811 lines =<< trim END
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002812 var l = [1,
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002813 2,
2814 3, 4
2815 ]
2816 assert_equal(2, l[
2817 1
2818 ])
2819 assert_equal([2, 3], l[1 : 2])
2820 assert_equal([1, 2, 3], l[
2821 :
2822 2
2823 ])
2824 assert_equal([3, 4], l[
2825 2
2826 :
2827 ])
2828 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002829 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar442af2f2020-07-03 21:09:52 +02002830enddef
2831
Bram Moolenaara79925a2021-01-05 17:50:28 +01002832def SetSomeVar()
2833 b:someVar = &fdm
2834enddef
2835
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002836def Test_expr8_option()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002837 var lines =<< trim END
2838 # option
2839 set ts=11
2840 assert_equal(11, &ts)
2841 &ts = 9
2842 assert_equal(9, &ts)
2843 set ts=8
2844 set grepprg=some\ text
2845 assert_equal('some text', &grepprg)
2846 &grepprg = test_null_string()
2847 assert_equal('', &grepprg)
2848 set grepprg&
Bram Moolenaard5ea8f02021-01-01 14:49:15 +01002849
Bram Moolenaar90193e62021-04-04 20:49:50 +02002850 # check matching type
2851 var bval: bool = &tgc
2852 var nval: number = &ts
2853 var sval: string = &path
Bram Moolenaara79925a2021-01-05 17:50:28 +01002854
Bram Moolenaar90193e62021-04-04 20:49:50 +02002855 # check v_lock is cleared (requires using valgrind, doesn't always show)
Bram Moolenaar62aec932022-01-29 21:45:34 +00002856 g:SetSomeVar()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002857 b:someVar = 0
2858 unlet b:someVar
2859 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002860 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002861enddef
2862
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002863def Test_expr8_environment()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002864 var lines =<< trim END
2865 # environment variable
2866 assert_equal('testvar', $TESTVAR)
2867 assert_equal('', $ASDF_ASD_XXX)
2868 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002869 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc58164c2020-03-29 18:40:30 +02002870
Bram Moolenaar62aec932022-01-29 21:45:34 +00002871 v9.CheckDefAndScriptFailure(["var x = $$$"], ['E1002:', 'E15:'], 1)
2872 v9.CheckDefAndScriptFailure(["$"], ['E1002:', 'E15:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002873enddef
2874
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002875def Test_expr8_register()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002876 var lines =<< trim END
2877 @a = 'register a'
2878 assert_equal('register a', @a)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002879
Bram Moolenaar90193e62021-04-04 20:49:50 +02002880 var fname = expand('%')
2881 assert_equal(fname, @%)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002882
Bram Moolenaar90193e62021-04-04 20:49:50 +02002883 feedkeys(":echo 'some'\<CR>", "xt")
2884 assert_equal("echo 'some'", @:)
Bram Moolenaar7226e5b2020-08-02 17:33:26 +02002885
Bram Moolenaar90193e62021-04-04 20:49:50 +02002886 normal axyz
2887 assert_equal("xyz", @.)
Bram Moolenaar65821722020-08-02 18:58:54 +02002888
Bram Moolenaar90193e62021-04-04 20:49:50 +02002889 @/ = 'slash'
2890 assert_equal('slash', @/)
Bram Moolenaar65821722020-08-02 18:58:54 +02002891
Bram Moolenaar90193e62021-04-04 20:49:50 +02002892 @= = 'equal'
2893 assert_equal('equal', @=)
2894 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002895 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02002896
Bram Moolenaar62aec932022-01-29 21:45:34 +00002897 v9.CheckDefAndScriptFailure(["@. = 'yes'"], ['E354:', 'E488:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002898enddef
2899
Bram Moolenaar886e5e72021-04-05 13:36:34 +02002900" This is slow when run under valgrind.
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002901def Test_expr8_namespace()
Bram Moolenaar90193e62021-04-04 20:49:50 +02002902 var lines =<< trim END
2903 g:some_var = 'some'
2904 assert_equal('some', get(g:, 'some_var'))
2905 assert_equal('some', get(g:, 'some_var', 'xxx'))
2906 assert_equal('xxx', get(g:, 'no_var', 'xxx'))
2907 unlet g:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002908
Bram Moolenaar90193e62021-04-04 20:49:50 +02002909 b:some_var = 'some'
2910 assert_equal('some', get(b:, 'some_var'))
2911 assert_equal('some', get(b:, 'some_var', 'xxx'))
2912 assert_equal('xxx', get(b:, 'no_var', 'xxx'))
2913 unlet b:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002914
Bram Moolenaar90193e62021-04-04 20:49:50 +02002915 w:some_var = 'some'
2916 assert_equal('some', get(w:, 'some_var'))
2917 assert_equal('some', get(w:, 'some_var', 'xxx'))
2918 assert_equal('xxx', get(w:, 'no_var', 'xxx'))
2919 unlet w:some_var
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002920
Bram Moolenaar90193e62021-04-04 20:49:50 +02002921 t:some_var = 'some'
2922 assert_equal('some', get(t:, 'some_var'))
2923 assert_equal('some', get(t:, 'some_var', 'xxx'))
2924 assert_equal('xxx', get(t:, 'no_var', 'xxx'))
2925 unlet t:some_var
Bram Moolenaar90193e62021-04-04 20:49:50 +02002926 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002927 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar2f8ce0a2020-07-19 19:47:35 +02002928enddef
2929
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002930def Test_expr8_namespace_loop_def()
Bram Moolenaardae453f2021-08-07 17:20:16 +02002931 var lines =<< trim END
2932 # check using g: in a for loop more than DO_NOT_FREE_CNT times
2933 var exists = 0
2934 var exists_not = 0
2935 for i in range(100000)
2936 if has_key(g:, 'does-not-exist')
2937 exists += 1
2938 else
2939 exists_not += 1
2940 endif
2941 endfor
2942 assert_equal(0, exists)
2943 assert_equal(100000, exists_not)
2944 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002945 v9.CheckDefSuccess(lines)
Bram Moolenaardae453f2021-08-07 17:20:16 +02002946enddef
2947
2948" NOTE: this is known to be slow. To skip use:
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002949" :let $TEST_SKIP_PAT = 'Test_expr8_namespace_loop_script'
2950def Test_expr8_namespace_loop_script()
Bram Moolenaardae453f2021-08-07 17:20:16 +02002951 var lines =<< trim END
2952 vim9script
2953 # check using g: in a for loop more than DO_NOT_FREE_CNT times
2954 var exists = 0
2955 var exists_not = 0
2956 for i in range(100000)
2957 if has_key(g:, 'does-not-exist')
2958 exists += 1
2959 else
2960 exists_not += 1
2961 endif
2962 endfor
2963 assert_equal(0, exists)
2964 assert_equal(100000, exists_not)
2965 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002966 v9.CheckScriptSuccess(lines)
Bram Moolenaardae453f2021-08-07 17:20:16 +02002967enddef
2968
Bram Moolenaar6389baa2022-01-17 20:50:40 +00002969def Test_expr8_parens()
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002970 # (expr)
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002971 var lines =<< trim END
Bram Moolenaar24156692021-01-14 20:35:49 +01002972 assert_equal(4, (6 * 4) / 6)
2973 assert_equal(0, 6 * ( 4 / 6 ))
2974
2975 assert_equal(6, +6)
2976 assert_equal(-6, -6)
2977 assert_equal(false, !-3)
2978 assert_equal(true, !+0)
2979
2980 assert_equal(7, 5 + (
2981 2))
2982 assert_equal(7, 5 + (
2983 2
2984 ))
2985 assert_equal(7, 5 + ( # comment
2986 2))
2987 assert_equal(7, 5 + ( # comment
2988 # comment
2989 2))
2990
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02002991 var s = (
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002992 'one'
2993 ..
2994 'two'
2995 )
2996 assert_equal('onetwo', s)
2997 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00002998 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar7a4981b2020-06-27 20:46:29 +02002999enddef
3000
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003001def Test_expr8_negate_add()
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003002 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003003 assert_equal(-99, -99)
3004 assert_equal(-99, - 99)
3005 assert_equal(99, +99)
3006
3007 var nr = 88
3008 assert_equal(-88, -nr)
3009 assert_equal(-88, - nr)
3010 assert_equal(88, + nr)
3011 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003012 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003013
3014 lines =<< trim END
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003015 var n = 12
3016 echo ++n
3017 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003018 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003019 lines =<< trim END
3020 var n = 12
3021 echo --n
3022 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003023 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003024 lines =<< trim END
3025 var n = 12
3026 echo +-n
3027 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003028 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003029 lines =<< trim END
3030 var n = 12
3031 echo -+n
3032 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003033 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003034 lines =<< trim END
3035 var n = 12
3036 echo - -n
3037 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003038 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003039 lines =<< trim END
3040 var n = 12
3041 echo + +n
3042 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003043 v9.CheckDefAndScriptFailure(lines, 'E15:')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003044enddef
3045
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003046def LegacyReturn(): string
3047 legacy return #{key: 'ok'}.key
3048enddef
3049
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003050def Test_expr8_legacy_script()
Bram Moolenaar15e5e532021-04-07 21:21:13 +02003051 var lines =<< trim END
3052 let s:legacy = 'legacy'
3053 def GetLocal(): string
3054 return legacy
3055 enddef
3056 def GetLocalPrefix(): string
3057 return s:legacy
3058 enddef
3059 call assert_equal('legacy', GetLocal())
3060 call assert_equal('legacy', GetLocalPrefix())
3061 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003062 v9.CheckScriptSuccess(lines)
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003063
Bram Moolenaar62aec932022-01-29 21:45:34 +00003064 assert_equal('ok', g:LegacyReturn())
Bram Moolenaar3b1373b2021-05-17 00:01:42 +02003065
3066 lines =<< trim END
3067 vim9script
3068 def GetNumber(): number
3069 legacy return range(3)->map('v:val + 1')
3070 enddef
3071 echo GetNumber()
3072 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003073 v9.CheckScriptFailure(lines, 'E1012: Type mismatch; expected number but got list<number>')
Bram Moolenaar15e5e532021-04-07 21:21:13 +02003074enddef
3075
Bram Moolenaar6e949782020-04-13 17:21:00 +02003076def Echo(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003077 return arg
3078enddef
3079
Bram Moolenaarc5da1fb2020-08-05 15:43:44 +02003080def s:Echo4Arg(arg: any): string
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003081 return arg
3082enddef
3083
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003084def Test_expr8_call()
Bram Moolenaar659bb222020-11-12 20:16:39 +01003085 var lines =<< trim END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003086 assert_equal('yes', 'yes'->g:Echo())
Bram Moolenaar659bb222020-11-12 20:16:39 +01003087 assert_equal(true, !range(5)->empty())
Bram Moolenaarb23279d2021-01-05 22:08:20 +01003088 assert_equal([0, 1, 2], 3->range())
Bram Moolenaar659bb222020-11-12 20:16:39 +01003089 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003090 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar659bb222020-11-12 20:16:39 +01003091
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003092 assert_equal('yes', 'yes'
Bram Moolenaar659bb222020-11-12 20:16:39 +01003093 ->s:Echo4Arg())
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003094
Bram Moolenaar62aec932022-01-29 21:45:34 +00003095 v9.CheckDefAndScriptFailure(["var x = 'yes'->g:Echo"], 'E107:', 1)
3096 v9.CheckDefAndScriptFailure([
Bram Moolenaar90193e62021-04-04 20:49:50 +02003097 "var x = substitute ('x', 'x', 'x', 'x')"
Bram Moolenaar86b3ab42021-12-19 18:33:23 +00003098 ], ['E1001:', 'E121:'], 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00003099 v9.CheckDefAndScriptFailure(["var Ref = function('len' [1, 2])"], ['E1123:', 'E116:'], 1)
3100enddef
Bram Moolenaara1773442020-08-12 15:21:22 +02003101
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003102def g:ExistingGlobal(): string
Bram Moolenaar62aec932022-01-29 21:45:34 +00003103 return 'existing'
3104enddef
3105
3106def Test_expr8_call_global()
Bram Moolenaar848fadd2022-01-30 15:28:30 +00003107 assert_equal('existing', g:ExistingGlobal())
Bram Moolenaar62aec932022-01-29 21:45:34 +00003108
3109 def g:DefinedLater(): string
3110 return 'later'
3111 enddef
3112 assert_equal('later', g:DefinedLater())
3113
3114 var lines =<< trim END
3115 echo ExistingGlobal()
3116 END
3117 v9.CheckDefAndScriptFailure(lines, 'E117: Unknown function: ExistingGlobal')
3118enddef
3119
3120def Test_expr8_call_autoload()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003121 var auto_lines =<< trim END
Bram Moolenaara1773442020-08-12 15:21:22 +02003122 def g:some#func(): string
3123 return 'found'
3124 enddef
3125 END
3126 mkdir('Xruntime/autoload', 'p')
3127 writefile(auto_lines, 'Xruntime/autoload/some.vim')
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003128 var save_rtp = &rtp
Bram Moolenaara1773442020-08-12 15:21:22 +02003129 &rtp = getcwd() .. '/Xruntime,' .. &rtp
3130 assert_equal('found', g:some#func())
3131 assert_equal('found', some#func())
3132
3133 &rtp = save_rtp
3134 delete('Xruntime', 'rf')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003135enddef
3136
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003137def Test_expr8_method_call()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003138 var lines =<< trim END
3139 new
3140 setline(1, ['first', 'last'])
3141 'second'->append(1)
3142 "third"->append(2)
3143 assert_equal(['first', 'second', 'third', 'last'], getline(1, '$'))
3144 bwipe!
Bram Moolenaar7e368202020-12-25 21:56:57 +01003145
Bram Moolenaar90193e62021-04-04 20:49:50 +02003146 var bufnr = bufnr()
3147 var loclist = [{bufnr: bufnr, lnum: 42, col: 17, text: 'wrong'}]
3148 loclist->setloclist(0)
3149 assert_equal([{bufnr: bufnr,
3150 lnum: 42,
thinca6864efa2021-06-19 20:45:20 +02003151 end_lnum: 0,
Bram Moolenaar90193e62021-04-04 20:49:50 +02003152 col: 17,
thinca6864efa2021-06-19 20:45:20 +02003153 end_col: 0,
Bram Moolenaar90193e62021-04-04 20:49:50 +02003154 text: 'wrong',
3155 pattern: '',
3156 valid: 1,
3157 vcol: 0,
3158 nr: 0,
3159 type: '',
3160 module: ''}
3161 ], getloclist(0))
Bram Moolenaar7e368202020-12-25 21:56:57 +01003162
Bram Moolenaar90193e62021-04-04 20:49:50 +02003163 var result: bool = get({n: 0}, 'n', 0)
3164 assert_equal(false, result)
Bram Moolenaar7e368202020-12-25 21:56:57 +01003165
Bram Moolenaar90193e62021-04-04 20:49:50 +02003166 assert_equal('+string+', 'string'->((s) => '+' .. s .. '+')())
3167 assert_equal('-text-', 'text'->((s, c) => c .. s .. c)('-'))
Bram Moolenaar7e368202020-12-25 21:56:57 +01003168
Bram Moolenaar90193e62021-04-04 20:49:50 +02003169 var Join = (l) => join(l, 'x')
3170 assert_equal('axb', ['a', 'b']->(Join)())
Bram Moolenaara7330422021-06-08 20:46:45 +02003171
3172 var sorted = [3, 1, 2]
3173 -> sort()
3174 assert_equal([1, 2, 3], sorted)
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003175 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003176 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003177
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003178 lines =<< trim END
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003179 def SetNumber(n: number)
3180 g:number = n
3181 enddef
3182 const Setit = SetNumber
3183 len('text')->Setit()
3184 assert_equal(4, g:number)
Bram Moolenaarc665dab2022-01-16 19:38:07 +00003185
3186 const SetFuncref = funcref(SetNumber)
3187 len('longer')->SetFuncref()
3188 assert_equal(6, g:number)
3189
3190 const SetList = [SetNumber, SetFuncref]
3191 len('xx')->SetList[0]()
3192 assert_equal(2, g:number)
3193 len('xxx')->SetList[1]()
3194 assert_equal(3, g:number)
3195
3196 const SetDict = {key: SetNumber}
3197 len('xxxx')->SetDict['key']()
3198 assert_equal(4, g:number)
3199 len('xxxxx')->SetDict.key()
3200 assert_equal(5, g:number)
3201
Bram Moolenaarc84287d2022-01-16 18:06:21 +00003202 unlet g:number
Bram Moolenaar90193e62021-04-04 20:49:50 +02003203 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003204 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003205
3206 lines =<< trim END
3207 def RetVoid()
3208 enddef
Bram Moolenaarf57b43c2021-06-15 22:13:27 +02003209 RetVoid()->byteidx(3)
3210 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003211 v9.CheckDefExecFailure(lines, 'E1013:')
Bram Moolenaar7e368202020-12-25 21:56:57 +01003212enddef
3213
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003214def Test_expr8_method_call_linebreak()
Bram Moolenaar5e6b9882022-01-10 18:50:52 +00003215 # this was giving an error when skipping over the expression
3216 var lines =<< trim END
3217 vim9script
3218 def Test()
3219 var a: dict<any> = {b: {}}
3220 a.b->extend({f1: 1,
3221 f2: 2})
3222 echo a
3223 enddef
3224 defcompile
3225 assert_equal('', v:errmsg)
3226 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003227 v9.CheckScriptSuccess(lines)
Bram Moolenaar5e6b9882022-01-10 18:50:52 +00003228enddef
3229
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003230def Test_expr8_method_call_import()
3231 var lines =<< trim END
3232 vim9script
3233 export def Square(items: list<number>): list<number>
3234 return map(items, (_, i) => i * i)
3235 enddef
3236 END
3237 call writefile(lines, 'Xsquare.vim')
Bram Moolenaar0b37a2f2020-03-29 21:38:15 +02003238
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003239 lines =<< trim END
3240 vim9script
3241 import './Xsquare.vim'
3242
3243 def Test(): list<number>
3244 return range(5)
3245 ->Xsquare.Square()
3246 ->map((_, i) => i * 10)
3247 enddef
3248
3249 assert_equal([0, 10, 40, 90, 160], Test())
3250 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003251 v9.CheckScriptSuccess(lines)
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003252
Bram Moolenaar64283d52022-01-18 10:37:29 +00003253 lines =<< trim END
3254 vim9script
3255 import './Xsquare.vim'
3256
3257 echo range(5)->Xsquare.NoSuchFunc()
3258 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003259 v9.CheckScriptFailure(lines, 'E1048: Item not found in script: NoSuchFunc')
Bram Moolenaar64283d52022-01-18 10:37:29 +00003260
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003261 delete('Xsquare.vim')
3262enddef
3263
3264
3265def Test_expr8_not()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003266 var lines =<< trim END
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003267 assert_equal(true, !'')
3268 assert_equal(true, ![])
3269 assert_equal(false, !'asdf')
3270 assert_equal(false, ![2])
3271 assert_equal(true, !!'asdf')
3272 assert_equal(true, !![2])
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003273
Bram Moolenaar27491cd2020-10-15 21:54:56 +02003274 assert_equal(true, ! false)
3275 assert_equal(true, !! true)
3276 assert_equal(true, ! ! true)
3277 assert_equal(true, !!! false)
3278 assert_equal(true, ! ! ! false)
3279
3280 g:true = true
3281 g:false = false
3282 assert_equal(true, ! g:false)
3283 assert_equal(true, !! g:true)
3284 assert_equal(true, ! ! g:true)
3285 assert_equal(true, !!! g:false)
3286 assert_equal(true, ! ! ! g:false)
3287 unlet g:true
3288 unlet g:false
3289
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003290 assert_equal(true, !test_null_partial())
Bram Moolenaar2949cfd2020-12-31 21:28:47 +01003291 assert_equal(false, !() => 'yes')
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003292
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003293 assert_equal(true, !test_null_dict())
3294 assert_equal(true, !{})
Bram Moolenaare0de1712020-12-02 17:36:54 +01003295 assert_equal(false, !{yes: 'no'})
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003296
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003297 if has('channel')
3298 assert_equal(true, !test_null_job())
3299 assert_equal(true, !test_null_channel())
3300 endif
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003301
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003302 assert_equal(true, !test_null_blob())
3303 assert_equal(true, !0z)
3304 assert_equal(false, !0z01)
Bram Moolenaar8ed04582020-02-22 19:07:28 +01003305
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003306 assert_equal(true, !test_void())
3307 assert_equal(true, !test_unknown())
Bram Moolenaar59eccb92020-08-10 23:09:37 +02003308
3309 assert_equal(false, ![1, 2, 3]->reverse())
3310 assert_equal(true, ![]->reverse())
Bram Moolenaar3e06a1e2020-08-10 21:57:54 +02003311 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003312 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003313enddef
3314
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003315let g:anumber = 42
3316
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003317def Test_expr8_negate()
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003318 var lines =<< trim END
3319 var nr = 1
3320 assert_equal(-1, -nr)
3321 assert_equal(-42, -g:anumber)
3322 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003323 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarcd6b4f32021-08-15 20:36:28 +02003324enddef
3325
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003326func Test_expr8_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003327 call v9.CheckDefFailure(["var x = (12"], "E1097:", 3)
3328 call v9.CheckScriptFailure(['vim9script', "var x = (12"], 'E110:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003329
Bram Moolenaar62aec932022-01-29 21:45:34 +00003330 call v9.CheckDefAndScriptFailure(["var x = -'xx'"], "E1030:", 1)
3331 call v9.CheckDefAndScriptFailure(["var x = +'xx'"], "E1030:", 1)
3332 call v9.CheckDefAndScriptFailure(["var x = -0z12"], "E974:", 1)
3333 call v9.CheckDefExecAndScriptFailure(["var x = -[8]"], ["E1012:", 'E745:'], 1)
3334 call v9.CheckDefExecAndScriptFailure(["var x = -{a: 1}"], ["E1012:", 'E728:'], 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003335
Bram Moolenaar62aec932022-01-29 21:45:34 +00003336 call v9.CheckDefAndScriptFailure(["var x = @"], "E1002:", 1)
3337 call v9.CheckDefAndScriptFailure(["var x = @<"], "E354:", 1)
Bram Moolenaar58ceca52020-01-28 22:46:22 +01003338
Bram Moolenaar62aec932022-01-29 21:45:34 +00003339 call v9.CheckDefFailure(["var x = [1, 2"], "E697:", 2)
3340 call v9.CheckScriptFailure(['vim9script', "var x = [1, 2"], 'E696:', 2)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003341
Bram Moolenaar62aec932022-01-29 21:45:34 +00003342 call v9.CheckDefAndScriptFailure(["var x = [notfound]"], ["E1001:", 'E121:'], 1)
Bram Moolenaaree619e52020-03-28 21:38:06 +01003343
Bram Moolenaar62aec932022-01-29 21:45:34 +00003344 call v9.CheckDefAndScriptFailure(["var X = () => 123)"], 'E488:', 1)
3345 call v9.CheckDefAndScriptFailure(["var x = 123->((x) => x + 5)"], "E107:", 1)
Bram Moolenaarfd1823e2020-02-19 20:23:11 +01003346
Bram Moolenaar62aec932022-01-29 21:45:34 +00003347 call v9.CheckDefAndScriptFailure(["var x = &notexist"], 'E113:', 1)
3348 call v9.CheckDefAndScriptFailure(["&grepprg = [343]"], ['E1012:', 'E730:'], 1)
Bram Moolenaar09f28f42020-02-20 23:08:34 +01003349
Bram Moolenaara749a422022-02-12 19:52:25 +00003350 call v9.CheckDefExecAndScriptFailure(["echo s:doesnt_exist"], ['E121:', 'E1268:'], 1)
Bram Moolenaar62aec932022-01-29 21:45:34 +00003351 call v9.CheckDefExecAndScriptFailure(["echo g:doesnt_exist"], 'E121:', 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003352
Bram Moolenaar62aec932022-01-29 21:45:34 +00003353 call v9.CheckDefAndScriptFailure(["echo a:somevar"], ['E1075:', 'E121:'], 1)
3354 call v9.CheckDefAndScriptFailure(["echo l:somevar"], ['E1075:', 'E121:'], 1)
3355 call v9.CheckDefAndScriptFailure(["echo x:somevar"], ['E1075:', 'E121:'], 1)
Bram Moolenaar42a480b2020-02-29 23:23:47 +01003356
Bram Moolenaar62aec932022-01-29 21:45:34 +00003357 call v9.CheckDefExecAndScriptFailure(["var x = +g:astring"], ['E1012:', 'E1030:'], 1)
3358 call v9.CheckDefExecAndScriptFailure(["var x = +g:ablob"], ['E1012:', 'E974:'], 1)
3359 call v9.CheckDefExecAndScriptFailure(["var x = +g:alist"], ['E1012:', 'E745:'], 1)
3360 call v9.CheckDefExecAndScriptFailure(["var x = +g:adict"], ['E1012:', 'E728:'], 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003361
Bram Moolenaar62aec932022-01-29 21:45:34 +00003362 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 +02003363
Bram Moolenaar62aec932022-01-29 21:45:34 +00003364 call v9.CheckDefAndScriptFailure(["'yes'->", "Echo()"], ['E488: Trailing characters: ->', 'E260: Missing name after ->'], 1)
Bram Moolenaardd1a9af2020-07-23 15:38:03 +02003365
Bram Moolenaar62aec932022-01-29 21:45:34 +00003366 call v9.CheckDefExecFailure(["[1, 2->len()"], 'E697:', 2)
3367 call v9.CheckScriptFailure(['vim9script', "[1, 2->len()"], 'E696:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003368
Bram Moolenaar62aec932022-01-29 21:45:34 +00003369 call v9.CheckDefFailure(["{a: 1->len()"], 'E723:', 2)
3370 call v9.CheckScriptFailure(['vim9script', "{a: 1->len()"], 'E722:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003371
Bram Moolenaar62aec932022-01-29 21:45:34 +00003372 call v9.CheckDefExecFailure(["{['a']: 1->len()"], 'E723:', 2)
3373 call v9.CheckScriptFailure(['vim9script', "{['a']: 1->len()"], 'E722:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003374endfunc
3375
3376let g:Funcrefs = [function('add')]
3377
3378func CallMe(arg)
3379 return a:arg
3380endfunc
3381
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003382func CallMe2(one, two)
3383 return a:one .. a:two
3384endfunc
3385
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003386def Test_expr8_trailing()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003387 var lines =<< trim END
3388 # user function call
3389 assert_equal(123, g:CallMe(123))
3390 assert_equal(123, g:CallMe( 123))
3391 assert_equal(123, g:CallMe(123 ))
3392 assert_equal('yesno', g:CallMe2('yes', 'no'))
3393 assert_equal('yesno', g:CallMe2( 'yes', 'no' ))
3394 assert_equal('nothing', g:CallMe('nothing'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003395
Bram Moolenaar90193e62021-04-04 20:49:50 +02003396 # partial call
3397 var Part = function('g:CallMe')
3398 assert_equal('yes', Part('yes'))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003399
Bram Moolenaar90193e62021-04-04 20:49:50 +02003400 # funcref call, using list index
3401 var l = []
3402 g:Funcrefs[0](l, 2)
3403 assert_equal([2], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003404
Bram Moolenaar90193e62021-04-04 20:49:50 +02003405 # method call
3406 l = [2, 5, 6]
3407 l->map((k, v) => k + v)
3408 assert_equal([2, 6, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003409
Bram Moolenaar90193e62021-04-04 20:49:50 +02003410 # lambda method call
3411 l = [2, 5]
3412 l->((ll) => add(ll, 8))()
3413 assert_equal([2, 5, 8], l)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003414
Bram Moolenaar90193e62021-04-04 20:49:50 +02003415 # dict member
3416 var d = {key: 123}
3417 assert_equal(123, d.key)
3418 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003419 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003420enddef
3421
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003422def Test_expr8_string_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003423 var lines =<< trim END
3424 var text = 'abcdef'
Bram Moolenaare7525c52021-01-09 13:20:37 +01003425 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003426 assert_equal('a', text[0])
3427 assert_equal('e', text[4])
3428 assert_equal('f', text[5])
3429 assert_equal('', text[6])
3430
Bram Moolenaare7525c52021-01-09 13:20:37 +01003431 text = 'ábçdë'
3432 assert_equal('ë', text[-1])
3433 assert_equal('d', text[-2])
3434 assert_equal('ç', text[-3])
3435 assert_equal('b', text[-4])
3436 assert_equal('á', text[-5])
3437 assert_equal('', text[-6])
3438
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003439 text = 'ábçdëf'
3440 assert_equal('', text[-999])
Bram Moolenaare7525c52021-01-09 13:20:37 +01003441 assert_equal('f', text[-1])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003442 assert_equal('á', text[0])
3443 assert_equal('b', text[1])
3444 assert_equal('ç', text[2])
3445 assert_equal('d', text[3])
3446 assert_equal('ë', text[4])
3447 assert_equal('f', text[5])
3448 assert_equal('', text[6])
3449 assert_equal('', text[999])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003450
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003451 assert_equal('ábçdëf', text[0 : -1])
3452 assert_equal('ábçdëf', text[0 : -1])
3453 assert_equal('ábçdëf', text[0 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003454 assert_equal('ábçdëf', text[0 : -1])
3455 assert_equal('ábçdëf', text[0
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003456 : -1])
3457 assert_equal('ábçdëf', text[0 :
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003458 -1])
3459 assert_equal('ábçdëf', text[0 : -1
3460 ])
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003461 assert_equal('bçdëf', text[1 : -1])
3462 assert_equal('çdëf', text[2 : -1])
3463 assert_equal('dëf', text[3 : -1])
3464 assert_equal('ëf', text[4 : -1])
3465 assert_equal('f', text[5 : -1])
3466 assert_equal('', text[6 : -1])
3467 assert_equal('', text[999 : -1])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003468
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003469 assert_equal('ábçd', text[: 3])
3470 assert_equal('bçdëf', text[1 :])
Bram Moolenaar11107ba2020-08-15 21:10:16 +02003471 assert_equal('ábçdëf', text[:])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003472
3473 assert_equal('a', g:astring[0])
3474 assert_equal('sd', g:astring[1 : 2])
3475 assert_equal('asdf', g:astring[:])
Bram Moolenaare3c37d82020-08-15 18:39:05 +02003476 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003477 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar918a4242020-12-06 14:37:08 +01003478
3479 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003480 var d = 'asdf'[1 :
Bram Moolenaar918a4242020-12-06 14:37:08 +01003481 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003482 v9.CheckDefFailure(lines, 'E1097:', 3)
3483 v9.CheckScriptFailure(['vim9script'] + lines, 'E15:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003484
Bram Moolenaar918a4242020-12-06 14:37:08 +01003485 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003486 var d = 'asdf'[1 : xxx]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003487 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003488 v9.CheckDefAndScriptFailure(lines, ['E1001:', 'E121:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003489
Bram Moolenaar918a4242020-12-06 14:37:08 +01003490 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003491 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003492 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003493 v9.CheckDefFailure(lines, 'E1097:', 3)
3494 v9.CheckScriptFailure(['vim9script'] + lines, 'E111:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003495
Bram Moolenaar918a4242020-12-06 14:37:08 +01003496 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003497 var d = 'asdf'[1 : 2
Bram Moolenaar918a4242020-12-06 14:37:08 +01003498 echo d
3499 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003500 v9.CheckDefAndScriptFailure(lines, 'E111:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003501
Bram Moolenaar918a4242020-12-06 14:37:08 +01003502 lines =<< trim END
3503 var d = 'asdf'['1']
3504 echo d
3505 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003506 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 +02003507
Bram Moolenaar918a4242020-12-06 14:37:08 +01003508 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003509 var d = 'asdf'['1' : 2]
Bram Moolenaar918a4242020-12-06 14:37:08 +01003510 echo d
3511 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003512 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 +02003513
Bram Moolenaar918a4242020-12-06 14:37:08 +01003514 lines =<< trim END
Bram Moolenaarde4f95b2020-12-30 20:39:21 +01003515 var d = 'asdf'[1 : '2']
Bram Moolenaar918a4242020-12-06 14:37:08 +01003516 echo d
3517 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003518 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 +02003519enddef
3520
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003521def Test_expr8_list_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003522 var lines =<< trim END
Bram Moolenaar90193e62021-04-04 20:49:50 +02003523 var list = [0, 1, 2, 3, 4]
3524 assert_equal(0, list[0])
3525 assert_equal(4, list[4])
3526 assert_equal(4, list[-1])
3527 assert_equal(0, list[-5])
Bram Moolenaared591872020-08-15 22:14:53 +02003528
Bram Moolenaar90193e62021-04-04 20:49:50 +02003529 assert_equal([0, 1, 2, 3, 4], list[0 : 4])
3530 assert_equal([0, 1, 2, 3, 4], list[:])
3531 assert_equal([1, 2, 3, 4], list[1 :])
3532 assert_equal([2, 3, 4], list[2 : -1])
3533 assert_equal([4], list[4 : -1])
3534 assert_equal([], list[5 : -1])
3535 assert_equal([], list[999 : -1])
3536 assert_equal([1, 2, 3, 4], list[g:theone : g:thefour])
Bram Moolenaared591872020-08-15 22:14:53 +02003537
Bram Moolenaar90193e62021-04-04 20:49:50 +02003538 assert_equal([0, 1, 2, 3], list[0 : 3])
3539 assert_equal([0], list[0 : 0])
3540 assert_equal([0, 1, 2, 3, 4], list[0 : -1])
3541 assert_equal([0, 1, 2], list[0 : -3])
3542 assert_equal([0], list[0 : -5])
3543 assert_equal([], list[0 : -6])
3544 assert_equal([], list[0 : -99])
Bram Moolenaar261417b2021-05-06 21:04:55 +02003545
3546 assert_equal(2, g:alist[0])
3547 assert_equal([2, 3, 4], g:alist[:])
Bram Moolenaared591872020-08-15 22:14:53 +02003548 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003549 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar56acb092020-08-16 14:48:19 +02003550
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003551 lines = ['var l = [0, 1, 2]', 'echo l[g:astring : g:theone]']
Bram Moolenaar62aec932022-01-29 21:45:34 +00003552 v9.CheckDefExecAndScriptFailure(lines, ['E1012:', 'E1030:'], 2)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003553
3554 lines =<< trim END
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003555 var ld = []
3556 def Func()
3557 eval ld[0].key
3558 enddef
3559 defcompile
3560 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003561 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaared591872020-08-15 22:14:53 +02003562enddef
3563
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003564def Test_expr8_dict_subscript()
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003565 var lines =<< trim END
Bram Moolenaare0de1712020-12-02 17:36:54 +01003566 var l = [{lnum: 2}, {lnum: 1}]
Bram Moolenaar37ce6d32020-09-27 17:57:43 +02003567 var res = l[0].lnum > l[1].lnum
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003568 assert_true(res)
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003569
Bram Moolenaar261417b2021-05-06 21:04:55 +02003570 assert_equal(2, g:adict['aaa'])
3571 assert_equal(8, g:adict.bbb)
3572
Bram Moolenaar31a11b92021-01-10 19:23:27 +01003573 var dd = {}
3574 def Func1()
3575 eval dd.key1.key2
3576 enddef
3577 def Func2()
3578 eval dd['key1'].key2
3579 enddef
3580 defcompile
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003581 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003582 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaarc6e57b72020-09-12 21:27:03 +02003583enddef
3584
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003585def Test_expr8_blob_subscript()
Bram Moolenaar261417b2021-05-06 21:04:55 +02003586 var lines =<< trim END
3587 var b = 0z112233
3588 assert_equal(0x11, b[0])
3589 assert_equal(0z112233, b[:])
3590
3591 assert_equal(0x01, g:ablob[0])
3592 assert_equal(0z01ab, g:ablob[:])
3593 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003594 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar261417b2021-05-06 21:04:55 +02003595enddef
3596
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003597def Test_expr8_subscript_linebreak()
Bram Moolenaar90193e62021-04-04 20:49:50 +02003598 var lines =<< trim END
3599 var range = range(
3600 3)
3601 var l = range
3602 ->mapnew('string(v:key)')
3603 assert_equal(['0', '1', '2'], l)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003604
Bram Moolenaar90193e62021-04-04 20:49:50 +02003605 l = range
3606 ->mapnew('string(v:key)')
3607 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003608
Bram Moolenaar90193e62021-04-04 20:49:50 +02003609 l = range # comment
3610 ->mapnew('string(v:key)')
3611 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003612
Bram Moolenaar90193e62021-04-04 20:49:50 +02003613 l = range
Bram Moolenaar23c55272020-06-21 16:58:13 +02003614
Bram Moolenaar90193e62021-04-04 20:49:50 +02003615 ->mapnew('string(v:key)')
3616 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003617
Bram Moolenaar90193e62021-04-04 20:49:50 +02003618 l = range
3619 # comment
3620 ->mapnew('string(v:key)')
3621 assert_equal(['0', '1', '2'], l)
Bram Moolenaar23c55272020-06-21 16:58:13 +02003622
Bram Moolenaar90193e62021-04-04 20:49:50 +02003623 assert_equal('1', l[
3624 1])
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003625
Bram Moolenaar90193e62021-04-04 20:49:50 +02003626 var d = {one: 33}
3627 assert_equal(33, d
3628 .one)
3629 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003630 v9.CheckDefAndScriptSuccess(lines)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003631
3632 lines =<< trim END
3633 var d = {one: 33}
3634 assert_equal(33, d.
3635 one)
3636 END
Bram Moolenaar62aec932022-01-29 21:45:34 +00003637 v9.CheckDefAndScriptFailure(lines, ['E1127:', 'E116:'], 2)
Bram Moolenaara3b7fdc2020-06-21 14:12:17 +02003638enddef
3639
Bram Moolenaar6389baa2022-01-17 20:50:40 +00003640func Test_expr8_trailing_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003641 call v9.CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8))'], 'E107:', 2)
3642 call v9.CheckDefAndScriptFailure(['var l = [2]', 'l->((ll) => add(ll, 8)) ()'], 'E274:', 2)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003643endfunc
3644
3645func Test_expr_fails()
Bram Moolenaar62aec932022-01-29 21:45:34 +00003646 call v9.CheckDefAndScriptFailure(["var x = '1'is2"], 'E488:', 1)
3647 call v9.CheckDefAndScriptFailure(["var x = '1'isnot2"], 'E488:', 1)
Bram Moolenaar38a5f512020-02-19 12:40:39 +01003648
Bram Moolenaar62aec932022-01-29 21:45:34 +00003649 call v9.CheckDefAndScriptFailure(["CallMe ('yes')"], ['E476:', 'E492:'], 1)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003650
Bram Moolenaar62aec932022-01-29 21:45:34 +00003651 call v9.CheckDefAndScriptFailure(["CallMe2('yes','no')"], 'E1069:', 1)
Bram Moolenaar0c2ca582020-02-25 22:58:29 +01003652
Bram Moolenaar62aec932022-01-29 21:45:34 +00003653 call v9.CheckDefAndScriptFailure(["v:nosuch += 3"], ['E1001:', 'E121:'], 1)
3654 call v9.CheckDefAndScriptFailure(["var v:statusmsg = ''"], 'E1016: Cannot declare a v: variable:', 1)
3655 call v9.CheckDefAndScriptFailure(["var asdf = v:nosuch"], ['E1001:', 'E121:'], 1)
Bram Moolenaar33fa29c2020-03-28 19:41:33 +01003656
Bram Moolenaar62aec932022-01-29 21:45:34 +00003657 call v9.CheckDefFailure(["echo len('asdf'"], 'E110:', 2)
3658 call v9.CheckScriptFailure(['vim9script', "echo len('asdf'"], 'E116:', 2)
Bram Moolenaar90193e62021-04-04 20:49:50 +02003659
Bram Moolenaar62aec932022-01-29 21:45:34 +00003660 call v9.CheckDefAndScriptFailure(["echo Func0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789()"], ['E1011:', 'E117:'], 1)
3661 call v9.CheckDefAndScriptFailure(["echo doesnotexist()"], 'E117:', 1)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003662endfunc
Bram Moolenaar6d91bcb2020-08-12 18:50:36 +02003663
3664" vim: shiftwidth=2 sts=2 expandtab