diff options
| -rw-r--r-- | spec/inputs/upvalue_func.yue | 207 | ||||
| -rw-r--r-- | spec/outputs/upvalue_func.lua | 502 | ||||
| -rw-r--r-- | src/yuescript/yue_compiler.cpp | 11 |
3 files changed, 715 insertions, 5 deletions
diff --git a/spec/inputs/upvalue_func.yue b/spec/inputs/upvalue_func.yue new file mode 100644 index 0000000..a4155da --- /dev/null +++ b/spec/inputs/upvalue_func.yue | |||
| @@ -0,0 +1,207 @@ | |||
| 1 | -- In module root scope the anonymous functions won't be moved to up-values because they just run once. | ||
| 2 | |||
| 3 | -- 1. if expr | ||
| 4 | func if cond | ||
| 5 | 998 | ||
| 6 | else | ||
| 7 | "abc" | ||
| 8 | |||
| 9 | -- 2. nil coalesed expr | ||
| 10 | func valueA + valueB ?? 123 | ||
| 11 | |||
| 12 | -- 3. vararg passing | ||
| 13 | do | ||
| 14 | ok, ... = func 1, 2, 3 | ||
| 15 | print select 3, ... | ||
| 16 | |||
| 17 | -- 4. chain with existential operator | ||
| 18 | if tb?.abc?\call? 123 | ||
| 19 | print "OK" | ||
| 20 | |||
| 21 | -- 5. colon chain with metamethod accessing with string or expr | ||
| 22 | func( | ||
| 23 | tb\<"fn"> 123 | ||
| 24 | tb\<[1 + 1]> "abc" | ||
| 25 | ) | ||
| 26 | |||
| 27 | -- 6. colon chain with Lua keyword or unicode name | ||
| 28 | func tb\end()\🤣 123 | ||
| 29 | |||
| 30 | -- 7. in expr with short check | ||
| 31 | itemA = 1 | ||
| 32 | listA = [] | ||
| 33 | if itemA in listA | ||
| 34 | print "itemA in listA" | ||
| 35 | |||
| 36 | -- 8. in expr without short check | ||
| 37 | if itemB? and itemB in listB | ||
| 38 | print "itemB in listB" | ||
| 39 | |||
| 40 | -- 9. spread table | ||
| 41 | func [...listA, ...listB] | ||
| 42 | |||
| 43 | -- 10. comprehension | ||
| 44 | func [i for i = 1, 10], [k for k in pairs tb] | ||
| 45 | |||
| 46 | -- 11. for expr | ||
| 47 | func for i = 1, 10 | ||
| 48 | i + 1 | ||
| 49 | |||
| 50 | -- 12. for each expr | ||
| 51 | func for k, v in pairs tb | ||
| 52 | [k, v] | ||
| 53 | |||
| 54 | -- 13. class declaration expr | ||
| 55 | func class | ||
| 56 | new: => @value = 1 | ||
| 57 | |||
| 58 | -- 14. with expr | ||
| 59 | func with tb | ||
| 60 | .field = 1 | ||
| 61 | \func "a" | ||
| 62 | |||
| 63 | -- 15. table comprehension expr | ||
| 64 | func {"#{k}-post-fix", v * 2 for k, v in pairs tb} | ||
| 65 | |||
| 66 | -- 16. do expr | ||
| 67 | func do | ||
| 68 | print 123 | ||
| 69 | "abc" | ||
| 70 | |||
| 71 | -- 17. try expr with block codes | ||
| 72 | do | ||
| 73 | success, ... = try | ||
| 74 | a = 1 | ||
| 75 | print a + nil | ||
| 76 | 1, 2, 3 | ||
| 77 | print select '#', ... if success | ||
| 78 | |||
| 79 | -- 18. while expr | ||
| 80 | i = 1 | ||
| 81 | func while cond | ||
| 82 | i += 1 | ||
| 83 | i | ||
| 84 | |||
| 85 | -- 19. switch expr | ||
| 86 | func switch value | ||
| 87 | when 1 | ||
| 88 | 'a' | ||
| 89 | when 2 | ||
| 90 | 'b' | ||
| 91 | |||
| 92 | GameEngine\onUpdate (deltaTime) -> | ||
| 93 | -- 1. if expr | ||
| 94 | func if cond | ||
| 95 | 998 | ||
| 96 | else | ||
| 97 | "abc" | ||
| 98 | |||
| 99 | -- 2. nil coalesed expr | ||
| 100 | func valueA + valueB ?? 123 | ||
| 101 | |||
| 102 | -- 3. vararg passing | ||
| 103 | do | ||
| 104 | ok, ... = func 1, 2, 3 | ||
| 105 | print select 3, ... | ||
| 106 | |||
| 107 | -- 4. chain with existential operator | ||
| 108 | if tb?.abc?\call? 123 | ||
| 109 | print "OK" | ||
| 110 | |||
| 111 | -- 5. colon chain with metamethod accessing with string or expr | ||
| 112 | func( | ||
| 113 | tb\<"fn"> 123 | ||
| 114 | tb\<[1 + 1]> "abc" | ||
| 115 | ) | ||
| 116 | |||
| 117 | -- 6. colon chain with Lua keyword or unicode name | ||
| 118 | func tb\end()\🤣 123 | ||
| 119 | |||
| 120 | -- 7. in expr with short check | ||
| 121 | itemA = 1 | ||
| 122 | listA = [] | ||
| 123 | if itemA in listA | ||
| 124 | print "item in list" | ||
| 125 | |||
| 126 | -- 8. in expr without short check | ||
| 127 | if itemB? and itemB in listB | ||
| 128 | print "item in list" | ||
| 129 | |||
| 130 | -- 9. spread table | ||
| 131 | func [...listA, ...listB] | ||
| 132 | |||
| 133 | -- 10. comprehension | ||
| 134 | func [i for i = 1, 10], [k for k in pairs tb] | ||
| 135 | |||
| 136 | -- 11. for expr | ||
| 137 | func for i = 1, 10 | ||
| 138 | i + 1 | ||
| 139 | |||
| 140 | -- 12. for each expr | ||
| 141 | func for k, v in pairs tb | ||
| 142 | [k, v] | ||
| 143 | |||
| 144 | -- 13. class declaration expr | ||
| 145 | func class | ||
| 146 | new: => @value = 1 | ||
| 147 | |||
| 148 | -- 14. with expr | ||
| 149 | func with tb | ||
| 150 | .field = 1 | ||
| 151 | \func "a" | ||
| 152 | |||
| 153 | -- 15. table comprehension expr | ||
| 154 | func {"#{k}-post-fix", v * 2 for k, v in pairs tb} | ||
| 155 | |||
| 156 | -- 16. do expr | ||
| 157 | func do | ||
| 158 | print 123 | ||
| 159 | "abc" | ||
| 160 | |||
| 161 | -- 17. try expr with block codes | ||
| 162 | do | ||
| 163 | success, ... = try | ||
| 164 | a = 1 | ||
| 165 | print a + nil | ||
| 166 | 1, 2, 3 | ||
| 167 | print select '#', ... if success | ||
| 168 | |||
| 169 | -- 18. while expr | ||
| 170 | i = 1 | ||
| 171 | func while cond | ||
| 172 | i += 1 | ||
| 173 | i | ||
| 174 | |||
| 175 | -- 19. switch expr | ||
| 176 | func switch value | ||
| 177 | when 1 | ||
| 178 | 'a' | ||
| 179 | when 2 | ||
| 180 | 'b' | ||
| 181 | |||
| 182 | GameEngine\onEvent "SomeEvent", -> | ||
| 183 | func value + (if cond | ||
| 184 | 998 | ||
| 185 | else | ||
| 186 | "abc") + (valueB ?? 123) > tb?.abc?\call?(123) + tb\end()\🤣 123 and | ||
| 187 | itemA in listA | ||
| 188 | |||
| 189 | GameEngine\schedule (deltaTime) -> | ||
| 190 | value = 123 | ||
| 191 | func if value > 200 | ||
| 192 | UpdateScoreText "Win: #{value}" | ||
| 193 | "done" | ||
| 194 | else | ||
| 195 | UpdateScoreText "Score: #{value}" | ||
| 196 | "continue" | ||
| 197 | |||
| 198 | GameEngine\schedule (deltaTime) -> -- closure 1 | ||
| 199 | value = 123 | ||
| 200 | func if value > 200 | ||
| 201 | UpdateScoreText "Win: #{value}" | ||
| 202 | "done" | ||
| 203 | else | ||
| 204 | GameEngine\schedule (deltaTime) -> -- closure 2 | ||
| 205 | UpdateScoreText "Score: #{value}" -- value is captured by closure 2 | ||
| 206 | "continue" | ||
| 207 | |||
diff --git a/spec/outputs/upvalue_func.lua b/spec/outputs/upvalue_func.lua new file mode 100644 index 0000000..125d75f --- /dev/null +++ b/spec/outputs/upvalue_func.lua | |||
| @@ -0,0 +1,502 @@ | |||
| 1 | func((function() | ||
| 2 | if cond then | ||
| 3 | return 998 | ||
| 4 | else | ||
| 5 | return "abc" | ||
| 6 | end | ||
| 7 | end)()) | ||
| 8 | func(valueA + (function() | ||
| 9 | local _exp_0 = valueB | ||
| 10 | if _exp_0 ~= nil then | ||
| 11 | return _exp_0 | ||
| 12 | else | ||
| 13 | return 123 | ||
| 14 | end | ||
| 15 | end)()) | ||
| 16 | do | ||
| 17 | (function(_arg_0, ...) | ||
| 18 | local ok = _arg_0 | ||
| 19 | return print(select(3, ...)) | ||
| 20 | end)(func(1, 2, 3)) | ||
| 21 | end | ||
| 22 | if (function() | ||
| 23 | local _obj_0 = tb | ||
| 24 | if _obj_0 ~= nil then | ||
| 25 | local _obj_1 = _obj_0.abc | ||
| 26 | if _obj_1 ~= nil then | ||
| 27 | local _obj_2 = _obj_1.call | ||
| 28 | if _obj_2 ~= nil then | ||
| 29 | return _obj_2(_obj_1, 123) | ||
| 30 | end | ||
| 31 | return nil | ||
| 32 | end | ||
| 33 | return nil | ||
| 34 | end | ||
| 35 | return nil | ||
| 36 | end)() then | ||
| 37 | print("OK") | ||
| 38 | end | ||
| 39 | func((function() | ||
| 40 | local _obj_0 = getmetatable(tb) | ||
| 41 | return _obj_0["fn"](_obj_0, 123) | ||
| 42 | end)(), (function() | ||
| 43 | local _obj_0 = getmetatable(tb) | ||
| 44 | return _obj_0[1 + 1](_obj_0, "abc") | ||
| 45 | end)()) | ||
| 46 | func((function() | ||
| 47 | local _call_0 = tb | ||
| 48 | local _call_1 = _call_0["end"](_call_0) | ||
| 49 | return _call_1["🤣"](_call_1, 123) | ||
| 50 | end)()) | ||
| 51 | local itemA = 1 | ||
| 52 | local listA = { } | ||
| 53 | if (#listA > 0 and (function() | ||
| 54 | for _index_0 = 1, #listA do | ||
| 55 | if listA[_index_0] == itemA then | ||
| 56 | return true | ||
| 57 | end | ||
| 58 | end | ||
| 59 | return false | ||
| 60 | end)()) then | ||
| 61 | print("itemA in listA") | ||
| 62 | end | ||
| 63 | if (itemB ~= nil) and (function() | ||
| 64 | local _check_0 = listB | ||
| 65 | local _val_0 = itemB | ||
| 66 | for _index_0 = 1, #_check_0 do | ||
| 67 | if _check_0[_index_0] == _val_0 then | ||
| 68 | return true | ||
| 69 | end | ||
| 70 | end | ||
| 71 | return false | ||
| 72 | end)() then | ||
| 73 | print("itemB in listB") | ||
| 74 | end | ||
| 75 | func((function() | ||
| 76 | local _tab_0 = { } | ||
| 77 | local _idx_0 = #_tab_0 + 1 | ||
| 78 | for _index_0 = 1, #listA do | ||
| 79 | local _value_0 = listA[_index_0] | ||
| 80 | _tab_0[_idx_0] = _value_0 | ||
| 81 | _idx_0 = _idx_0 + 1 | ||
| 82 | end | ||
| 83 | local _idx_1 = #_tab_0 + 1 | ||
| 84 | local _list_0 = listB | ||
| 85 | for _index_0 = 1, #_list_0 do | ||
| 86 | local _value_0 = _list_0[_index_0] | ||
| 87 | _tab_0[_idx_1] = _value_0 | ||
| 88 | _idx_1 = _idx_1 + 1 | ||
| 89 | end | ||
| 90 | return _tab_0 | ||
| 91 | end)()) | ||
| 92 | func((function() | ||
| 93 | local _accum_0 = { } | ||
| 94 | local _len_0 = 1 | ||
| 95 | for i = 1, 10 do | ||
| 96 | _accum_0[_len_0] = i | ||
| 97 | _len_0 = _len_0 + 1 | ||
| 98 | end | ||
| 99 | return _accum_0 | ||
| 100 | end)(), (function() | ||
| 101 | local _accum_0 = { } | ||
| 102 | local _len_0 = 1 | ||
| 103 | for k in pairs(tb) do | ||
| 104 | _accum_0[_len_0] = k | ||
| 105 | _len_0 = _len_0 + 1 | ||
| 106 | end | ||
| 107 | return _accum_0 | ||
| 108 | end)()) | ||
| 109 | func((function() | ||
| 110 | local _accum_0 = { } | ||
| 111 | local _len_0 = 1 | ||
| 112 | for i = 1, 10 do | ||
| 113 | _accum_0[_len_0] = i + 1 | ||
| 114 | _len_0 = _len_0 + 1 | ||
| 115 | end | ||
| 116 | return _accum_0 | ||
| 117 | end)()) | ||
| 118 | func((function() | ||
| 119 | local _accum_0 = { } | ||
| 120 | local _len_0 = 1 | ||
| 121 | for k, v in pairs(tb) do | ||
| 122 | _accum_0[_len_0] = { | ||
| 123 | k, | ||
| 124 | v | ||
| 125 | } | ||
| 126 | _len_0 = _len_0 + 1 | ||
| 127 | end | ||
| 128 | return _accum_0 | ||
| 129 | end)()) | ||
| 130 | func((function() | ||
| 131 | do | ||
| 132 | local _class_0 | ||
| 133 | local _base_0 = { } | ||
| 134 | if _base_0.__index == nil then | ||
| 135 | _base_0.__index = _base_0 | ||
| 136 | end | ||
| 137 | _class_0 = setmetatable({ | ||
| 138 | __init = function(self) | ||
| 139 | self.value = 1 | ||
| 140 | end, | ||
| 141 | __base = _base_0 | ||
| 142 | }, { | ||
| 143 | __index = _base_0, | ||
| 144 | __call = function(cls, ...) | ||
| 145 | local _self_0 = setmetatable({ }, _base_0) | ||
| 146 | cls.__init(_self_0, ...) | ||
| 147 | return _self_0 | ||
| 148 | end | ||
| 149 | }) | ||
| 150 | _base_0.__class = _class_0 | ||
| 151 | return _class_0 | ||
| 152 | end | ||
| 153 | end)()) | ||
| 154 | func((function() | ||
| 155 | local _with_0 = tb | ||
| 156 | _with_0.field = 1 | ||
| 157 | _with_0:func("a") | ||
| 158 | return _with_0 | ||
| 159 | end)()) | ||
| 160 | func((function() | ||
| 161 | local _tbl_0 = { } | ||
| 162 | for k, v in pairs(tb) do | ||
| 163 | _tbl_0[tostring(k) .. "-post-fix"] = v * 2 | ||
| 164 | end | ||
| 165 | return _tbl_0 | ||
| 166 | end)()) | ||
| 167 | func((function() | ||
| 168 | print(123) | ||
| 169 | return "abc" | ||
| 170 | end)()) | ||
| 171 | do | ||
| 172 | (function(_arg_0, ...) | ||
| 173 | local success = _arg_0 | ||
| 174 | if success then | ||
| 175 | return print(select('#', ...)) | ||
| 176 | end | ||
| 177 | end)(pcall(function() | ||
| 178 | local a = 1 | ||
| 179 | print(a + nil) | ||
| 180 | return 1, 2, 3 | ||
| 181 | end)) | ||
| 182 | end | ||
| 183 | local i = 1 | ||
| 184 | func((function() | ||
| 185 | local _accum_0 = { } | ||
| 186 | local _len_0 = 1 | ||
| 187 | while cond do | ||
| 188 | i = i + 1 | ||
| 189 | _accum_0[_len_0] = i | ||
| 190 | _len_0 = _len_0 + 1 | ||
| 191 | end | ||
| 192 | return _accum_0 | ||
| 193 | end)()) | ||
| 194 | func((function() | ||
| 195 | local _exp_0 = value | ||
| 196 | if 1 == _exp_0 then | ||
| 197 | return 'a' | ||
| 198 | elseif 2 == _exp_0 then | ||
| 199 | return 'b' | ||
| 200 | end | ||
| 201 | end)()) | ||
| 202 | local _anon_func_0 = function(cond) | ||
| 203 | if cond then | ||
| 204 | return 998 | ||
| 205 | else | ||
| 206 | return "abc" | ||
| 207 | end | ||
| 208 | end | ||
| 209 | local _anon_func_1 = function(valueB) | ||
| 210 | if valueB ~= nil then | ||
| 211 | return valueB | ||
| 212 | else | ||
| 213 | return 123 | ||
| 214 | end | ||
| 215 | end | ||
| 216 | local _anon_func_2 = function(print, select, _arg_0, ...) | ||
| 217 | do | ||
| 218 | local ok = _arg_0 | ||
| 219 | return print(select(3, ...)) | ||
| 220 | end | ||
| 221 | end | ||
| 222 | local _anon_func_3 = function(tb) | ||
| 223 | if tb ~= nil then | ||
| 224 | local _obj_0 = tb.abc | ||
| 225 | if _obj_0 ~= nil then | ||
| 226 | local _obj_1 = _obj_0.call | ||
| 227 | if _obj_1 ~= nil then | ||
| 228 | return _obj_1(_obj_0, 123) | ||
| 229 | end | ||
| 230 | return nil | ||
| 231 | end | ||
| 232 | return nil | ||
| 233 | end | ||
| 234 | return nil | ||
| 235 | end | ||
| 236 | local _anon_func_4 = function(getmetatable, tb) | ||
| 237 | local _obj_0 = getmetatable(tb) | ||
| 238 | return _obj_0["fn"](_obj_0, 123) | ||
| 239 | end | ||
| 240 | local _anon_func_5 = function(getmetatable, tb) | ||
| 241 | local _obj_0 = getmetatable(tb) | ||
| 242 | return _obj_0[1 + 1](_obj_0, "abc") | ||
| 243 | end | ||
| 244 | local _anon_func_6 = function(tb) | ||
| 245 | do | ||
| 246 | local _call_0 = tb | ||
| 247 | local _call_1 = _call_0["end"](_call_0) | ||
| 248 | return _call_1["🤣"](_call_1, 123) | ||
| 249 | end | ||
| 250 | end | ||
| 251 | local _anon_func_7 = function(itemA, listA) | ||
| 252 | for _index_0 = 1, #listA do | ||
| 253 | if listA[_index_0] == itemA then | ||
| 254 | return true | ||
| 255 | end | ||
| 256 | end | ||
| 257 | return false | ||
| 258 | end | ||
| 259 | local _anon_func_8 = function(itemB, listB) | ||
| 260 | for _index_0 = 1, #listB do | ||
| 261 | if listB[_index_0] == itemB then | ||
| 262 | return true | ||
| 263 | end | ||
| 264 | end | ||
| 265 | return false | ||
| 266 | end | ||
| 267 | local _anon_func_9 = function(listA, listB, pairs) | ||
| 268 | local _tab_0 = { } | ||
| 269 | local _idx_0 = #_tab_0 + 1 | ||
| 270 | for _index_0 = 1, #listA do | ||
| 271 | local _value_0 = listA[_index_0] | ||
| 272 | _tab_0[_idx_0] = _value_0 | ||
| 273 | _idx_0 = _idx_0 + 1 | ||
| 274 | end | ||
| 275 | local _idx_1 = #_tab_0 + 1 | ||
| 276 | for _index_0 = 1, #listB do | ||
| 277 | local _value_0 = listB[_index_0] | ||
| 278 | _tab_0[_idx_1] = _value_0 | ||
| 279 | _idx_1 = _idx_1 + 1 | ||
| 280 | end | ||
| 281 | return _tab_0 | ||
| 282 | end | ||
| 283 | local _anon_func_10 = function() | ||
| 284 | local _accum_0 = { } | ||
| 285 | local _len_0 = 1 | ||
| 286 | for i = 1, 10 do | ||
| 287 | _accum_0[_len_0] = i | ||
| 288 | _len_0 = _len_0 + 1 | ||
| 289 | end | ||
| 290 | return _accum_0 | ||
| 291 | end | ||
| 292 | local _anon_func_11 = function(pairs, tb) | ||
| 293 | local _accum_0 = { } | ||
| 294 | local _len_0 = 1 | ||
| 295 | for k in pairs(tb) do | ||
| 296 | _accum_0[_len_0] = k | ||
| 297 | _len_0 = _len_0 + 1 | ||
| 298 | end | ||
| 299 | return _accum_0 | ||
| 300 | end | ||
| 301 | local _anon_func_12 = function() | ||
| 302 | local _accum_0 = { } | ||
| 303 | local _len_0 = 1 | ||
| 304 | for i = 1, 10 do | ||
| 305 | _accum_0[_len_0] = i + 1 | ||
| 306 | _len_0 = _len_0 + 1 | ||
| 307 | end | ||
| 308 | return _accum_0 | ||
| 309 | end | ||
| 310 | local _anon_func_13 = function(pairs, tb) | ||
| 311 | local _accum_0 = { } | ||
| 312 | local _len_0 = 1 | ||
| 313 | for k, v in pairs(tb) do | ||
| 314 | _accum_0[_len_0] = { | ||
| 315 | k, | ||
| 316 | v | ||
| 317 | } | ||
| 318 | _len_0 = _len_0 + 1 | ||
| 319 | end | ||
| 320 | return _accum_0 | ||
| 321 | end | ||
| 322 | local _anon_func_14 = function(setmetatable) | ||
| 323 | do | ||
| 324 | local _class_0 | ||
| 325 | local _base_0 = { } | ||
| 326 | if _base_0.__index == nil then | ||
| 327 | _base_0.__index = _base_0 | ||
| 328 | end | ||
| 329 | _class_0 = setmetatable({ | ||
| 330 | __init = function(self) | ||
| 331 | self.value = 1 | ||
| 332 | end, | ||
| 333 | __base = _base_0 | ||
| 334 | }, { | ||
| 335 | __index = _base_0, | ||
| 336 | __call = function(cls, ...) | ||
| 337 | local _self_0 = setmetatable({ }, _base_0) | ||
| 338 | cls.__init(_self_0, ...) | ||
| 339 | return _self_0 | ||
| 340 | end | ||
| 341 | }) | ||
| 342 | _base_0.__class = _class_0 | ||
| 343 | return _class_0 | ||
| 344 | end | ||
| 345 | end | ||
| 346 | local _anon_func_15 = function(tb) | ||
| 347 | tb.field = 1 | ||
| 348 | tb:func("a") | ||
| 349 | return tb | ||
| 350 | end | ||
| 351 | local _anon_func_16 = function(pairs, tb, tostring) | ||
| 352 | local _tbl_0 = { } | ||
| 353 | for k, v in pairs(tb) do | ||
| 354 | _tbl_0[tostring(k) .. "-post-fix"] = v * 2 | ||
| 355 | end | ||
| 356 | return _tbl_0 | ||
| 357 | end | ||
| 358 | local _anon_func_17 = function(print) | ||
| 359 | do | ||
| 360 | print(123) | ||
| 361 | return "abc" | ||
| 362 | end | ||
| 363 | end | ||
| 364 | local _anon_func_18 = function(print, select, _arg_0, ...) | ||
| 365 | do | ||
| 366 | local success = _arg_0 | ||
| 367 | if success then | ||
| 368 | return print(select('#', ...)) | ||
| 369 | end | ||
| 370 | end | ||
| 371 | end | ||
| 372 | local _anon_func_19 = function(print) | ||
| 373 | do | ||
| 374 | local a = 1 | ||
| 375 | print(a + nil) | ||
| 376 | return 1, 2, 3 | ||
| 377 | end | ||
| 378 | end | ||
| 379 | local _anon_func_20 = function(cond, i) | ||
| 380 | local _accum_0 = { } | ||
| 381 | local _len_0 = 1 | ||
| 382 | while cond do | ||
| 383 | i = i + 1 | ||
| 384 | _accum_0[_len_0] = i | ||
| 385 | _len_0 = _len_0 + 1 | ||
| 386 | end | ||
| 387 | return _accum_0 | ||
| 388 | end | ||
| 389 | local _anon_func_21 = function(value) | ||
| 390 | if 1 == value then | ||
| 391 | return 'a' | ||
| 392 | elseif 2 == value then | ||
| 393 | return 'b' | ||
| 394 | end | ||
| 395 | end | ||
| 396 | GameEngine:onUpdate(function(deltaTime) | ||
| 397 | func(_anon_func_0(cond)) | ||
| 398 | func(valueA + _anon_func_1(valueB)) | ||
| 399 | do | ||
| 400 | _anon_func_2(print, select, func(1, 2, 3)) | ||
| 401 | end | ||
| 402 | if _anon_func_3(tb) then | ||
| 403 | print("OK") | ||
| 404 | end | ||
| 405 | func(_anon_func_4(getmetatable, tb), _anon_func_5(getmetatable, tb)) | ||
| 406 | func(_anon_func_6(tb)) | ||
| 407 | itemA = 1 | ||
| 408 | listA = { } | ||
| 409 | if (#listA > 0 and _anon_func_7(itemA, listA)) then | ||
| 410 | print("item in list") | ||
| 411 | end | ||
| 412 | if (itemB ~= nil) and _anon_func_8(itemB, listB) then | ||
| 413 | print("item in list") | ||
| 414 | end | ||
| 415 | func(_anon_func_9(listA, listB, pairs)) | ||
| 416 | func(_anon_func_10(), _anon_func_11(pairs, tb)) | ||
| 417 | func(_anon_func_12()) | ||
| 418 | func(_anon_func_13(pairs, tb)) | ||
| 419 | func(_anon_func_14(setmetatable)) | ||
| 420 | func(_anon_func_15(tb)) | ||
| 421 | func(_anon_func_16(pairs, tb, tostring)) | ||
| 422 | func(_anon_func_17(print)) | ||
| 423 | do | ||
| 424 | _anon_func_18(print, select, pcall(_anon_func_19, print)) | ||
| 425 | end | ||
| 426 | i = 1 | ||
| 427 | func(_anon_func_20(cond, i)) | ||
| 428 | return func(_anon_func_21(value)) | ||
| 429 | end) | ||
| 430 | local _anon_func_22 = function(cond) | ||
| 431 | if cond then | ||
| 432 | return 998 | ||
| 433 | else | ||
| 434 | return "abc" | ||
| 435 | end | ||
| 436 | end | ||
| 437 | local _anon_func_23 = function(valueB) | ||
| 438 | if valueB ~= nil then | ||
| 439 | return valueB | ||
| 440 | else | ||
| 441 | return 123 | ||
| 442 | end | ||
| 443 | end | ||
| 444 | local _anon_func_24 = function(tb) | ||
| 445 | if tb ~= nil then | ||
| 446 | local _obj_0 = tb.abc | ||
| 447 | if _obj_0 ~= nil then | ||
| 448 | local _obj_1 = _obj_0.call | ||
| 449 | if _obj_1 ~= nil then | ||
| 450 | return _obj_1(_obj_0, 123) | ||
| 451 | end | ||
| 452 | return nil | ||
| 453 | end | ||
| 454 | return nil | ||
| 455 | end | ||
| 456 | return nil | ||
| 457 | end | ||
| 458 | local _anon_func_26 = function(itemA, listA) | ||
| 459 | for _index_0 = 1, #listA do | ||
| 460 | if listA[_index_0] == itemA then | ||
| 461 | return true | ||
| 462 | end | ||
| 463 | end | ||
| 464 | return false | ||
| 465 | end | ||
| 466 | local _anon_func_25 = function(itemA, listA, tb) | ||
| 467 | do | ||
| 468 | local _call_0 = tb | ||
| 469 | local _call_1 = _call_0["end"](_call_0) | ||
| 470 | return _call_1["🤣"](_call_1, 123 and (#listA > 0 and _anon_func_26(itemA, listA))) | ||
| 471 | end | ||
| 472 | end | ||
| 473 | GameEngine:onEvent("SomeEvent", function() | ||
| 474 | return func(value + (_anon_func_22(cond)) + (_anon_func_23(valueB)) > _anon_func_24(tb) + _anon_func_25(itemA, listA, tb)) | ||
| 475 | end) | ||
| 476 | local _anon_func_27 = function(UpdateScoreText, tostring, value) | ||
| 477 | if value > 200 then | ||
| 478 | UpdateScoreText("Win: " .. tostring(value)) | ||
| 479 | return "done" | ||
| 480 | else | ||
| 481 | UpdateScoreText("Score: " .. tostring(value)) | ||
| 482 | return "continue" | ||
| 483 | end | ||
| 484 | end | ||
| 485 | GameEngine:schedule(function(deltaTime) | ||
| 486 | local value = 123 | ||
| 487 | return func(_anon_func_27(UpdateScoreText, tostring, value)) | ||
| 488 | end) | ||
| 489 | return GameEngine:schedule(function(deltaTime) | ||
| 490 | local value = 123 | ||
| 491 | return func((function() | ||
| 492 | if value > 200 then | ||
| 493 | UpdateScoreText("Win: " .. tostring(value)) | ||
| 494 | return "done" | ||
| 495 | else | ||
| 496 | GameEngine:schedule(function(deltaTime) | ||
| 497 | return UpdateScoreText("Score: " .. tostring(value)) | ||
| 498 | end) | ||
| 499 | return "continue" | ||
| 500 | end | ||
| 501 | end)()) | ||
| 502 | end) | ||
diff --git a/src/yuescript/yue_compiler.cpp b/src/yuescript/yue_compiler.cpp index a443f39..1864846 100644 --- a/src/yuescript/yue_compiler.cpp +++ b/src/yuescript/yue_compiler.cpp | |||
| @@ -3787,11 +3787,6 @@ private: | |||
| 3787 | } | 3787 | } |
| 3788 | 3788 | ||
| 3789 | void transformNilCoalesedExp(Exp_t* exp, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr, bool nilBranchOnly = false) { | 3789 | void transformNilCoalesedExp(Exp_t* exp, str_list& out, ExpUsage usage, ExpList_t* assignList = nullptr, bool nilBranchOnly = false) { |
| 3790 | if (usage == ExpUsage::Closure) { | ||
| 3791 | if (transformAsUpValueFunc(exp, out)) { | ||
| 3792 | return; | ||
| 3793 | } | ||
| 3794 | } | ||
| 3795 | auto x = exp; | 3790 | auto x = exp; |
| 3796 | str_list temp; | 3791 | str_list temp; |
| 3797 | auto left = exp->new_ptr<Exp_t>(); | 3792 | auto left = exp->new_ptr<Exp_t>(); |
| @@ -3814,6 +3809,12 @@ private: | |||
| 3814 | } | 3809 | } |
| 3815 | std::string* funcStart = nullptr; | 3810 | std::string* funcStart = nullptr; |
| 3816 | if (usage == ExpUsage::Closure) { | 3811 | if (usage == ExpUsage::Closure) { |
| 3812 | left->nilCoalesed.set(exp->nilCoalesed); | ||
| 3813 | if (transformAsUpValueFunc(left, temp)) { | ||
| 3814 | out.push_back(join(temp)); | ||
| 3815 | return; | ||
| 3816 | } | ||
| 3817 | left->nilCoalesed.set(nullptr); | ||
| 3817 | pushAnonFunctionScope(); | 3818 | pushAnonFunctionScope(); |
| 3818 | pushAnonVarArg(); | 3819 | pushAnonVarArg(); |
| 3819 | funcStart = &temp.emplace_back(); | 3820 | funcStart = &temp.emplace_back(); |
