[feat] generics: capture types with backticks

changelog.md

@@ -2,6 +2,7 @@
 
 ## Unreleased
 <!-- Add all new changes here. They will be moved under a version at release -->
+* `NEW` Allow capture object types with backticks in generics
 
 ## 3.14.0
 `2025-4-7`

script/vm/sign.lua

@@ -51,9 +51,29 @@ function mt:resolve(uri, args)
             if object.literal then
                 -- 'number' -> `T`
                 for n in node:eachObject() do
+                    local typeName = nil
+                    local typeUri = nil
                     if n.type == 'string' then
+                        typeName = n[1]
+                        typeUri = guide.getUri(n)
+                    elseif n.type == "global" and n.cate == "type" then
+                        typeName = n:getName()
+                    elseif (n.type == "function" or n.type == "doc.type.function")
+                        and #n.returns > 0 then
                         ---@cast n parser.object
-                        local type = vm.declareGlobal('type', object.pattern and object.pattern:format(n[1]) or n[1], guide.getUri(n))
+                        local fret = vm.getReturnOfFunction(n, 1)
+                        if fret then
+                            local compiled = vm.compileNode(fret)
+                            local r1 = compiled and compiled[1]
+                            if r1 and r1.cate == "type" then
+                                typeName = r1:getName()
+                            end
+						end
+                    end
+                    if typeName ~= nil then
+                        ---@cast n parser.object
+                        local type = vm.declareGlobal('type',
+                            object.pattern and object.pattern:format(typeName) or typeName, typeUri)
                         resolved[key] = vm.createNode(type, resolved[key])
                     end
                 end

test/definition/luadoc.lua

@@ -293,7 +293,7 @@ print(v1.<?bar1?>)
 TEST [[
 ---@class Foo
 local Foo = {}
-function Foo:bar1() end
+function Foo:<!bar1!>() end
 
 ---@generic T
 ---@param arg1 `T`
@@ -402,6 +402,43 @@ local v1 = Generic("Foo")
 print(v1.<?bar1?>)
 ]]
 
+TEST [[
+---@class n.Foo.2
+local nFoo2 = {}
+function nFoo2:<!bar1!>() end
+
+---@class Foo
+local Foo = {}
+
+---@generic T
+---@param arg1 n.`T`.2
+---@return T
+function Generic(arg1) print(arg1) end
+
+local v1 = Generic(Foo)
+print(v1.<?bar1?>)
+]]
+
+TEST [[
+---@class n.Foo.2
+local nFoo2 = {}
+function nFoo2:<!bar1!>() end
+
+---@class Foo
+local Foo = {}
+
+---@return Foo
+function returnsFoo() print("") end
+
+---@generic T
+---@param arg1 n.`T`.2
+---@return T
+function Generic(arg1) print(arg1) end
+
+local v1 = Generic(returnsFoo())
+print(v1.<?bar1?>)
+]]
+
 TEST [[
 ---@class n-Foo-2
 local Foo = {}
@@ -430,6 +467,23 @@ local v1 = Generic({"Foo"})
 print(v1.<?bar1?>)
 ]]
 
+TEST [[
+---@class n-Foo-2
+local nFoo2 = {}
+function nFoo2:<!bar1!>() end
+
+---@class Foo
+local Foo = {}
+
+---@generic T
+---@param arg1 n-`T`-2[]
+---@return T
+function Generic(arg1) print(arg1) end
+
+local v1 = Generic({Foo})
+print(v1.<?bar1?>)
+]]
+
 TEST [[
 ---@class A
 local t