Merge pull request #2177 from sewbacca/feature/shortcut-autorequire

sumneko · web-flow · commit 9e1e7cc7f102 · 2023-07-18T10:10:22.000+08:00
[Feature] Add action to autorequire undefined globals
diff --git a/locale/en-us/script.lua b/locale/en-us/script.lua
@@ -448,6 +448,8 @@ ACTION_ADD_DICT         =
 'Add \'{}\' to workspace dict'
 ACTION_FIX_ADD_PAREN    = -- TODO: need translate!
 'Add parentheses.'
+ACTION_AUTOREQUIRE      = -- TODO: need translate!
+"Import '{}' as {}"
 
 COMMAND_DISABLE_DIAG       =
 'Disable diagnostics'
diff --git a/script/core/code-action.lua b/script/core/code-action.lua
@@ -4,6 +4,11 @@ local util      = require 'utility'
 local sp        = require 'bee.subprocess'
 local guide     = require "parser.guide"
 local converter = require 'proto.converter'
+local autoreq   = require 'core.completion.auto-require'
+local rpath     = require 'workspace.require-path'
+local furi      = require 'file-uri'
+local undefined = require 'core.diagnostics.undefined-global'
+local vm        = require 'vm'
 
 ---@param uri  uri
 ---@param row  integer
@@ -676,6 +681,54 @@ local function checkJsonToLua(results, uri, start, finish)
     }
 end
 
+local function findRequireTargets(visiblePaths)
+    local targets = {}
+    for _, visible in ipairs(visiblePaths) do
+        targets[#targets+1] = visible.name
+    end
+    return targets
+end
+
+local function checkMissingRequire(results, uri, start, finish)
+    local state = files.getState(uri)
+    local text  = files.getText(uri)
+    if not state or not text then
+        return
+    end
+
+    local function addRequires(global, endpos)
+        autoreq.check(state, global, endpos, function(moduleFile, stemname, targetSource)
+            local visiblePaths = rpath.getVisiblePath(uri, furi.decode(moduleFile))
+            if not visiblePaths or #visiblePaths == 0 then return end
+
+            for _, target in ipairs(findRequireTargets(visiblePaths)) do
+                results[#results+1] = {
+                    title = lang.script('ACTION_AUTOREQUIRE', target, global),
+                    kind = 'refactor.rewrite',
+                    command = {
+                        title     = 'autoRequire',
+                        command   = 'lua.autoRequire',
+                        arguments = {
+                            {
+                                uri         = guide.getUri(state.ast),
+                                target      = moduleFile,
+                                name        = global,
+                                requireName = target
+                            },
+                        },
+                    }
+                }
+            end
+        end)
+    end
+
+    guide.eachSourceBetween(state.ast, start, finish, function (source)
+        if vm.isUndefinedGlobal(source) then
+            addRequires(source[1], source.finish)
+        end
+    end)
+end
+
 return function (uri, start, finish, diagnostics)
     local ast = files.getState(uri)
     if not ast then
@@ -688,6 +741,7 @@ return function (uri, start, finish, diagnostics)
     checkSwapParams(results, uri, start, finish)
     --checkExtractAsFunction(results, uri, start, finish)
     checkJsonToLua(results, uri, start, finish)
+    checkMissingRequire(results, uri, start, finish)
 
     return results
 end
diff --git a/script/core/command/autoRequire.lua b/script/core/command/autoRequire.lua
@@ -135,6 +135,7 @@ return function (data)
     local uri    = data.uri
     local target = data.target
     local name   = data.name
+    local requireName   = data.requireName
     local state  = files.getState(uri)
     if not state then
         return
@@ -149,11 +150,13 @@ return function (data)
         return #a.name < #b.name
     end)
 
-    local result = askAutoRequire(uri, visiblePaths)
-    if not result then
-        return
+    if not requireName then
+        requireName = askAutoRequire(uri, visiblePaths)
+        if not requireName then
+            return
+        end
     end
 
     local offset, fmt = findInsertRow(uri)
-    applyAutoRequire(uri, offset, name, result, fmt)
+    applyAutoRequire(uri, offset, name, requireName, fmt)
 end
diff --git a/script/core/diagnostics/undefined-global.lua b/script/core/diagnostics/undefined-global.lua
@@ -20,41 +20,21 @@ return function (uri, callback)
         return
     end
 
