Refactor: extract shared helpers and reduce nesting

- Extract vm.isResolvedToGeneric() helper to replace duplicated
  allGeneric checks in generic.lua, compiler.lua (3 locations)
- Extract findGenericInTableFields() and simplify
  findGenericInExtendsTable() in sign.lua to reduce nesting
- Add changelog entries for generic resolution fixes

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: RomanSpector

changelog.md

@@ -6,6 +6,10 @@
 * `CHG` Improved the output of test failures during development
 * `FIX` Fix type inference for `x == nil and "default" or x` idiom [#2236](https://github.com/LuaLS/lua-language-server/issues/2236)
 * `FIX` Fix type loss for assignments inside `if`/`for` blocks due to circular dependency in tracer [#2374](https://github.com/LuaLS/lua-language-server/issues/2374) [#2494](https://github.com/LuaLS/lua-language-server/issues/2494)
+* `FIX` Resolve generic class method return types for `@param self list<T>` pattern
+* `FIX` Fix `ipairs(self)` type resolution in generic class methods
+* `FIX` Fix double angle brackets in generic sign display (`list<<T>>` -> `list<T>`)
+* `FIX` Fix nil crash in `getParentClass` for `doc.field` without class
 
 ## 3.17.1
 `2026-01-20`

script/vm/compiler.lua

@@ -1671,19 +1671,10 @@ local function bindReturnOfFunction(source, mfunc, index, args)
                     else
                         local clonedObject = vm.cloneObject(nd, resolved)
                         if clonedObject then
-                            if clonedObject.type == 'doc.generic.name' and clonedObject._resolved then
-                                local allGeneric = true
-                                for rn in clonedObject._resolved:eachObject() do
-                                    if rn.type ~= 'doc.generic.name' then
-                                        allGeneric = false
-                                        break
-                                    end
-                                end
-                                if allGeneric then
-                                    result:merge(clonedObject)
-                                else
-                                    result:merge(vm.compileNode(clonedObject))
-                                end
+                            if clonedObject.type == 'doc.generic.name'
+                            and clonedObject._resolved
+                            and vm.isResolvedToGeneric(clonedObject._resolved) then
+                                result:merge(clonedObject)
                             else
                                 result:merge(vm.compileNode(clonedObject))
                             end
@@ -1790,16 +1781,7 @@ local function bindReturnOfFunction(source, mfunc, index, args)
             elseif rnode._resolved then
                 -- Allow generics that resolved to another generic type
                 -- parameter (e.g. V -> T in generic method's ipairs(self)).
-                -- Only allow when resolved purely to other generics, not
-                -- to concrete types like string/boolean.
-                local allGeneric = true
-                for rn in rnode._resolved:eachObject() do
-                    if rn.type ~= 'doc.generic.name' then
-                        allGeneric = false
-                        break
-                    end
-                end
-                if allGeneric then
+                if vm.isResolvedToGeneric(rnode._resolved) then
                     vm.setNode(source, rnode)
                 end
             end

script/vm/generic.lua

@@ -199,20 +199,10 @@ function mt:resolve(uri, args)
                 -- inside a generic method), keep the resolved wrapper so
                 -- the resolution chain is preserved and downstream filters
                 -- can distinguish "resolved to generic T" from "unresolved".
-                if clonedObject.type == 'doc.generic.name' and clonedObject._resolved then
-                    local allGeneric = true
-                    for rn in clonedObject._resolved:eachObject() do
-                        if rn.type ~= 'doc.generic.name' then
-                            allGeneric = false
-                            break
-                        end
-                    end
-                    if allGeneric then
-                        result:merge(clonedObject)
-                    else
-                        local clonedNode = vm.compileNode(clonedObject)
-                        result:merge(clonedNode)
-                    end
+                if clonedObject.type == 'doc.generic.name'
+                and clonedObject._resolved
+                and vm.isResolvedToGeneric(clonedObject._resolved) then
+                    result:merge(clonedObject)
                 else
                     local clonedNode   = vm.compileNode(clonedObject)
                     result:merge(clonedNode)
@@ -243,6 +233,20 @@ function vm.isGenericUnsolved(source)
     return false
 end
 
+--- Check if a resolved node contains only generic name objects.
+--- Used to distinguish "V resolved to generic T" (preserve wrapper)
+--- from "V resolved to concrete string" (unwrap normally).
+---@param node vm.node
+---@return boolean
+function vm.isResolvedToGeneric(node)
+    for rn in node:eachObject() do
+        if rn.type ~= 'doc.generic.name' then
+            return false
+        end
+    end
+    return true
+end
+
 ---@param source parser.object
 ---@param generic vm.generic
 function vm.setGeneric(source, generic)

script/vm/sign.lua

@@ -2,6 +2,53 @@ local guide         = require 'parser.guide'
 ---@class vm
 local vm            = require 'vm.vm'
 
+--- Find a generic name referenced in a doc.type.table's fields
+--- that exists in the given genericMap.
+---@param tableType parser.object  doc.type.table with fields
+---@param genericMap table<string, vm.node>
+---@return string?  The matching generic key name
+local function findGenericInTableFields(tableType, genericMap)
+    for _, field in ipairs(tableType.fields) do
+        if field.extends then
+            local found
+            guide.eachSourceType(field.extends, 'doc.generic.name', function (src)
+                if genericMap[src[1]] then
+                    found = src[1]
+                end
+            end)
+            if found then
+                return found
+            end
+        end
+    end
+    return nil
+end
+
+--- Search for a generic name in extends tables of a class definition.
+--- For classes like `@class list<T>: {[integer]:T}`, the [integer] field
+--- lives in the extends doc.type.table, not in @field annotations.
+---@param uri uri
+---@param classGlobal vm.global
+---@param genericMap table<string, vm.node>
+---@return string?  The class generic name that maps to the integer field
+local function findGenericInExtendsTable(uri, classGlobal, genericMap)
+    for _, set in ipairs(classGlobal:getSets(uri)) do
+        if set.type ~= 'doc.class' or not set.extends then
+            goto CONTINUE
+        end
+        for _, ext in ipairs(set.extends) do
+            if ext.type == 'doc.type.table' and ext.fields then
+                local key = findGenericInTableFields(ext, genericMap)
+                if key then
+                    return key
+                end
+            end
+        end
+        ::CONTINUE::
+    end
+    return nil
+end
+
 ---@class vm.sign
 ---@field parent    parser.object
 ---@field signList  vm.node[]
@@ -112,26 +159,10 @@ function mt:resolve(uri, args)
                             end)
                             -- Also search extends tables (for @class list<T>: {[integer]:T})
                             if not handled then
-                                for _, set in ipairs(classGlobal:getSets(uri)) do
-                                    if set.type == 'doc.class' and set.extends then
-                                        for _, ext in ipairs(set.extends) do
-                                            if ext.type == 'doc.type.table' and ext.fields then
-                                                for _, field in ipairs(ext.fields) do
-                                                    if field.extends then
-                                                        guide.eachSourceType(field.extends, 'doc.generic.name', function (src)
-                                                            if genericMap[src[1]] then
-                                                                resolved[vKey] = genericMap[src[1]]
-                                                                handled = true
-                                                            end
-                                                        end)
-                                                    end
-                                                    if handled then break end
-                                                end
-                                            end
-                                            if handled then break end
-                                        end
-                                    end
-                                    if handled then break end
+                                local genericKey = findGenericInExtendsTable(uri, classGlobal, genericMap)
+                                if genericKey then
+                                    resolved[vKey] = genericMap[genericKey]
+                                    handled = true
                                 end
                             end
                         end