1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
|
---@class vm
local vm = require 'vm.vm'
local guide = require 'parser.guide'
---@alias vm.runner.callback fun(src: parser.object, node?: vm.node)
---@class vm.runner
---@field _loc parser.object
---@field _casts parser.object[]
---@field _callback vm.runner.callback
---@field _mark table
---@field _has table<parser.object, true>
---@field _main parser.object
local mt = {}
mt.__index = mt
mt._index = 1
---@return parser.object[]
function mt:_getCasts()
local root = guide.getRoot(self._loc)
if not root._casts then
root._casts = {}
local docs = root.docs
for _, doc in ipairs(docs) do
if doc.type == 'doc.cast' and doc.loc then
root._casts[#root._casts+1] = doc
end
end
end
return root._casts
end
---@param obj parser.object
function mt:_markHas(obj)
while true do
if self._has[obj] then
return
end
self._has[obj] = true
if obj == self._main then
return
end
obj = obj.parent
end
end
function mt:_collect()
local startPos = self._loc.start
local finishPos = 0
for _, ref in ipairs(self._loc.ref) do
if ref.type == 'getlocal'
or ref.type == 'setlocal' then
self:_markHas(ref)
if ref.finish > finishPos then
finishPos = ref.finish
end
end
end
local casts = self:_getCasts()
for _, cast in ipairs(casts) do
if cast.loc[1] == self._loc[1]
and cast.start > startPos
and cast.finish < finishPos
and guide.getLocal(self._loc, self._loc[1], cast.start) == self._loc then
self._casts[#self._casts+1] = cast
end
end
end
---@param pos integer
---@param topNode vm.node
---@return vm.node
function mt:_fastWardCasts(pos, topNode)
for i = self._index, #self._casts do
local action = self._casts[i]
if action.start > pos then
self._index = i
return topNode
end
topNode = topNode:copy()
for _, cast in ipairs(action.casts) do
if cast.mode == '+' then
if cast.optional then
topNode:addOptional()
end
if cast.extends then
topNode:merge(vm.compileNode(cast.extends))
end
elseif cast.mode == '-' then
if cast.optional then
topNode:removeOptional()
end
if cast.extends then
topNode:removeNode(vm.compileNode(cast.extends))
end
else
if cast.extends then
topNode:clear()
topNode:merge(vm.compileNode(cast.extends))
end
end
end
end
return topNode
end
---@param action parser.object
---@param topNode vm.node
---@param outNode? vm.node
---@return vm.node topNode
---@return vm.node outNode
function mt:_lookIntoChild(action, topNode, outNode)
if not self._has[action]
or self._mark[action] then
return topNode, topNode or outNode
end
self._mark[action] = true
if action.type == 'getlocal' then
if action.node == self._loc then
self._callback(action, topNode)
if outNode then
topNode = topNode:copy():setTruthy()
outNode = outNode:copy():setFalsy()
end
end
elseif action.type == 'function' then
self:_lookIntoBlock(action, topNode:copy())
elseif action.type == 'unary' then
if not action[1] then
goto RETURN
end
if action.op.type == 'not' then
outNode = outNode or topNode:copy()
outNode, topNode = self:_lookIntoChild(action[1], topNode, outNode)
end
elseif action.type == 'binary' then
if not action[1] or not action[2] then
goto RETURN
end
if action.op.type == 'and' then
topNode = self:_lookIntoChild(action[1], topNode, topNode:copy())
topNode = self:_lookIntoChild(action[2], topNode, topNode:copy())
elseif action.op.type == 'or' then
outNode = outNode or topNode:copy()
local topNode1, outNode1 = self:_lookIntoChild(action[1], topNode, outNode)
local topNode2, outNode2 = self:_lookIntoChild(action[2], outNode1, outNode1:copy())
topNode = vm.createNode(topNode1, topNode2)
outNode = outNode2:copy()
elseif action.op.type == '=='
or action.op.type == '~=' then
local handler, checker
for i = 1, 2 do
if guide.isLiteral(action[i]) then
checker = action[i]
handler = action[3-i] -- Copilot tells me use `3-i` instead of `i%2+1`
end
end
if not handler then
goto RETURN
end
if handler.type == 'getlocal'
and handler.node == self._loc then
-- if x == y then
topNode = self:_lookIntoChild(handler, topNode, outNode)
local checkerNode = vm.compileNode(checker)
if action.op.type == '==' then
topNode = checkerNode
if outNode then
outNode:removeNode(topNode)
end
else
topNode:removeNode(checkerNode)
if outNode then
outNode = checkerNode
end
end
elseif handler.type == 'call'
and checker.type == 'string'
and handler.node.special == 'type'
and handler.args
and handler.args[1]
and handler.args[1].type == 'getlocal'
and handler.args[1].node == self._loc then
-- if type(x) == 'string' then
self:_lookIntoChild(handler, topNode:copy())
if action.op.type == '==' then
topNode:narrow(checker[1])
if outNode then
outNode:remove(checker[1])
end
else
topNode:remove(checker[1])
if outNode then
outNode:narrow(checker[1])
end
end
elseif handler.type == 'getlocal'
and checker.type == 'string' then
local nodeValue = vm.getObjectValue(handler.node)
if nodeValue
and nodeValue.type == 'select'
and nodeValue.sindex == 1 then
local call = nodeValue.vararg
if call
and call.type == 'call'
and call.node.special == 'type'
and call.args
and call.args[1]
and call.args[1].type == 'getlocal'
and call.args[1].node == self._loc then
-- `local tp = type(x);if tp == 'string' then`
if action.op.type == '==' then
topNode:narrow(checker[1])
if outNode then
outNode:remove(checker[1])
end
else
topNode:remove(checker[1])
if outNode then
outNode:narrow(checker[1])
end
end
end
end
end
end
elseif action.type == 'loop'
or action.type == 'in'
or action.type == 'repeat'
or action.type == 'for' then
topNode = self:_lookIntoBlock(action, topNode:copy())
elseif action.type == 'while' then
local blockNode, mainNode
if action.filter then
blockNode, mainNode = self:_lookIntoChild(action.filter, topNode:copy(), topNode:copy())
else
blockNode = topNode:copy()
mainNode = topNode:copy()
end
blockNode = self:_lookIntoBlock(action, blockNode:copy())
if mainNode then
topNode = mainNode:merge(blockNode)
end
elseif action.type == 'if' then
local hasElse
local mainNode = topNode:copy()
local blockNodes = {}
for _, subBlock in ipairs(action) do
local blockNode = mainNode:copy()
if subBlock.filter then
blockNode, mainNode = self:_lookIntoChild(subBlock.filter, blockNode, mainNode)
else
hasElse = true
mainNode:clear()
end
blockNode = self:_lookIntoBlock(subBlock, blockNode:copy())
local neverReturn = subBlock.hasReturn
or subBlock.hasGoTo
or subBlock.hasBreak
or subBlock.hasError
if not neverReturn then
blockNodes[#blockNodes+1] = blockNode
end
end
if not hasElse and not topNode:hasKnownType() then
mainNode:merge(vm.declareGlobal('type', 'unknown'))
end
for _, blockNode in ipairs(blockNodes) do
mainNode:merge(blockNode)
end
topNode = mainNode
elseif action.type == 'call' then
if action.node.special == 'assert' and action.args and action.args[1] then
topNode = self:_lookIntoChild(action.args[1], topNode, topNode:copy())
end
elseif action.type == 'paren' then
topNode, outNode = self:_lookIntoChild(action.exp, topNode, outNode)
elseif action.type == 'setlocal' then
if action.node == self._loc then
if action.value then
self:_lookIntoChild(action.value, topNode)
end
topNode = self._callback(action, topNode)
end
elseif action.type == 'local' then
if action.value
and action.value.type == 'select' then
local index = action.value.sindex
local call = action.value.vararg
if index == 1
and call.type == 'call'
and call.node
and call.node.special == 'type'
and call.args then
local getLoc = call.args[1]
if getLoc
and getLoc.type == 'getlocal'
and getLoc.node == self._loc then
for _, ref in ipairs(action.ref) do
self:_markHas(ref)
end
end
end
end
end
::RETURN::
guide.eachChild(action, function (src)
if self._has[src] then
self:_lookIntoChild(src, topNode)
end
end)
return topNode, outNode or topNode
end
---@param block parser.object
---@param topNode vm.node
---@return vm.node topNode
function mt:_lookIntoBlock(block, topNode)
if not self._has[block] then
return topNode
end
for _, action in ipairs(block) do
if self._has[action] then
topNode = self:_fastWardCasts(action.start, topNode)
topNode = self:_lookIntoChild(action, topNode)
end
end
topNode = self:_fastWardCasts(block.finish, topNode)
return topNode
end
---@param loc parser.object
---@param callback vm.runner.callback
function vm.launchRunner(loc, callback)
local main = guide.getParentBlock(loc)
if not main then
return
end
local self = setmetatable({
_loc = loc,
_casts = {},
_mark = {},
_has = {},
_main = main,
_callback = callback,
}, mt)
self:_collect()
self:_lookIntoBlock(main, vm.getNode(loc):copy())
end
|