-    local dglobals = util.arrayToHash(config.get(uri, 'Lua.diagnostics.globals'))
-    local rspecial = config.get(uri, 'Lua.runtime.special')
-    local cache    = {}
-
     -- 遍历全局变量，检查所有没有 set 模式的全局变量
     guide.eachSourceType(state.ast, 'getglobal', function (src) ---@async
-        local key = src[1]
-        if not key then
-            return
-        end
-        if dglobals[key] then
-            return
-        end
-        if rspecial[key] then
-            return
-        end
-        local node = src.node
-        if node.tag ~= '_ENV' then
-            return
-        end
-        if cache[key] == nil then
-            await.delay()
-            cache[key] = vm.hasGlobalSets(uri, 'variable', key)
-        end
-        if cache[key] then
-            return
-        end
-        local message = lang.script('DIAG_UNDEF_GLOBAL', key)
-        if requireLike[key:lower()] then
-            message = ('%s(%s)'):format(message, lang.script('DIAG_REQUIRE_LIKE', key))
+        if vm.isUndefinedGlobal(src) then
+            local key = src[1]
+            local message = lang.script('DIAG_UNDEF_GLOBAL', key)
+            if requireLike[key:lower()] then
+                message = ('%s(%s)'):format(message, lang.script('DIAG_REQUIRE_LIKE', key))
+            end
+
+            callback {
+                start   = src.start,
+                finish  = src.finish,
+                message = message,
+                undefinedGlobal = src[1]
+            }
         end
-        callback {
-            start   = src.start,
-            finish  = src.finish,
-            message = message,
-        }
     end)
 end
diff --git a/script/vm/global.lua b/script/vm/global.lua
@@ -1,6 +1,7 @@
 local util  = require 'utility'
 local scope = require 'workspace.scope'
 local guide = require 'parser.guide'
+local config = require 'config'
 ---@class vm
 local vm    = require 'vm.vm'
 
@@ -518,6 +519,33 @@ function vm.hasGlobalSets(suri, cate, name)
     return true
 end
 
+---@param src parser.object
+local function checkIsUndefinedGlobal(src)
+    local key = src[1]
+
+    local uri = guide.getUri(src)
+    local dglobals = util.arrayToHash(config.get(uri, 'Lua.diagnostics.globals'))
+    local rspecial = config.get(uri, 'Lua.runtime.special')
+
+    local node = src.node
+    return src.type == 'getglobal' and key and not (
+        dglobals[key] or
+        rspecial[key] or
+        node.tag ~= '_ENV' or
+        vm.hasGlobalSets(uri, 'variable', key)
+    )
+end
+
+---@param src parser.object
+---@return boolean
+function vm.isUndefinedGlobal(src)
+    local node = vm.compileNode(src)
+    if node.undefinedGlobal == nil then
+        node.undefinedGlobal = checkIsUndefinedGlobal(src)
+    end
+    return node.undefinedGlobal
+end
+
 ---@param source parser.object
 function compileObject(source)
     if source._globalNode ~= nil then
diff --git a/script/vm/node.lua b/script/vm/node.lua
@@ -15,6 +15,7 @@ vm.nodeCache = setmetatable({}, util.MODE_K)
 ---@field [integer] vm.node.object
 ---@field [vm.node.object] true
 ---@field fields? table<vm.node|string, vm.node>
+---@field undefinedGlobal boolean?
 local mt = {}
 mt.__index    = mt
 mt.id         = 0
diff --git a/test/code_action/init.lua b/test/code_action/init.lua
@@ -2,38 +2,40 @@ local core  = require 'core.code-action'
 local files = require 'files'
 local lang  = require 'language'
 local catch = require 'catch'
+local furi  = require 'file-uri'
 
 rawset(_G, 'TEST', true)
 
 local EXISTS = {}
 
-local function eq(a, b)
-    if a == EXISTS and b ~= nil then
+local function eq(expected, result)
+    if expected == EXISTS and result ~= nil then
         return true
     end
-    if b == EXISTS and a ~= nil then
+    if result == EXISTS and expected ~= nil then
         return true
     end
-    local tp1, tp2 = type(a), type(b)
+    local tp1, tp2 = type(expected), type(result)
     if tp1 ~= tp2 then
