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
|
---@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 _objs parser.object[]
---@field _callback vm.runner.callback
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
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._objs[#self._objs+1] = ref
if ref.start > finishPos then
finishPos = ref.start
end
end
end
if #self._objs == 0 then
return
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._objs[#self._objs+1] = cast
end
end
table.sort(self._objs, function (a, b)
return (a.range or a.start) < (b.range or b.start)
end)
end
---@param pos integer
---@param node vm.node
---@return vm.node
---@return parser.object?
function mt:_fastWard(pos, node)
for i = self._index, #self._objs do
local obj = self._objs[i]
if obj.start > pos then
self._index = i
return node, obj
end
if obj.type == 'getlocal' then
self._callback(obj, node)
elseif obj.type == 'setlocal' then
local newNode = self._callback(obj, node)
if newNode then
node = newNode:copy()
end
else
error('unexpected type: ' .. obj.type)
end
end
self._index = math.huge
return node, nil
end
---@param action parser.object
---@param topNode vm.node
---@param outNode? vm.node
---@return vm.node
function mt:_lookInto(action, topNode, outNode)
action = vm.getObjectValue(action) or action
if action.type == 'function'
or action.type == 'loop'
or action.type == 'in'
or action.type == 'repeat'
or action.type == 'for' then
self:_launchBlock(action, topNode:copy())
elseif action.type == 'while' then
local blockNode, mainNode = self:_lookInto(action.filter, topNode:copy(), topNode:copy())
self:_fastWard(action.filter.finish, blockNode)
self:_launchBlock(action, blockNode:copy())
topNode = mainNode
elseif action.type == 'if' then
local mainNode = topNode:copy()
local blockNode = topNode:copy()
for _, subBlock in ipairs(action) do
if subBlock.type == 'ifblock' then
blockNode, mainNode = self:_lookInto(subBlock.filter, blockNode, mainNode)
self:_fastWard(subBlock.filter.finish, blockNode)
blockNode = self:_launchBlock(subBlock, blockNode:copy())
local neverReturn = subBlock.hasReturn
or subBlock.hasGoTo
or subBlock.hasBreak
if not neverReturn then
mainNode:merge(blockNode)
end
end
end
topNode = mainNode
elseif action.type == 'getlocal' then
if action.node == self._loc then
topNode = self:_fastWard(action.finish, topNode)
topNode = topNode:copy():setTruthy()
if outNode then
outNode:setFalsy()
end
end
elseif action.type == 'unary' then
if not action[1] then
goto RETURN
end
if action.op.type == 'not' then
outNode, topNode = self:_lookInto(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:_lookInto(action[1], topNode)
topNode = self:_lookInto(action[2], topNode)
elseif action.op.type == 'or' then
outNode = outNode or topNode:copy()
local topNode1, outNode1 = self:_lookInto(action[1], topNode, outNode)
local topNode2, outNode2 = self:_lookInto(action[2], outNode1, outNode)
topNode = vm.createNode(topNode1, topNode2)
outNode = outNode2
elseif action.op.type == '=='
or action.op.type == '~=' then
local loc, checker
for i = 1, 2 do
if action[i].type == 'getlocal' and action[i].node == self._loc then
loc = action[i]
checker = action[3-i] -- Copilot tells me use `3-i` instead of `i%2+1`
else
loc = action[3-i]
checker = action[i]
end
end
if loc then
if guide.isLiteral(checker) then
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
end
end
end
elseif action.type == 'call' then
if action.node.special == 'assert' and action.args and action.args[1] then
topNode = self:_lookInto(action.args[1], topNode)
end
end
::RETURN::
topNode = self:_fastWard(action.finish, topNode)
return topNode, outNode
end
---@param block parser.object
---@param node vm.node
---@return vm.node
function mt:_launchBlock(block, node)
local topNode, top = self:_fastWard(block.start, node)
if not top then
return topNode
end
for _, action in ipairs(block) do
local finish = action.range or action.finish
if finish < top.start then
goto CONTINUE
end
topNode = self:_lookInto(action, topNode)
topNode, top = self:_fastWard(action.finish, topNode)
if not top then
return topNode
end
::CONTINUE::
end
topNode = self:_fastWard(block.finish, topNode)
return topNode
end
---@param loc parser.object
---@param callback vm.runner.callback
function vm.launchRunner(loc, callback)
local self = setmetatable({
_loc = loc,
_objs = {},
_callback = callback,
}, mt)
self:_collect()
if #self._objs == 0 then
return
end
self:_launchBlock(guide.getParentBlock(loc), vm.getNode(loc):copy())
end
|
