fix: undefined-doc-name issue

Author: ian-pascoe

script/core/diagnostics/param-type-mismatch.lua

@@ -5,7 +5,8 @@ local vm    = require 'vm'
 local await = require 'await'
 
 ---@param defNode  vm.node
-local function expandGenerics(defNode)
+---@param classGenericMap table<string, vm.node>?
+local function expandGenerics(defNode, classGenericMap)
     ---@type parser.object[]
     local generics = {}
     for dn in defNode:eachObject() do
@@ -20,27 +21,78 @@ local function expandGenerics(defNode)
     end
 
     for _, generic in ipairs(generics) do
-        local limits = generic.generic and generic.generic.extends
-        if limits then
-            defNode:merge(vm.compileNode(limits))
+        -- First check if this generic is a class generic that can be resolved
+        local genericName = generic[1]
+        if classGenericMap and genericName and classGenericMap[genericName] then
+            defNode:merge(classGenericMap[genericName])
         else
-            local unknownType = vm.declareGlobal('type', 'unknown')
-            defNode:merge(unknownType)
+            -- Fall back to constraint or unknown
+            local limits = generic.generic and generic.generic.extends
+            if limits then
+                defNode:merge(vm.compileNode(limits))
+            else
+                local unknownType = vm.declareGlobal('type', 'unknown')
+                defNode:merge(unknownType)
+            end
+        end
+    end
+end
+
+---@param uri uri
+---@param source parser.object
+---@return table<string, vm.node>?
+local function getReceiverGenericMap(uri, source)
+    local callNode = source.node
+    if not callNode then
+        return nil
+    end
+    -- Only resolve generics for method calls (obj:method()), not static calls (Class.method())
+    if callNode.type ~= 'getmethod' then
+        return nil
+    end
+    local receiver = callNode.node
+    if not receiver then
+        return nil
+    end
+    local receiverNode = vm.compileNode(receiver)
+    for rn in receiverNode:eachObject() do
+        if rn.type == 'doc.type.sign' and rn.signs and rn.node and rn.node[1] then
+            local classGlobal = vm.getGlobal('type', rn.node[1])
+            if classGlobal then
+                return vm.getClassGenericMap(uri, classGlobal, rn.signs)
+            end
         end
     end
+    return nil
 end
 
 ---@param funcNode vm.node
 ---@param i integer
+---@param classGenericMap table<string, vm.node>?
 ---@return vm.node?
-local function getDefNode(funcNode, i)
+local function getDefNode(funcNode, i, classGenericMap)
     local defNode = vm.createNode()
     for src in funcNode:eachObject() do
         if src.type == 'function'
         or src.type == 'doc.type.function' then
             local param = src.args and src.args[i]
             if param then
-                defNode:merge(vm.compileNode(param))
+                local paramNode = vm.compileNode(param)
+                -- Check for global type references that match class generic params
+                if classGenericMap then
+                    local newNode = vm.createNode()
+                    for pn in paramNode:eachObject() do
+                        if pn.type == 'global' and pn.cate == 'type' and classGenericMap[pn.name] then
+                            -- Replace the global type reference with the resolved type
+                            newNode:merge(classGenericMap[pn.name])
+                        else
+                            newNode:merge(pn)
+                        end
+                    end
+                    defNode:merge(newNode)
+                else
+                    defNode:merge(paramNode)
+                end
                 if param[1] == '...' then
                     defNode:addOptional()
                 end
@@ -51,7 +103,7 @@ local function getDefNode(funcNode, i)
         return nil
     end
 
-    expandGenerics(defNode)
+    expandGenerics(defNode, classGenericMap)
 
     return defNode
 end
@@ -87,12 +139,14 @@ return function (uri, callback)
         end
         await.delay()
         local funcNode = vm.compileNode(source.node)
+        -- Get the class generic map for method calls on generic class instances
+        local classGenericMap = getReceiverGenericMap(uri, source)
         for i, arg in ipairs(source.args) do
             local refNode = vm.compileNode(arg)
             if not refNode then
                 goto CONTINUE
             end
-            local defNode = getDefNode(funcNode, i)
+            local defNode = getDefNode(funcNode, i, classGenericMap)
             if not defNode then
                 goto CONTINUE
             end

script/core/diagnostics/undefined-doc-name.lua

@@ -54,18 +54,22 @@ local function isClassGenericParam(source, name, uri)
     end
 
     -- Check if bound to a method on a generic class
-    -- First, find the function from any doc in the bindGroup
+    -- Find the function from any doc in the bindGroup
     local func = nil
     if bindGroup then
         for _, other in ipairs(bindGroup) do
             local bindSource = other.bindSource
             if bindSource then
                 if bindSource.type == 'function' then
+                    -- doc.return binds directly to function
                     func = bindSource
                     break
-                elseif bindSource.parent and bindSource.parent.type == 'function' then
-                    func = bindSource.parent
-                    break
+                else
+                    -- doc.param binds to local param, find containing function
+                    func = guide.getParentFunction(bindSource)
+                    if func then
+                        break
+                    end
                 end
             end
         end

script/vm/compiler.lua

@@ -280,11 +280,12 @@ local function containsGenericName(obj)
     return false
 end
 
+---Builds a map from generic parameter names to their concrete types
 ---@param uri uri
 ---@param classGlobal vm.global
 ---@param signs parser.object[]
 ---@return table<string, vm.node>?
-local function getClassGenericMap(uri, classGlobal, signs)
+function vm.getClassGenericMap(uri, classGlobal, signs)
     for _, set in ipairs(classGlobal:getSets(uri)) do
         if set.type == 'doc.class' and set.signs then
             local resolved = {}
@@ -315,7 +316,7 @@ local function resolveGenericField(uri, classGlobal, field, signs)
     if not containsGenericName(field.extends) then
         return nil
     end
-    local resolved = getClassGenericMap(uri, classGlobal, signs)
+    local resolved = vm.getClassGenericMap(uri, classGlobal, signs)
     if not resolved then
         return nil
     end
@@ -1724,7 +1725,7 @@ local function bindReturnOfFunction(source, mfunc, index, args)
                     if rn.type == 'doc.type.sign' and rn.signs and rn.node and rn.node[1] then
                         local classGlobal = vm.getGlobal('type', rn.node[1])
                         if classGlobal then
-                            local genericMap = getClassGenericMap(guide.getUri(source), classGlobal, rn.signs)
+                            local genericMap = vm.getClassGenericMap(guide.getUri(source), classGlobal, rn.signs)
                             if genericMap and mfunc.bindDocs then
                                 for _, doc in ipairs(mfunc.bindDocs) do
                                     if doc.type == 'doc.return' then

test/diagnostics/undefined-doc-name.lua

@@ -46,6 +46,15 @@ function Map:get(key)
 end
 ]]
 
+-- Variable name different from class name
+TEST [[
+---@class Pool<T>
+local M = {}
+
+---@param item T
+function M:push(item) end
+]]
+
 -- Undefined types SHOULD still warn (control case)
 TEST [[
 ---@class Container<T>