-        return false
+        return false, string.format(": expected type %s, got %s for %s", tp1, tp2)
     end
     if tp1 == 'table' then
         local mark = {}
-        for k in pairs(a) do
-            if not eq(a[k], b[k]) then
-                return false
+        for k in pairs(expected) do
+            local ok, err = eq(expected[k], result[k])
+            if not ok then
+                return false, string.format(".%s%s", k, err)
             end
             mark[k] = true
         end
-        for k in pairs(b) do
+        for k in pairs(result) do
             if not mark[k] then
-                return false
+                return false, string.format(".%s: missing key in result", k)
             end
         end
         return true
     end
-    return a == b
+    return expected == result, string.format(": expected %s, got %s", expected, result)
 end
 
 function TEST(script)
@@ -47,6 +49,32 @@ function TEST(script)
     end
 end
 
+local function TEST_CROSSFILE(testfiles)
+    local mainscript = table.remove(testfiles, 1)
+    return function(expected)
+        for _, data in ipairs(testfiles) do
+            local uri = furi.encode(data.path)
+            files.setText(uri, data.content)
+            files.compileState(uri)
+        end
+
+        local newScript, catched = catch(mainscript, '?')
+        files.setText(TESTURI, newScript)
+        files.compileState(TESTURI)
+
+        local _ <close> = function ()
+            for _, info in ipairs(testfiles) do
+                files.remove(furi.encode(info.path))
+            end
+            files.remove(TESTURI)
+        end
+
+        local results = core(TESTURI, catched['?'][1][1], catched['?'][1][2])
+        assert(results)
+        assert(eq(expected, results))
+    end
+end
+
 TEST [[
 print(<?a?>, b, c)
 ]]
@@ -154,3 +182,97 @@ local t = {
 --        edit  = EXISTS,
 --    },
 --}
+
+TEST_CROSSFILE {
+[[
+    <?unrequiredModule?>.myFunction()
+]],
+    {
+        path = 'unrequiredModule.lua',
+        content = [[
+            local m = {}
+            m.myFunction = print
+            return m
+        ]]
+    }
+} {
+    {
+        title = lang.script('ACTION_AUTOREQUIRE', 'unrequiredModule', 'unrequiredModule'),
+        kind = 'refactor.rewrite',
+        command = {
+            title     = 'autoRequire',
+            command   = 'lua.autoRequire',
+            arguments = {
+                {
+                    uri         = TESTURI,
+                    target      = furi.encode 'unrequiredModule.lua',
+                    name        = 'unrequiredModule',
+                    requireName = 'unrequiredModule'
+                },
+            },
+        }
+    }
+}
+
+TEST_CROSSFILE {
+[[
+    <?myModule?>.myFunction()
+]],
+    {
+        path = 'myModule/init.lua',
+        content = [[
+            local m = {}
+            m.myFunction = print
+            return m
+        ]]
+    }
+} {
+    {
+        title = lang.script('ACTION_AUTOREQUIRE', 'myModule.init', 'myModule'),
+        kind = 'refactor.rewrite',
+        command = {
+            title     = 'autoRequire',
+            command   = 'lua.autoRequire',
+            arguments = {
+                {
+                    uri         = TESTURI,
+                    target      = furi.encode 'myModule/init.lua',
+                    name        = 'myModule',
+                    requireName = 'myModule.init'
+                },
+            },
+        }
+    },
+    {
+        title = lang.script('ACTION_AUTOREQUIRE', 'init', 'myModule'),
+        kind = 'refactor.rewrite',
+        command = {
+            title     = 'autoRequire',
+            command   = 'lua.autoRequire',
+            arguments = {
+                {
+                    uri         = TESTURI,
+                    target      = furi.encode 'myModule/init.lua',
+                    name        = 'myModule',
+                    requireName = 'init'
+                },
+            },
+        }
+    },
+    {
+        title = lang.script('ACTION_AUTOREQUIRE', 'myModule', 'myModule'),
+        kind = 'refactor.rewrite',
+        command = {
+            title     = 'autoRequire',
+            command   = 'lua.autoRequire',
+            arguments = {
+                {
+                    uri         = TESTURI,
+                    target      = furi.encode 'myModule/init.lua',
+                    name        = 'myModule',
+                    requireName = 'myModule'
+                },
+            },
+        }
+    },
+}
