1856 lines
59 KiB
Lua
1856 lines
59 KiB
Lua
|
local guide = require 'parser.guide'
|
|||
|
|
local util = require 'utility'
|
|||
|
|
local config = require 'config'
|
|||
|
|
local rpath = require 'workspace.require-path'
|
|||
|
|
local files = require 'files'
|
|||
|
|
---@class vm
|
|||
|
|
local vm = require 'vm.vm'
|
|||
|
|
|
|||
|
|
local LOCK = {}
|
|||
|
|
|
|||
|
|
---@class parser.object
|
|||
|
|
---@field _compiledNodes boolean
|
|||
|
|
---@field _node vm.node
|
|||
|
|
---@field _globalBase table
|
|||
|
|
---@field cindex integer
|
|||
|
|
---@field func parser.object
|
|||
|
|
---@field operators? parser.object[]
|
|||
|
|
|
|||
|
|
-- 该函数有副作用，会给source绑定node！
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@return boolean
|
|||
|
|
local function bindDocs(source)
|
|||
|
|
local docs = source.bindDocs
|
|||
|
|
if not docs then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
for i = #docs, 1, -1 do
|
|||
|
|
local doc = docs[i]
|
|||
|
|
if doc.type == 'doc.type' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
if doc.type == 'doc.class' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
if doc.type == 'doc.param' then
|
|||
|
|
local node = vm.compileNode(doc)
|
|||
|
|
if doc.optional then
|
|||
|
|
node:addOptional()
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
if doc.type == 'doc.module' then
|
|||
|
|
local name = doc.module
|
|||
|
|
if not name then
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
local uri = rpath.findUrisByRequireName(guide.getUri(source), name)[1]
|
|||
|
|
if not uri then
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
local state = files.getState(uri)
|
|||
|
|
local ast = state and state.ast
|
|||
|
|
if not ast then
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.compileNode(ast))
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
if doc.type == 'doc.overload' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param key any
|
|||
|
|
---@param ref boolean
|
|||
|
|
---@param pushResult fun(res: parser.object, markDoc?: boolean)
|
|||
|
|
local function searchFieldByLocalID(source, key, ref, pushResult)
|
|||
|
|
local fields
|
|||
|
|
if key then
|
|||
|
|
fields = vm.getLocalSourcesSets(source, key)
|
|||
|
|
if ref then
|
|||
|
|
local gets = vm.getLocalSourcesGets(source, key)
|
|||
|
|
if gets then
|
|||
|
|
fields = fields or {}
|
|||
|
|
for _, src in ipairs(gets) do
|
|||
|
|
fields[#fields+1] = src
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
fields = vm.getLocalFields(source, false)
|
|||
|
|
end
|
|||
|
|
if not fields then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local hasMarkDoc = {}
|
|||
|
|
for _, src in ipairs(fields) do
|
|||
|
|
if src.bindDocs then
|
|||
|
|
if bindDocs(src) then
|
|||
|
|
local skey = guide.getKeyName(src)
|
|||
|
|
if skey then
|
|||
|
|
hasMarkDoc[skey] = true
|
|||
|
|
end
|
|||
|
|
pushResult(src, true)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
for _, src in ipairs(fields) do
|
|||
|
|
local skey = guide.getKeyName(src)
|
|||
|
|
if not hasMarkDoc[skey] then
|
|||
|
|
pushResult(src)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param suri uri
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param key any
|
|||
|
|
---@param ref boolean
|
|||
|
|
---@param pushResult fun(res: parser.object, markDoc?: boolean)
|
|||
|
|
local function searchFieldByGlobalID(suri, source, key, ref, pushResult)
|
|||
|
|
local node = source._globalNode
|
|||
|
|
if not node then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if node.cate == 'variable' then
|
|||
|
|
if key then
|
|||
|
|
if type(key) ~= 'string' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local global = vm.getGlobal('variable', node.name, key)
|
|||
|
|
if global then
|
|||
|
|
for _, set in ipairs(global:getSets(suri)) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
for _, get in ipairs(global:getGets(suri)) do
|
|||
|
|
pushResult(get)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
local globals = vm.getGlobalFields('variable', node.name)
|
|||
|
|
for _, global in ipairs(globals) do
|
|||
|
|
for _, set in ipairs(global:getSets(suri)) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
for _, get in ipairs(global:getGets(suri)) do
|
|||
|
|
pushResult(get)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if node.cate == 'type' then
|
|||
|
|
vm.getClassFields(suri, node, key, ref, pushResult)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local searchFieldSwitch = util.switch()
|
|||
|
|
: case 'table'
|
|||
|
|
: call(function (suri, source, key, ref, pushResult)
|
|||
|
|
local hasFiled = false
|
|||
|
|
for _, field in ipairs(source) do
|
|||
|
|
if field.type == 'tablefield'
|
|||
|
|
or field.type == 'tableindex' then
|
|||
|
|
local fieldKey = guide.getKeyName(field)
|
|||
|
|
if key == nil
|
|||
|
|
or key == fieldKey then
|
|||
|
|
hasFiled = true
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if field.type == 'tableexp' then
|
|||
|
|
if key == nil
|
|||
|
|
or key == field.tindex then
|
|||
|
|
hasFiled = true
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if field.type == 'varargs' then
|
|||
|
|
if not hasFiled
|
|||
|
|
and type(key) == 'number'
|
|||
|
|
and key >= 1
|
|||
|
|
and math.tointeger(key) then
|
|||
|
|
hasFiled = true
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
if key == nil then
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'string'
|
|||
|
|
: case 'doc.type.string'
|
|||
|
|
: call(function (suri, source, key, ref, pushResult)
|
|||
|
|
-- change to `string: stringlib` ?
|
|||
|
|
local stringlib = vm.getGlobal('type', 'stringlib')
|
|||
|
|
if stringlib then
|
|||
|
|
vm.getClassFields(suri, stringlib, key, ref, pushResult)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.array'
|
|||
|
|
: call(function (suri, source, key, ref, pushResult)
|
|||
|
|
if type(key) == 'number' then
|
|||
|
|
if key < 1
|
|||
|
|
or not math.tointeger(key) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
pushResult(source.node)
|
|||
|
|
end
|
|||
|
|
if type(key) == 'table' then
|
|||
|
|
if vm.isSubType(suri, key, 'integer') then
|
|||
|
|
pushResult(source.node)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.table'
|
|||
|
|
: call(function (suri, source, key, ref, pushResult)
|
|||
|
|
for _, field in ipairs(source.fields) do
|
|||
|
|
local fieldKey = field.name
|
|||
|
|
if fieldKey.type == 'doc.type' then
|
|||
|
|
local fieldNode = vm.compileNode(fieldKey)
|
|||
|
|
for fn in fieldNode:eachObject() do
|
|||
|
|
if fn.type == 'global' and fn.cate == 'type' then
|
|||
|
|
if key == nil
|
|||
|
|
or fn.name == 'any'
|
|||
|
|
or (fn.name == 'boolean' and type(key) == 'boolean')
|
|||
|
|
or (fn.name == 'number' and type(key) == 'number')
|
|||
|
|
or (fn.name == 'integer' and math.tointeger(key))
|
|||
|
|
or (fn.name == 'string' and type(key) == 'string') then
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if fieldKey.type == 'doc.field.name' then
|
|||
|
|
if key == nil or fieldKey[1] == key then
|
|||
|
|
pushResult(field)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'global'
|
|||
|
|
: call(function (suri, node, key, ref, pushResult)
|
|||
|
|
if node.cate == 'variable' then
|
|||
|
|
if key then
|
|||
|
|
if type(key) ~= 'string' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local global = vm.getGlobal('variable', node.name, key)
|
|||
|
|
if global then
|
|||
|
|
for _, set in ipairs(global:getSets(suri)) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
if ref then
|
|||
|
|
for _, get in ipairs(global:getGets(suri)) do
|
|||
|
|
pushResult(get)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
local globals = vm.getGlobalFields('variable', node.name)
|
|||
|
|
for _, global in ipairs(globals) do
|
|||
|
|
for _, set in ipairs(global:getSets(suri)) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
if ref then
|
|||
|
|
for _, get in ipairs(global:getGets(suri)) do
|
|||
|
|
pushResult(get)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if node.cate == 'type' then
|
|||
|
|
vm.getClassFields(suri, node, key, ref, pushResult)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: default(function (suri, source, key, ref, pushResult)
|
|||
|
|
searchFieldByLocalID(source, key, ref, pushResult)
|
|||
|
|
searchFieldByGlobalID(suri, source, key, ref, pushResult)
|
|||
|
|
end)
|
|||
|
|
|
|||
|
|
---@param suri uri
|
|||
|
|
---@param object vm.global
|
|||
|
|
---@param key string|vm.global
|
|||
|
|
---@param ref boolean
|
|||
|
|
---@param pushResult fun(field: vm.object, isMark?: boolean)
|
|||
|
|
function vm.getClassFields(suri, object, key, ref, pushResult)
|
|||
|
|
local mark = {}
|
|||
|
|
|
|||
|
|
local function searchClass(class, searchedFields)
|
|||
|
|
local name = class.name
|
|||
|
|
if mark[name] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
mark[name] = true
|
|||
|
|
searchedFields = searchedFields or {}
|
|||
|
|
for _, set in ipairs(class:getSets(suri)) do
|
|||
|
|
if set.type == 'doc.class' then
|
|||
|
|
-- check ---@field
|
|||
|
|
local hasFounded = {}
|
|||
|
|
|
|||
|
|
local function copyToSearched()
|
|||
|
|
for fieldKey in pairs(hasFounded) do
|
|||
|
|
searchedFields[fieldKey] = true
|
|||
|
|
hasFounded[fieldKey] = nil
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
for _, field in ipairs(set.fields) do
|
|||
|
|
local fieldKey = guide.getKeyName(field)
|
|||
|
|
if fieldKey then
|
|||
|
|
-- ---@field x boolean -> class.x
|
|||
|
|
if key == nil
|
|||
|
|
or fieldKey == key then
|
|||
|
|
if not searchedFields[fieldKey] then
|
|||
|
|
pushResult(field, true)
|
|||
|
|
hasFounded[fieldKey] = true
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
elseif key and not hasFounded[key] then
|
|||
|
|
local keyType = type(key)
|
|||
|
|
if keyType == 'table' then
|
|||
|
|
-- ---@field [integer] boolean -> class[integer]
|
|||
|
|
local fieldNode = vm.compileNode(field.field)
|
|||
|
|
if vm.isSubType(suri, key.name, fieldNode) then
|
|||
|
|
local nkey = '|' .. key.name
|
|||
|
|
if not searchedFields[nkey] then
|
|||
|
|
pushResult(field, true)
|
|||
|
|
hasFounded[nkey] = true
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
local typeName
|
|||
|
|
if keyType == 'number' then
|
|||
|
|
if math.tointeger(key) then
|
|||
|
|
typeName = 'integer'
|
|||
|
|
else
|
|||
|
|
typeName = 'number'
|
|||
|
|
end
|
|||
|
|
elseif keyType == 'boolean'
|
|||
|
|
or keyType == 'string' then
|
|||
|
|
typeName = keyType
|
|||
|
|
end
|
|||
|
|
if typeName and field.field.type ~= 'doc.field.name' then
|
|||
|
|
-- ---@field [integer] boolean -> class[1]
|
|||
|
|
local fieldNode = vm.compileNode(field.field)
|
|||
|
|
if vm.isSubType(suri, typeName, fieldNode) then
|
|||
|
|
local nkey = '|' .. typeName
|
|||
|
|
if not searchedFields[nkey] then
|
|||
|
|
pushResult(field, true)
|
|||
|
|
hasFounded[nkey] = true
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
copyToSearched()
|
|||
|
|
-- check local field and global field
|
|||
|
|
if not searchedFields[key] and set.bindSource then
|
|||
|
|
local src = set.bindSource
|
|||
|
|
if src.value and src.value.type == 'table' then
|
|||
|
|
searchFieldSwitch('table', suri, src.value, key, ref, function (field)
|
|||
|
|
local fieldKey = guide.getKeyName(field)
|
|||
|
|
if fieldKey then
|
|||
|
|
if not searchedFields[fieldKey]
|
|||
|
|
and guide.isSet(field) then
|
|||
|
|
hasFounded[fieldKey] = true
|
|||
|
|
pushResult(field, true)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
copyToSearched()
|
|||
|
|
searchFieldSwitch(src.type, suri, src, key, ref, function (field)
|
|||
|
|
local fieldKey = guide.getKeyName(field)
|
|||
|
|
if fieldKey and not searchedFields[fieldKey] then
|
|||
|
|
if not searchedFields[fieldKey]
|
|||
|
|
and guide.isSet(field)
|
|||
|
|
and field.value then
|
|||
|
|
if vm.getLocalID(field)
|
|||
|
|
and vm.getLocalID(field) == vm.getLocalID(field.value) then
|
|||
|
|
elseif src._globalNode
|
|||
|
|
and src._globalNode == field.value._globalNode then
|
|||
|
|
else
|
|||
|
|
hasFounded[fieldKey] = true
|
|||
|
|
end
|
|||
|
|
pushResult(field, true)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
copyToSearched()
|
|||
|
|
end
|
|||
|
|
-- look into extends(if field not found)
|
|||
|
|
if not searchedFields[key] and set.extends then
|
|||
|
|
for _, extend in ipairs(set.extends) do
|
|||
|
|
if extend.type == 'doc.extends.name' then
|
|||
|
|
local extendType = vm.getGlobal('type', extend[1])
|
|||
|
|
if extendType then
|
|||
|
|
searchClass(extendType, searchedFields)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
copyToSearched()
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local function searchGlobal(class)
|
|||
|
|
if class.cate == 'type' and class.name == '_G' then
|
|||
|
|
if key == nil then
|
|||
|
|
local sets = vm.getGlobalSets(suri, 'variable')
|
|||
|
|
for _, set in ipairs(sets) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
elseif type(key) == 'string' then
|
|||
|
|
local global = vm.getGlobal('variable', key)
|
|||
|
|
if global then
|
|||
|
|
for _, set in ipairs(global:getSets(suri)) do
|
|||
|
|
pushResult(set)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
searchClass(object)
|
|||
|
|
searchGlobal(object)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@class parser.object
|
|||
|
|
---@field _sign vm.sign|false
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@return vm.sign|false
|
|||
|
|
local function getObjectSign(source)
|
|||
|
|
if source._sign ~= nil then
|
|||
|
|
return source._sign
|
|||
|
|
end
|
|||
|
|
source._sign = false
|
|||
|
|
if source.type == 'function' then
|
|||
|
|
if not source.bindDocs then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
for _, doc in ipairs(source.bindDocs) do
|
|||
|
|
if doc.type == 'doc.generic' then
|
|||
|
|
if not source._sign then
|
|||
|
|
source._sign = vm.createSign()
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not source._sign then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
if source.args then
|
|||
|
|
for _, arg in ipairs(source.args) do
|
|||
|
|
local argNode = vm.compileNode(arg)
|
|||
|
|
if arg.optional then
|
|||
|
|
argNode:addOptional()
|
|||
|
|
end
|
|||
|
|
source._sign:addSign(argNode)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if source.type == 'doc.type.function'
|
|||
|
|
or source.type == 'doc.type.table'
|
|||
|
|
or source.type == 'doc.type.array' then
|
|||
|
|
local hasGeneric
|
|||
|
|
guide.eachSourceType(source, 'doc.generic.name', function ()
|
|||
|
|
hasGeneric = true
|
|||
|
|
end)
|
|||
|
|
if not hasGeneric then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
source._sign = vm.createSign()
|
|||
|
|
if source.type == 'doc.type.function' then
|
|||
|
|
for _, arg in ipairs(source.args) do
|
|||
|
|
if arg.extends then
|
|||
|
|
local argNode = vm.compileNode(arg.extends)
|
|||
|
|
if arg.optional then
|
|||
|
|
argNode:addOptional()
|
|||
|
|
end
|
|||
|
|
source._sign:addSign(argNode)
|
|||
|
|
else
|
|||
|
|
source._sign:addSign(vm.createNode())
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
return source._sign
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param func parser.object
|
|||
|
|
---@param index integer
|
|||
|
|
---@return (parser.object|vm.generic)?
|
|||
|
|
function vm.getReturnOfFunction(func, index)
|
|||
|
|
if func.type == 'function' then
|
|||
|
|
if not func._returns then
|
|||
|
|
func._returns = {}
|
|||
|
|
end
|
|||
|
|
if not func._returns[index] then
|
|||
|
|
func._returns[index] = {
|
|||
|
|
type = 'function.return',
|
|||
|
|
parent = func,
|
|||
|
|
returnIndex = index,
|
|||
|
|
}
|
|||
|
|
end
|
|||
|
|
return func._returns[index]
|
|||
|
|
end
|
|||
|
|
if func.type == 'doc.type.function' then
|
|||
|
|
local rtn = func.returns[index]
|
|||
|
|
if not rtn then
|
|||
|
|
local lastReturn = func.returns[#func.returns]
|
|||
|
|
if lastReturn and lastReturn.name and lastReturn.name[1] == '...' then
|
|||
|
|
rtn = lastReturn
|
|||
|
|
else
|
|||
|
|
return nil
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
local sign = getObjectSign(func)
|
|||
|
|
if not sign then
|
|||
|
|
return rtn
|
|||
|
|
end
|
|||
|
|
return vm.createGeneric(rtn, sign)
|
|||
|
|
end
|
|||
|
|
return nil
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param args parser.object[]
|
|||
|
|
---@return vm.node
|
|||
|
|
local function getReturnOfSetMetaTable(args)
|
|||
|
|
local tbl = args[1]
|
|||
|
|
local mt = args[2]
|
|||
|
|
local node = vm.createNode()
|
|||
|
|
if tbl then
|
|||
|
|
node:merge(vm.compileNode(tbl))
|
|||
|
|
end
|
|||
|
|
if mt then
|
|||
|
|
vm.compileByParentNode(mt, '__index', false, function (src)
|
|||
|
|
for n in vm.compileNode(src):eachObject() do
|
|||
|
|
if n.type == 'global'
|
|||
|
|
or n.type == 'local'
|
|||
|
|
or n.type == 'table'
|
|||
|
|
or n.type == 'doc.type.table' then
|
|||
|
|
node:merge(n)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
return node
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
local function matchCall(source)
|
|||
|
|
local call = source.parent
|
|||
|
|
if not call
|
|||
|
|
or call.type ~= 'call'
|
|||
|
|
or call.node ~= source then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local funcs = vm.getMatchedFunctions(source, call.args)
|
|||
|
|
local myNode = vm.getNode(source)
|
|||
|
|
if not myNode then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local needRemove
|
|||
|
|
for n in myNode:eachObject() do
|
|||
|
|
if n.type == 'function'
|
|||
|
|
or n.type == 'doc.type.function' then
|
|||
|
|
if not util.arrayHas(funcs, n) then
|
|||
|
|
if not needRemove then
|
|||
|
|
needRemove = vm.createNode()
|
|||
|
|
end
|
|||
|
|
needRemove:merge(n)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if needRemove then
|
|||
|
|
local newNode = myNode:copy()
|
|||
|
|
newNode:removeNode(needRemove)
|
|||
|
|
newNode:setData('originNode', myNode)
|
|||
|
|
vm.setNode(source, newNode, true)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param func parser.object
|
|||
|
|
---@param index integer
|
|||
|
|
---@param args parser.object[]
|
|||
|
|
---@return vm.node
|
|||
|
|
local function getReturn(func, index, args)
|
|||
|
|
if not func._callReturns then
|
|||
|
|
func._callReturns = {}
|
|||
|
|
end
|
|||
|
|
if not func._callReturns[index] then
|
|||
|
|
local call = func.parent
|
|||
|
|
func._callReturns[index] = {
|
|||
|
|
type = 'call.return',
|
|||
|
|
parent = call,
|
|||
|
|
func = func,
|
|||
|
|
cindex = index,
|
|||
|
|
args = args,
|
|||
|
|
start = call.start,
|
|||
|
|
finish = call.finish,
|
|||
|
|
}
|
|||
|
|
end
|
|||
|
|
return vm.compileNode(func._callReturns[index])
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@return boolean
|
|||
|
|
local function bindAs(source)
|
|||
|
|
local root = guide.getRoot(source)
|
|||
|
|
local docs = root.docs
|
|||
|
|
if not docs then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
local ases = docs._asCache
|
|||
|
|
if not ases then
|
|||
|
|
ases = {}
|
|||
|
|
docs._asCache = ases
|
|||
|
|
for _, doc in ipairs(docs) do
|
|||
|
|
if doc.type == 'doc.as' and doc.as and doc.touch then
|
|||
|
|
ases[#ases+1] = doc
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
table.sort(ases, function (a, b)
|
|||
|
|
return a.touch < b.touch
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if #ases == 0 then
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local max = #ases
|
|||
|
|
local index
|
|||
|
|
local left = 1
|
|||
|
|
local right = max
|
|||
|
|
for _ = 1, 1000 do
|
|||
|
|
if left == right then
|
|||
|
|
index = left
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
index = left + (right - left) // 2
|
|||
|
|
local doc = ases[index]
|
|||
|
|
if doc.touch < source.finish then
|
|||
|
|
left = index + 1
|
|||
|
|
else
|
|||
|
|
right = index
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local doc = ases[index]
|
|||
|
|
if doc and doc.touch == source.finish then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc.as), true)
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param key? string|vm.global
|
|||
|
|
---@param pushResult fun(source: parser.object)
|
|||
|
|
function vm.compileByParentNode(source, key, ref, pushResult)
|
|||
|
|
local parentNode = vm.compileNode(source)
|
|||
|
|
local docedResults = {}
|
|||
|
|
local commonResults = {}
|
|||
|
|
local mark = {}
|
|||
|
|
local suri = guide.getUri(source)
|
|||
|
|
local hasClass
|
|||
|
|
for node in parentNode:eachObject() do
|
|||
|
|
if node.type == 'global'
|
|||
|
|
and node.cate == 'type'
|
|||
|
|
---@cast node vm.global
|
|||
|
|
and not guide.isBasicType(node.name) then
|
|||
|
|
hasClass = true
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
for node in parentNode:eachObject() do
|
|||
|
|
if not hasClass
|
|||
|
|
or (
|
|||
|
|
node.type == 'global'
|
|||
|
|
and node.cate == 'type'
|
|||
|
|
---@cast node vm.global
|
|||
|
|
and not guide.isBasicType(node.name)
|
|||
|
|
)
|
|||
|
|
or guide.isLiteral(node) then
|
|||
|
|
searchFieldSwitch(node.type, suri, node, key, ref, function (res, markDoc)
|
|||
|
|
if mark[res] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
mark[res] = true
|
|||
|
|
if markDoc then
|
|||
|
|
docedResults[#docedResults+1] = res
|
|||
|
|
else
|
|||
|
|
commonResults[#commonResults+1] = res
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if not next(mark) then
|
|||
|
|
searchFieldByLocalID(source, key, ref, function (res, markDoc)
|
|||
|
|
if mark[res] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
mark[res] = true
|
|||
|
|
if markDoc then
|
|||
|
|
docedResults[#docedResults+1] = res
|
|||
|
|
else
|
|||
|
|
commonResults[#commonResults+1] = res
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if #docedResults > 0 then
|
|||
|
|
for _, res in ipairs(docedResults) do
|
|||
|
|
pushResult(res)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if #docedResults == 0 or key == nil then
|
|||
|
|
for _, res in ipairs(commonResults) do
|
|||
|
|
pushResult(res)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param list parser.object[]
|
|||
|
|
---@param index integer
|
|||
|
|
---@return vm.node
|
|||
|
|
---@return parser.object?
|
|||
|
|
function vm.selectNode(list, index)
|
|||
|
|
local exp
|
|||
|
|
if list[index] then
|
|||
|
|
exp = list[index]
|
|||
|
|
index = 1
|
|||
|
|
else
|
|||
|
|
for i = index, 1, -1 do
|
|||
|
|
if list[i] then
|
|||
|
|
local last = list[i]
|
|||
|
|
if last.type == 'call'
|
|||
|
|
or last.type == 'varargs' then
|
|||
|
|
index = index - i + 1
|
|||
|
|
exp = last
|
|||
|
|
end
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not exp then
|
|||
|
|
return vm.createNode(vm.declareGlobal('type', 'nil')), nil
|
|||
|
|
end
|
|||
|
|
---@type vm.node?
|
|||
|
|
local result
|
|||
|
|
if exp.type == 'call' then
|
|||
|
|
result = getReturn(exp.node, index, exp.args)
|
|||
|
|
if result:isEmpty() then
|
|||
|
|
result:merge(vm.declareGlobal('type', 'unknown'))
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
---@type vm.node
|
|||
|
|
result = vm.compileNode(exp)
|
|||
|
|
if result:isEmpty() then
|
|||
|
|
result:merge(vm.declareGlobal('type', 'unknown'))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
return result, exp
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param list parser.object[]
|
|||
|
|
---@param index integer
|
|||
|
|
---@return vm.node
|
|||
|
|
local function selectNode(source, list, index)
|
|||
|
|
local result = vm.selectNode(list, index)
|
|||
|
|
if source.type == 'function.return' then
|
|||
|
|
-- remove any for returns
|
|||
|
|
local rtnNode = vm.createNode()
|
|||
|
|
for n in result:eachObject() do
|
|||
|
|
if guide.isLiteral(n) then
|
|||
|
|
rtnNode:merge(n)
|
|||
|
|
end
|
|||
|
|
if n.type == 'global' and n.cate == 'type' then
|
|||
|
|
if n.name ~= 'any' then
|
|||
|
|
rtnNode:merge(n)
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
rtnNode:merge(n)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, rtnNode)
|
|||
|
|
return rtnNode
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, result)
|
|||
|
|
return result
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param node vm.node.object
|
|||
|
|
---@return boolean
|
|||
|
|
local function isValidCallArgNode(source, node)
|
|||
|
|
if source.type == 'function' then
|
|||
|
|
return node.type == 'doc.type.function'
|
|||
|
|
end
|
|||
|
|
if source.type == 'table' then
|
|||
|
|
return node.type == 'doc.type.table' or node.type == 'doc.type.array'
|
|||
|
|
or ( node.type == 'global'
|
|||
|
|
and node.cate == 'type'
|
|||
|
|
---@cast node vm.global
|
|||
|
|
and not guide.isBasicType(node.name)
|
|||
|
|
)
|
|||
|
|
end
|
|||
|
|
if source.type == 'dummyarg' then
|
|||
|
|
return true
|
|||
|
|
end
|
|||
|
|
return false
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param func parser.object
|
|||
|
|
---@param index integer
|
|||
|
|
---@return parser.object?
|
|||
|
|
local function getFuncArg(func, index)
|
|||
|
|
local args = func.args
|
|||
|
|
if not args then
|
|||
|
|
return nil
|
|||
|
|
end
|
|||
|
|
if args[index] then
|
|||
|
|
return args[index]
|
|||
|
|
end
|
|||
|
|
local lastArg = args[#args]
|
|||
|
|
if lastArg and lastArg.type == '...' then
|
|||
|
|
return lastArg
|
|||
|
|
end
|
|||
|
|
return nil
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param arg parser.object
|
|||
|
|
---@param call parser.object
|
|||
|
|
---@param callNode vm.node
|
|||
|
|
---@param fixIndex integer
|
|||
|
|
---@param myIndex integer
|
|||
|
|
local function compileCallArgNode(arg, call, callNode, fixIndex, myIndex)
|
|||
|
|
local eventIndex, eventMap
|
|||
|
|
if call.args then
|
|||
|
|
for i = 1, 2 do
|
|||
|
|
local eventArg = call.args[i + fixIndex]
|
|||
|
|
if not eventArg then
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
eventMap = vm.getLiterals(eventArg)
|
|||
|
|
if eventMap then
|
|||
|
|
eventIndex = i
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
for n in callNode:eachObject() do
|
|||
|
|
if n.type == 'function' then
|
|||
|
|
---@cast n parser.object
|
|||
|
|
local sign = getObjectSign(n)
|
|||
|
|
local farg = getFuncArg(n, myIndex)
|
|||
|
|
if farg then
|
|||
|
|
for fn in vm.compileNode(farg):eachObject() do
|
|||
|
|
if isValidCallArgNode(arg, fn) then
|
|||
|
|
if fn.type == 'doc.type.function' then
|
|||
|
|
---@cast fn parser.object
|
|||
|
|
if sign then
|
|||
|
|
local generic = vm.createGeneric(fn, sign)
|
|||
|
|
local args = {}
|
|||
|
|
for i = fixIndex + 1, myIndex - 1 do
|
|||
|
|
args[#args+1] = call.args[i]
|
|||
|
|
end
|
|||
|
|
fn = generic:resolve(guide.getUri(call), args)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
vm.setNode(arg, fn)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if n.type == 'doc.type.function' then
|
|||
|
|
---@cast n parser.object
|
|||
|
|
local myEvent
|
|||
|
|
if n.args[eventIndex] then
|
|||
|
|
local argNode = vm.compileNode(n.args[eventIndex])
|
|||
|
|
myEvent = argNode:get(1)
|
|||
|
|
end
|
|||
|
|
if not myEvent
|
|||
|
|
or not eventMap
|
|||
|
|
or myIndex <= eventIndex
|
|||
|
|
or myEvent.type ~= 'doc.type.string'
|
|||
|
|
or eventMap[myEvent[1]] then
|
|||
|
|
local farg = getFuncArg(n, myIndex)
|
|||
|
|
if farg then
|
|||
|
|
for fn in vm.compileNode(farg):eachObject() do
|
|||
|
|
if isValidCallArgNode(arg, fn) then
|
|||
|
|
vm.setNode(arg, fn)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param arg parser.object
|
|||
|
|
---@param call parser.object
|
|||
|
|
---@param index? integer
|
|||
|
|
---@return vm.node?
|
|||
|
|
function vm.compileCallArg(arg, call, index)
|
|||
|
|
if not index then
|
|||
|
|
for i, carg in ipairs(call.args) do
|
|||
|
|
if carg == arg then
|
|||
|
|
index = i
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not index then
|
|||
|
|
return nil
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local callNode = vm.compileNode(call.node)
|
|||
|
|
compileCallArgNode(arg, call, callNode, 0, index)
|
|||
|
|
|
|||
|
|
if call.node.special == 'pcall'
|
|||
|
|
or call.node.special == 'xpcall' then
|
|||
|
|
local fixIndex = call.node.special == 'pcall' and 1 or 2
|
|||
|
|
if call.args and call.args[1] then
|
|||
|
|
callNode = vm.compileNode(call.args[1])
|
|||
|
|
compileCallArgNode(arg, call, callNode, fixIndex, index - fixIndex)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
return vm.getNode(arg)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@class parser.object
|
|||
|
|
---@field _iterator? table
|
|||
|
|
---@field _iterArgs? table
|
|||
|
|
---@field _iterVars? table<parser.object, vm.node>
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
---@param target parser.object
|
|||
|
|
local function compileForVars(source, target)
|
|||
|
|
if not source.exps then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
-- for k, v in pairs(t) do
|
|||
|
|
--> for k, v in iterator, status, initValue do
|
|||
|
|
--> local k, v = iterator(status, initValue)
|
|||
|
|
if not source._iterator then
|
|||
|
|
source._iterator = {
|
|||
|
|
type = 'dummyfunc',
|
|||
|
|
parent = source,
|
|||
|
|
}
|
|||
|
|
source._iterArgs = {{},{}}
|
|||
|
|
source._iterVars = {}
|
|||
|
|
end
|
|||
|
|
-- iterator
|
|||
|
|
if not vm.getNode(source._iterator) then
|
|||
|
|
selectNode(source._iterator, source.exps, 1)
|
|||
|
|
end
|
|||
|
|
-- status
|
|||
|
|
if not vm.getNode(source._iterArgs[1]) then
|
|||
|
|
selectNode(source._iterArgs[1], source.exps, 2)
|
|||
|
|
end
|
|||
|
|
-- initValue
|
|||
|
|
if not vm.getNode(source._iterArgs[2]) then
|
|||
|
|
selectNode(source._iterArgs[2], source.exps, 3)
|
|||
|
|
end
|
|||
|
|
if source.keys then
|
|||
|
|
for i, loc in ipairs(source.keys) do
|
|||
|
|
if loc == target then
|
|||
|
|
local node = getReturn(source._iterator, i, source._iterArgs)
|
|||
|
|
node:removeOptional()
|
|||
|
|
vm.setNode(loc, node)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
local function compileLocal(source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
|
|||
|
|
local hasMarkDoc
|
|||
|
|
if source.bindDocs then
|
|||
|
|
hasMarkDoc = bindDocs(source)
|
|||
|
|
end
|
|||
|
|
local hasMarkParam
|
|||
|
|
if source.type == 'self' and not hasMarkDoc then
|
|||
|
|
hasMarkParam = true
|
|||
|
|
if source.parent.type == 'callargs' then
|
|||
|
|
-- obj:func(...)
|
|||
|
|
if source.parent.parent and source.parent.parent.node and source.parent.parent.node.node then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.parent.parent.node.node))
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
-- function obj:func(...)
|
|||
|
|
if source.parent.parent and source.parent.parent.parent and source.parent.parent.parent.node then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.parent.parent.parent.node))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
vm.getNode(source):remove 'function'
|
|||
|
|
end
|
|||
|
|
local hasMarkValue
|
|||
|
|
if not hasMarkDoc and source.value then
|
|||
|
|
hasMarkValue = true
|
|||
|
|
if source.value.type == 'table' then
|
|||
|
|
vm.setNode(source, source.value)
|
|||
|
|
elseif source.value.type ~= 'nil' then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.value))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not hasMarkValue and not hasMarkValue then
|
|||
|
|
if source.ref then
|
|||
|
|
for _, ref in ipairs(source.ref) do
|
|||
|
|
if ref.type == 'setlocal'
|
|||
|
|
and ref.value
|
|||
|
|
and ref.value.type == 'function' then
|
|||
|
|
vm.setNode(source, vm.compileNode(ref.value))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
-- function x.y(self, ...) --> function x:y(...)
|
|||
|
|
if source[1] == 'self'
|
|||
|
|
and not hasMarkDoc
|
|||
|
|
and source.parent.type == 'funcargs'
|
|||
|
|
and source.parent[1] == source then
|
|||
|
|
local setfield = source.parent.parent.parent
|
|||
|
|
if setfield.type == 'setfield' then
|
|||
|
|
hasMarkParam = true
|
|||
|
|
vm.setNode(source, vm.compileNode(setfield.node))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if source.parent.type == 'funcargs' and not hasMarkDoc and not hasMarkParam then
|
|||
|
|
local func = source.parent.parent
|
|||
|
|
local funcNode = vm.compileNode(func)
|
|||
|
|
local hasDocArg
|
|||
|
|
for n in funcNode:eachObject() do
|
|||
|
|
if n.type == 'doc.type.function' then
|
|||
|
|
for index, arg in ipairs(n.args) do
|
|||
|
|
if func.args[index] == source then
|
|||
|
|
local argNode = vm.compileNode(arg)
|
|||
|
|
for an in argNode:eachObject() do
|
|||
|
|
if an.type ~= 'doc.generic.name' then
|
|||
|
|
vm.setNode(source, an)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
hasDocArg = true
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not hasDocArg then
|
|||
|
|
vm.setNode(source, vm.declareGlobal('type', 'any'))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
-- for x in ... do
|
|||
|
|
if source.parent.type == 'in' then
|
|||
|
|
compileForVars(source.parent, source)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
-- for x = ... do
|
|||
|
|
if source.parent.type == 'loop' then
|
|||
|
|
if source.parent.loc == source then
|
|||
|
|
if bindDocs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.declareGlobal('type', 'integer'))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
vm.getNode(source):setData('hasDefined', hasMarkDoc or hasMarkParam or hasMarkValue)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local compilerSwitch = util.switch()
|
|||
|
|
: case 'nil'
|
|||
|
|
: case 'boolean'
|
|||
|
|
: case 'integer'
|
|||
|
|
: case 'number'
|
|||
|
|
: case 'string'
|
|||
|
|
: case 'doc.type.function'
|
|||
|
|
: case 'doc.type.table'
|
|||
|
|
: case 'doc.type.array'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
end)
|
|||
|
|
: case 'table'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
|
|||
|
|
if source.parent.type == 'callargs' then
|
|||
|
|
local call = source.parent.parent
|
|||
|
|
vm.compileCallArg(source, call)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if source.parent.type == 'setglobal'
|
|||
|
|
or source.parent.type == 'local'
|
|||
|
|
or source.parent.type == 'setlocal'
|
|||
|
|
or source.parent.type == 'tablefield'
|
|||
|
|
or source.parent.type == 'tableindex'
|
|||
|
|
or source.parent.type == 'tableexp'
|
|||
|
|
or source.parent.type == 'setfield'
|
|||
|
|
or source.parent.type == 'setindex' then
|
|||
|
|
local parentNode = vm.compileNode(source.parent)
|
|||
|
|
for _, pn in ipairs(parentNode) do
|
|||
|
|
if pn.type == 'global'
|
|||
|
|
and pn.cate == 'type' then
|
|||
|
|
---@cast pn vm.global
|
|||
|
|
if not guide.isBasicType(pn.name) then
|
|||
|
|
vm.setNode(source, pn)
|
|||
|
|
end
|
|||
|
|
elseif pn.type == 'doc.type.table' or pn.type == 'doc.type.array' then
|
|||
|
|
vm.setNode(source, pn)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'function'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
|
|||
|
|
if source.bindDocs then
|
|||
|
|
for _, doc in ipairs(source.bindDocs) do
|
|||
|
|
if doc.type == 'doc.overload' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
-- table.sort(string[], function (<?x?>) end)
|
|||
|
|
if source.parent.type == 'callargs' then
|
|||
|
|
local call = source.parent.parent
|
|||
|
|
vm.compileCallArg(source, call)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'paren'
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if source.exp then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.exp))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'local'
|
|||
|
|
: case 'self'
|
|||
|
|
---@param source parser.object
|
|||
|
|
: call(function (source)
|
|||
|
|
compileLocal(source)
|
|||
|
|
local refs = source.ref
|
|||
|
|
if not refs then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local hasMark = vm.getNode(source):getData 'hasDefined'
|
|||
|
|
|
|||
|
|
vm.launchRunner(source, function (src, node)
|
|||
|
|
if src.type == 'setlocal' then
|
|||
|
|
if src.bindDocs then
|
|||
|
|
for _, doc in ipairs(src.bindDocs) do
|
|||
|
|
if doc.type == 'doc.type' then
|
|||
|
|
vm.setNode(src, vm.compileNode(doc), true)
|
|||
|
|
return vm.getNode(src)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if src.value then
|
|||
|
|
if src.value.type == 'table' then
|
|||
|
|
vm.setNode(src, vm.createNode(src.value))
|
|||
|
|
vm.setNode(src, node:copy():asTable())
|
|||
|
|
else
|
|||
|
|
local function clearLockedNode(child)
|
|||
|
|
if not child then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if child.type == 'function' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if child.type == 'setlocal'
|
|||
|
|
or child.type == 'getlocal' then
|
|||
|
|
if child.node == source then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if LOCK[child] then
|
|||
|
|
vm.removeNode(child)
|
|||
|
|
end
|
|||
|
|
guide.eachChild(child, clearLockedNode)
|
|||
|
|
end
|
|||
|
|
clearLockedNode(src.value)
|
|||
|
|
vm.setNode(src, vm.compileNode(src.value), true)
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
vm.setNode(src, node, true)
|
|||
|
|
end
|
|||
|
|
return vm.getNode(src)
|
|||
|
|
elseif src.type == 'getlocal' then
|
|||
|
|
if bindAs(src) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(src, node, true)
|
|||
|
|
matchCall(src)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
|
|||
|
|
if not hasMark then
|
|||
|
|
local parentFunc = guide.getParentFunction(source)
|
|||
|
|
for _, ref in ipairs(source.ref) do
|
|||
|
|
if ref.type == 'setlocal'
|
|||
|
|
and guide.getParentFunction(ref) == parentFunc then
|
|||
|
|
local refNode = vm.getNode(ref)
|
|||
|
|
if refNode then
|
|||
|
|
vm.setNode(source, refNode)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'setlocal'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.compileNode(source.node)
|
|||
|
|
end)
|
|||
|
|
: case 'getlocal'
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.compileNode(source.node)
|
|||
|
|
end)
|
|||
|
|
: case 'setfield'
|
|||
|
|
: case 'setmethod'
|
|||
|
|
: case 'setindex'
|
|||
|
|
: case 'getfield'
|
|||
|
|
: case 'getmethod'
|
|||
|
|
: case 'getindex'
|
|||
|
|
: call(function (source)
|
|||
|
|
if guide.isGet(source) and bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
---@type (string|vm.node)?
|
|||
|
|
local key = guide.getKeyName(source)
|
|||
|
|
if key == nil and source.index then
|
|||
|
|
key = vm.compileNode(source.index)
|
|||
|
|
end
|
|||
|
|
if key == nil then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if type(key) == 'table' then
|
|||
|
|
---@cast key vm.node
|
|||
|
|
local uri = guide.getUri(source)
|
|||
|
|
local value = vm.getTableValue(uri, vm.compileNode(source.node), key)
|
|||
|
|
if value then
|
|||
|
|
vm.setNode(source, value)
|
|||
|
|
end
|
|||
|
|
for k in key:eachObject() do
|
|||
|
|
if k.type == 'global' and k.cate == 'type' then
|
|||
|
|
---@cast k vm.global
|
|||
|
|
vm.compileByParentNode(source.node, k, false, function (src)
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
if src.value then
|
|||
|
|
vm.setNode(source, vm.compileNode(src.value))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
---@cast key string
|
|||
|
|
vm.compileByParentNode(source.node, key, false, function (src)
|
|||
|
|
if src.value then
|
|||
|
|
if bindDocs(src) then
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
elseif src.value.type ~= 'nil' then
|
|||
|
|
vm.setNode(source, vm.compileNode(src.value))
|
|||
|
|
local node = vm.getNode(src)
|
|||
|
|
if node then
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
else
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'setglobal'
|
|||
|
|
: call(function (source)
|
|||
|
|
if source.node[1] ~= '_ENV' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local key = guide.getKeyName(source)
|
|||
|
|
vm.compileByParentNode(source.node, key, false, function (src)
|
|||
|
|
if src.type == 'doc.type.field'
|
|||
|
|
or src.type == 'doc.field' then
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end)
|
|||
|
|
: case 'getglobal'
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if source.node[1] ~= '_ENV' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local key = guide.getKeyName(source)
|
|||
|
|
vm.compileByParentNode(source.node, key, false, function (src)
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
end)
|
|||
|
|
end)
|
|||
|
|
: case 'tablefield'
|
|||
|
|
: case 'tableindex'
|
|||
|
|
: call(function (source)
|
|||
|
|
local hasMarkDoc
|
|||
|
|
if source.bindDocs then
|
|||
|
|
hasMarkDoc = bindDocs(source)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if not hasMarkDoc then
|
|||
|
|
vm.compileByParentNode(source.node, guide.getKeyName(source), false, function (src)
|
|||
|
|
if src.type == 'doc.field'
|
|||
|
|
or src.type == 'doc.type.field' then
|
|||
|
|
hasMarkDoc = true
|
|||
|
|
vm.setNode(source, vm.compileNode(src))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if not hasMarkDoc and source.value then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.value))
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
end)
|
|||
|
|
: case 'field'
|
|||
|
|
: case 'method'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, vm.compileNode(source.parent))
|
|||
|
|
end)
|
|||
|
|
: case 'tableexp'
|
|||
|
|
: call(function (source)
|
|||
|
|
if (source.parent.type == 'table') then
|
|||
|
|
local node = vm.compileNode(source.parent)
|
|||
|
|
for n in node:eachObject() do
|
|||
|
|
if n.type == 'doc.type.array' then
|
|||
|
|
vm.setNode(source, vm.compileNode(n.node))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.compileNode(source.value))
|
|||
|
|
end)
|
|||
|
|
: case 'function.return'
|
|||
|
|
---@param source parser.object
|
|||
|
|
: call(function (source)
|
|||
|
|
local func = source.parent
|
|||
|
|
local index = source.returnIndex
|
|||
|
|
local hasMarkDoc
|
|||
|
|
if func.bindDocs then
|
|||
|
|
local sign = getObjectSign(func)
|
|||
|
|
local lastReturn
|
|||
|
|
for _, doc in ipairs(func.bindDocs) do
|
|||
|
|
if doc.type == 'doc.return' then
|
|||
|
|
for _, rtn in ipairs(doc.returns) do
|
|||
|
|
lastReturn = rtn
|
|||
|
|
if rtn.returnIndex == index then
|
|||
|
|
hasMarkDoc = true
|
|||
|
|
local hasGeneric
|
|||
|
|
if sign then
|
|||
|
|
guide.eachSourceType(rtn, 'doc.generic.name', function (src)
|
|||
|
|
hasGeneric = true
|
|||
|
|
end)
|
|||
|
|
end
|
|||
|
|
if hasGeneric then
|
|||
|
|
---@cast sign -false
|
|||
|
|
vm.setNode(source, vm.createGeneric(rtn, sign))
|
|||
|
|
else
|
|||
|
|
vm.setNode(source, vm.compileNode(rtn))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if lastReturn
|
|||
|
|
and not hasMarkDoc then
|
|||
|
|
if lastReturn.name and lastReturn.name[1] == '...' then
|
|||
|
|
hasMarkDoc = true
|
|||
|
|
vm.setNode(source, vm.compileNode(lastReturn))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
local hasReturn
|
|||
|
|
if func.returns and not hasMarkDoc then
|
|||
|
|
for _, rtn in ipairs(func.returns) do
|
|||
|
|
if selectNode(source, rtn, index) then
|
|||
|
|
hasReturn = true
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if hasReturn then
|
|||
|
|
local hasKnownType
|
|||
|
|
local hasUnknownType
|
|||
|
|
for n in vm.getNode(source):eachObject() do
|
|||
|
|
if guide.isLiteral(n) then
|
|||
|
|
if n.type ~= 'nil' then
|
|||
|
|
hasKnownType = true
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
goto CONTINUE
|
|||
|
|
end
|
|||
|
|
if n.type == 'global' and n.cate == 'type' then
|
|||
|
|
if n.name ~= 'nil' then
|
|||
|
|
hasKnownType = true
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
goto CONTINUE
|
|||
|
|
end
|
|||
|
|
hasUnknownType = true
|
|||
|
|
::CONTINUE::
|
|||
|
|
end
|
|||
|
|
if not hasKnownType and hasUnknownType then
|
|||
|
|
vm.setNode(source, vm.declareGlobal('type', 'unknown'))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if not hasMarkDoc and not hasReturn then
|
|||
|
|
vm.setNode(source, vm.declareGlobal('type', 'nil'))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'call.return'
|
|||
|
|
---@param source parser.object
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local func = source.func
|
|||
|
|
local args = source.args
|
|||
|
|
local index = source.cindex
|
|||
|
|
if func.special == 'setmetatable' then
|
|||
|
|
if not args then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, getReturnOfSetMetaTable(args))
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if func.special == 'pcall' and index > 1 then
|
|||
|
|
if not args then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local newArgs = {}
|
|||
|
|
for i = 2, #args do
|
|||
|
|
newArgs[#newArgs+1] = args[i]
|
|||
|
|
end
|
|||
|
|
local node = getReturn(args[1], index - 1, newArgs)
|
|||
|
|
if node then
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
end
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if func.special == 'xpcall' and index > 1 then
|
|||
|
|
if not args then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local newArgs = {}
|
|||
|
|
for i = 3, #args do
|
|||
|
|
newArgs[#newArgs+1] = args[i]
|
|||
|
|
end
|
|||
|
|
local node = getReturn(args[1], index - 1, newArgs)
|
|||
|
|
if node then
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
end
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if func.special == 'require' then
|
|||
|
|
if not args then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local nameArg = args[1]
|
|||
|
|
if not nameArg or nameArg.type ~= 'string' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local name = nameArg[1]
|
|||
|
|
if not name or type(name) ~= 'string' then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local uri = rpath.findUrisByRequireName(guide.getUri(func), name)[1]
|
|||
|
|
if not uri then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local state = files.getState(uri)
|
|||
|
|
local ast = state and state.ast
|
|||
|
|
if not ast then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.compileNode(ast))
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local funcNode = vm.compileNode(func)
|
|||
|
|
---@type vm.node?
|
|||
|
|
for mfunc in funcNode:eachObject() do
|
|||
|
|
if mfunc.type == 'function'
|
|||
|
|
or mfunc.type == 'doc.type.function' then
|
|||
|
|
---@cast mfunc parser.object
|
|||
|
|
local returnObject = vm.getReturnOfFunction(mfunc, index)
|
|||
|
|
if returnObject then
|
|||
|
|
local returnNode = vm.compileNode(returnObject)
|
|||
|
|
for rnode in returnNode:eachObject() do
|
|||
|
|
if rnode.type == 'generic' then
|
|||
|
|
returnNode = rnode:resolve(guide.getUri(func), args)
|
|||
|
|
break
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if returnNode then
|
|||
|
|
for rnode in returnNode:eachObject() do
|
|||
|
|
-- TODO: narrow type
|
|||
|
|
if rnode.type ~= 'doc.generic.name' then
|
|||
|
|
vm.setNode(source, rnode)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if returnNode:isOptional() then
|
|||
|
|
vm.getNode(source):addOptional()
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'main'
|
|||
|
|
: call(function (source)
|
|||
|
|
if source.returns then
|
|||
|
|
for _, rtn in ipairs(source.returns) do
|
|||
|
|
if rtn[1] then
|
|||
|
|
vm.setNode(source, vm.compileNode(rtn[1]))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'select'
|
|||
|
|
: call(function (source)
|
|||
|
|
local vararg = source.vararg
|
|||
|
|
if vararg.type == 'call' then
|
|||
|
|
local node = getReturn(vararg.node, source.sindex, vararg.args)
|
|||
|
|
if not node then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if node:isEmpty() then
|
|||
|
|
node = vm.runOperator('call', vararg.node) or node
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
end
|
|||
|
|
if vararg.type == 'varargs' then
|
|||
|
|
vm.setNode(source, vm.compileNode(vararg))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'varargs'
|
|||
|
|
: call(function (source)
|
|||
|
|
if source.node then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.node))
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'call'
|
|||
|
|
: call(function (source)
|
|||
|
|
local node = getReturn(source.node, 1, source.args)
|
|||
|
|
if not node then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if node:isEmpty() then
|
|||
|
|
node = vm.runOperator('call', source.node) or node
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, node)
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type'
|
|||
|
|
: call(function (source)
|
|||
|
|
for _, typeUnit in ipairs(source.types) do
|
|||
|
|
vm.setNode(source, vm.compileNode(typeUnit))
|
|||
|
|
end
|
|||
|
|
if source.optional then
|
|||
|
|
vm.getNode(source):addOptional()
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.integer'
|
|||
|
|
: case 'doc.type.string'
|
|||
|
|
: case 'doc.type.boolean'
|
|||
|
|
: case 'doc.type.code'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
end)
|
|||
|
|
: case 'doc.generic.name'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.sign'
|
|||
|
|
: call(function (source)
|
|||
|
|
local uri = guide.getUri(source)
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
if not source.node[1] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local global = vm.getGlobal('type', source.node[1])
|
|||
|
|
if not global then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
if set.type == 'doc.class' then
|
|||
|
|
if set.extends then
|
|||
|
|
for _, ext in ipairs(set.extends) do
|
|||
|
|
if ext.type == 'doc.type.table' then
|
|||
|
|
if ext._generic then
|
|||
|
|
local resolved = ext._generic:resolve(uri, source.signs)
|
|||
|
|
vm.setNode(source, resolved)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if set.type == 'doc.alias' then
|
|||
|
|
if set.extends._generic then
|
|||
|
|
local resolved = set.extends._generic:resolve(uri, source.signs)
|
|||
|
|
vm.setNode(source, resolved)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.class.name'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, vm.compileNode(source.parent))
|
|||
|
|
end)
|
|||
|
|
: case 'doc.enum.name'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, vm.compileNode(source.parent))
|
|||
|
|
end)
|
|||
|
|
: case 'doc.field'
|
|||
|
|
: call(function (source)
|
|||
|
|
if not source.extends then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local fieldNode = vm.compileNode(source.extends)
|
|||
|
|
if source.optional then
|
|||
|
|
fieldNode:addOptional()
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, fieldNode)
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.field'
|
|||
|
|
: call(function (source)
|
|||
|
|
if not source.extends then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
local fieldNode = vm.compileNode(source.extends)
|
|||
|
|
if source.optional then
|
|||
|
|
fieldNode:addOptional()
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, fieldNode)
|
|||
|
|
end)
|
|||
|
|
: case 'doc.param'
|
|||
|
|
: call(function (source)
|
|||
|
|
if not source.extends then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.compileNode(source.extends))
|
|||
|
|
end)
|
|||
|
|
: case 'doc.vararg'
|
|||
|
|
: call(function (source)
|
|||
|
|
if not source.vararg then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.setNode(source, vm.compileNode(source.vararg))
|
|||
|
|
end)
|
|||
|
|
: case '...'
|
|||
|
|
: call(function (source)
|
|||
|
|
if not source.bindDocs then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
for _, doc in ipairs(source.bindDocs) do
|
|||
|
|
if doc.type == 'doc.vararg' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
end
|
|||
|
|
if doc.type == 'doc.param' then
|
|||
|
|
vm.setNode(source, vm.compileNode(doc))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.overload'
|
|||
|
|
: call(function (source)
|
|||
|
|
vm.setNode(source, vm.compileNode(source.overload))
|
|||
|
|
end)
|
|||
|
|
: case 'doc.see.name'
|
|||
|
|
: call(function (source)
|
|||
|
|
local type = vm.getGlobal('type', source[1])
|
|||
|
|
if type then
|
|||
|
|
vm.setNode(source, type)
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'doc.type.arg'
|
|||
|
|
: call(function (source)
|
|||
|
|
if source.extends then
|
|||
|
|
vm.setNode(source, vm.compileNode(source.extends))
|
|||
|
|
else
|
|||
|
|
vm.setNode(source, vm.declareGlobal('type', 'any'))
|
|||
|
|
end
|
|||
|
|
if source.optional then
|
|||
|
|
vm.getNode(source):addOptional()
|
|||
|
|
end
|
|||
|
|
end)
|
|||
|
|
: case 'unary'
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if not source[1] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.unarySwich(source.op.type, source)
|
|||
|
|
end)
|
|||
|
|
: case 'binary'
|
|||
|
|
: call(function (source)
|
|||
|
|
if bindAs(source) then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
if not source[1] or not source[2] then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
vm.binarySwitch(source.op.type, source)
|
|||
|
|
end)
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
local function compileByNode(source)
|
|||
|
|
compilerSwitch(source.type, source)
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source parser.object
|
|||
|
|
local function compileByGlobal(source)
|
|||
|
|
local global = source._globalNode
|
|||
|
|
if not global then
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
---@cast source parser.object
|
|||
|
|
local root = guide.getRoot(source)
|
|||
|
|
local uri = guide.getUri(source)
|
|||
|
|
if not root._globalBase then
|
|||
|
|
root._globalBase = {}
|
|||
|
|
end
|
|||
|
|
local name = global:asKeyName()
|
|||
|
|
if not root._globalBase[name] then
|
|||
|
|
root._globalBase[name] = {
|
|||
|
|
type = 'globalbase',
|
|||
|
|
parent = root,
|
|||
|
|
}
|
|||
|
|
end
|
|||
|
|
local globalNode = vm.getNode(root._globalBase[name])
|
|||
|
|
if globalNode then
|
|||
|
|
vm.setNode(source, globalNode, true)
|
|||
|
|
return
|
|||
|
|
end
|
|||
|
|
---@type vm.node
|
|||
|
|
globalNode = vm.createNode(global)
|
|||
|
|
vm.setNode(root._globalBase[name], globalNode, true)
|
|||
|
|
vm.setNode(source, globalNode, true)
|
|||
|
|
|
|||
|
|
-- TODO:don't mix
|
|||
|
|
--local sets = global.links[uri].sets or {}
|
|||
|
|
--local gets = global.links[uri].gets or {}
|
|||
|
|
--for _, set in ipairs(sets) do
|
|||
|
|
-- vm.setNode(set, globalNode, true)
|
|||
|
|
--end
|
|||
|
|
--for _, get in ipairs(gets) do
|
|||
|
|
-- vm.setNode(get, globalNode, true)
|
|||
|
|
--end
|
|||
|
|
|
|||
|
|
if global.cate == 'variable' then
|
|||
|
|
local hasMarkDoc
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
if set.bindDocs and set.parent.type == 'main' then
|
|||
|
|
if bindDocs(set) then
|
|||
|
|
globalNode:merge(vm.compileNode(set))
|
|||
|
|
hasMarkDoc = true
|
|||
|
|
end
|
|||
|
|
if vm.getNode(set) then
|
|||
|
|
globalNode:merge(vm.compileNode(set))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
-- Set all globals node first to avoid recursive
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
vm.setNode(set, globalNode, true)
|
|||
|
|
end
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
if set.value and set.value.type ~= 'nil' and set.parent.type == 'main' then
|
|||
|
|
if not hasMarkDoc or guide.isLiteral(set.value) then
|
|||
|
|
globalNode:merge(vm.compileNode(set.value))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
vm.setNode(set, globalNode, true)
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if global.cate == 'type' then
|
|||
|
|
for _, set in ipairs(global:getSets(uri)) do
|
|||
|
|
if set.type == 'doc.class' then
|
|||
|
|
if set.extends then
|
|||
|
|
for _, ext in ipairs(set.extends) do
|
|||
|
|
if ext.type == 'doc.type.table' then
|
|||
|
|
if not ext._generic then
|
|||
|
|
globalNode:merge(vm.compileNode(ext))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
if set.type == 'doc.alias' then
|
|||
|
|
if not set.extends._generic then
|
|||
|
|
globalNode:merge(vm.compileNode(set.extends))
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@param source vm.object
|
|||
|
|
---@return vm.node
|
|||
|
|
function vm.compileNode(source)
|
|||
|
|
if not source then
|
|||
|
|
if TEST then
|
|||
|
|
error('Can not compile nil source')
|
|||
|
|
else
|
|||
|
|
log.error('Can not compile nil source')
|
|||
|
|
end
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
local cache = vm.getNode(source)
|
|||
|
|
if cache ~= nil then
|
|||
|
|
return cache
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
if source.type == 'generic' then
|
|||
|
|
vm.setNode(source, source)
|
|||
|
|
local node = vm.getNode(source)
|
|||
|
|
---@cast node -?
|
|||
|
|
return node
|
|||
|
|
end
|
|||
|
|
|
|||
|
|
---@cast source parser.object
|
|||
|
|
vm.setNode(source, vm.createNode(), true)
|
|||
|
|
LOCK[source] = true
|
|||
|
|
compileByGlobal(source)
|
|||
|
|
compileByNode(source)
|
|||
|
|
matchCall(source)
|
|||
|
|
LOCK[source] = nil
|
|||
|
|
|
|||
|
|
local node = vm.getNode(source)
|
|||
|
|
---@cast node -?
|
|||
|
|
return node
|
|||
|
|
end
|