fix: support generic class inheritance with type arguments

Fixes #1929 - Classes can now extend generic classes with specific type
parameters and fields are properly resolved.

Changes:
- Parser: Support doc.type.sign for class extends (e.g., Bar: Foo<integer>)
- Parser: Include doc.field in bindGeneric() to convert generic type names
- VM: Add resolveGenericField() to resolve generic parameters in field types
- VM: Handle doc.type.sign extends in class field inheritance search
- VM: Export vm.cloneObject() for generic type resolution

Example that now works:
  ---@Class Foo<T>
  ---@field a T
  ---@Class Bar: Foo<integer>
  local x ---@type Bar
  local what = x.a  -- Now infers as 'integer' instead of 'unknown'

Author: ian-pascoe

script/parser/luadoc.lua

@@ -1030,6 +1030,12 @@ local docSwitch = util.switch()
                 }
                 return result
             end
+            if extend.type == 'doc.extends.name' then
+                local signResult = parseTypeUnitSign(result, extend)
+                if signResult then
+                    extend = signResult
+                end
+            end
             result.extends[#result.extends+1] = extend
             result.finish = getFinish()
             if not checkToken('symbol', ',', 1) then
@@ -1850,7 +1856,8 @@ local function bindGeneric(binded)
         or doc.type == 'doc.return'
         or doc.type == 'doc.type'
         or doc.type == 'doc.class'
-        or doc.type == 'doc.alias' then
+        or doc.type == 'doc.alias'
+        or doc.type == 'doc.field' then
             guide.eachSourceType(doc, 'doc.type.name', function (src)
                 local name = src[1]
                 if generics[name] then

script/vm/compiler.lua

@@ -234,6 +234,56 @@ local function searchLiteralFieldFromTable(source, key, callback)
     end
 end
 
+---@param uri uri
+---@param classGlobal vm.global
+---@param field parser.object
+---@param signs parser.object[]
+---@return parser.object?
+local function resolveGenericField(uri, classGlobal, field, signs)
+    if field.type ~= 'doc.field' then
+        return nil
+    end
+    if not field.extends then
+        return nil
+    end
+    local hasGeneric = false
+    guide.eachSourceType(field.extends, 'doc.generic.name', function ()
+        hasGeneric = true
+    end)
+    if not hasGeneric then
+        return nil
+    end
+    for _, set in ipairs(classGlobal:getSets(uri)) do
+        if set.type == 'doc.class' and set.signs then
+            local resolved = {}
+            for i, signName in ipairs(set.signs) do
+                local signType = signs[i]
+                if signType and signName[1] then
+                    local signNode = vm.compileNode(signType)
+                    resolved[signName[1]] = signNode
+                end
+            end
+            if next(resolved) then
+                local newExtends = vm.cloneObject(field.extends, resolved)
+                if newExtends then
+                    return {
+                        type    = field.type,
+                        start   = field.start,
+                        finish  = field.finish,
+                        parent  = field.parent,
+                        field   = field.field,
+                        extends = newExtends,
+                        visible = field.visible,
+                        optional = field.optional,
+                    }
+                end
+            end
+            break
+        end
+    end
+    return nil
+end
+
 local searchFieldSwitch = util.switch()
     : case 'table'
     : call(function (_suri, source, key, pushResult)
@@ -357,7 +407,16 @@ local searchFieldSwitch = util.switch()
         if not globalVar then
             return
         end
-        vm.getClassFields(suri, globalVar, key, pushResult)
+        vm.getClassFields(suri, globalVar, key, function (field, isMark)
+            if source.signs then
+                local newField = resolveGenericField(suri, globalVar, field, source.signs)
+                if newField then
+                    pushResult(newField, isMark)
+                    return
+                end
+            end
+            pushResult(field, isMark)
+        end)
     end)
     : case 'global'
     : call(function (suri, node, key, pushResult)
@@ -565,14 +624,21 @@ function vm.getClassFields(suri, object, key, pushResult)
 
         for _, set in ipairs(sets) do
             if set.type == 'doc.class' then
-                -- 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
+                        elseif extend.type == 'doc.type.sign' then
+                            searchFieldSwitch(extend.type, suri, extend, key, function (field, isMark)
+                                local fieldKey = guide.getKeyName(field)
+                                if fieldKey and not searchedFields[fieldKey] then
+                                    hasFounded[fieldKey] = true
+                                    pushResult(field, isMark)
+                                end
+                            end)
                         end
                     end
                 end

script/vm/generic.lua

@@ -173,3 +173,10 @@ function vm.createGeneric(proto, sign)
     }, mt)
     return generic
 end
+
+---@param source    vm.object?
+---@param resolved? table<string, vm.node>
+---@return vm.object?
+function vm.cloneObject(source, resolved)
+    return cloneObject(source, resolved)
+end

test/type_inference/common.lua

@@ -4909,3 +4909,49 @@ function f(...args)
     print(<?args?>)
 end
 ]]
+
+TEST 'integer' [[
+---@class Foo<T>
+---@field a T
+
+---@class Bar: Foo<integer>
+
+---@type Bar
+local x
+local <?what?> = x.a
+]]
+
+TEST 'string' [[
+---@class GenericBase<T>
+---@field value T
+
+---@class StringHolder: GenericBase<string>
+
+---@type StringHolder
+local holder
+local <?v?> = holder.value
+]]
+
+TEST 'boolean' [[
+---@class Container<K, V>
+---@field key K
+---@field val V
+
+---@class BoolContainer: Container<string, boolean>
+
+---@type BoolContainer
+local c
+local <?b?> = c.val
+]]
+
+TEST 'string' [[
+---@class Container<K, V>
+---@field key K
+---@field val V
+
+---@class BoolContainer: Container<string, boolean>
+
+---@type BoolContainer
+local c
+local <?k?> = c.key
+]]