summaryrefslogtreecommitdiff
path: root/script/vm/infer.lua
blob: c396f3ecf58f2d64c2f7dae6b834bb25314e518f (plain)
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
local util      = require 'utility'
local nodeMgr   = require 'vm.node'

---@class vm.infer-manager
local m = {}

local inferSorted = {
    ['nil'] = 100,
}

local viewNodeMap = util.switch()
    : case 'nil'
    : case 'boolean'
    : case 'string'
    : case 'function'
    : case 'integer'
    : call(function (source, options)
        return source.type
    end)
    : case 'number'
    : call(function (source, options)
        options['hasNumber'] = true
        return source.type
    end)
    : case 'table'
    : call(function (source, options)
        options['hasTable'] = true
    end)
    : case 'global'
    : call(function (source, options)
        if source.cate == 'type' then
            options['hasClass'] = true
            return source.name
        end
    end)
    : case 'doc.type.name'
    : call(function (source, options)
        return source[1]
    end)
    : case 'doc.type.array'
    : call(function (source, options)
        options['hasClass'] = true
        return m.viewType(source.node) .. '[]'
    end)
    : case 'doc.type.enum'
    : call(function (source, options)
        return ('%q'):format(source[1])
    end)
    : getMap()

---@param node vm.node
---@return string?
local function viewNode(node, options)
    if viewNodeMap[node.type] then
        return viewNodeMap[node.type](node, options)
    end
end

local function eraseAlias(node, viewMap)
    for n in nodeMgr.eachNode(node) do
        if n.type == 'global' and n.cate == 'type' then
            for _, set in ipairs(n:getSets()) do
                if set.type == 'doc.alias' then
                    for _, ext in ipairs(set.extends.types) do
                        local view = viewNode(ext, {})
                        if view and view ~= n.name then
                            viewMap[view] = nil
                        end
                    end
                end
            end
        end
    end
end

---@param source parser.object
---@return table<string, boolean>
function m.getViews(source)
    local compiler = require 'vm.compiler'
    local node     = compiler.compileNode(source)
    if node.type == 'union' and node.lastViews then
        return node.lastViews
    end
    local views = {}
    local options = {}
    if node.type == 'union' then
        node.lastViews = views
    end
    for n in nodeMgr.eachNode(node) do
        local view = viewNode(n, options)
        if view then
            views[view] = true
        end
    end
    if options['hasNumber'] then
        views['integer'] = nil
    end
    if options['hasTable'] and not options['hasClass'] then
        views['table'] = true
    end
    if options['hasClass'] then
        eraseAlias(node, views)
    end
    return views
end

---@param source parser.object
---@return string
function m.viewType(source)
    local views = m.getViews(source)
    if not next(views) then
        return 'unknown'
    end

    local array = {}
    for view in pairs(views) do
        array[#array+1] = view
    end

    table.sort(array, function (a, b)
        local sa = inferSorted[a] or 0
        local sb = inferSorted[b] or 0
        if sa == sb then
            return a < b
        end
        return sa < sb
    end)
    local view = table.concat(array, '|')

    return view
end

return m