fix: generic type resolution for class methods and iterators

[RomanSpector]

Summary

Comprehensive fixes for generic type resolution in class methods, improving type inference for generic class patterns.

Problems Fixed

1. Generic class method return types not resolved (compiler.lua, sign.lua)

When calling a method on a generic class instance, return types using class generic parameters were not resolved:

---@class list<T>: {[integer]:T}

---@generic T
---@param self list<T>
---@param i intger
---@return T
function list:get(i) ... end

---@type list<string>
local strings
local v = strings:get(1) -- was: unknown, now: string

2. Nested generic resolution in doc.type.sign (generic.lua)

Generic parameters inside nested sign types (e.g. table<uint32, list<T>>) were not being cloned/resolved correctly, causing display issues like list<<T>> and incorrect type resolution.

3. ipairs(self) in generic class methods (sign.lua, generic.lua, compiler.lua)

Loop variables from ipairs(self) inside generic methods were not resolved:

---@class list<T>: {[integer]:T}

---@generic T
---@param self list<T>
function list:each()
    for i, v in ipairs(self) do
        -- v was: unknown, now: T
    end
end

The fix works through three layers:

• sign.lua: Resolve V[] (from ipairs signature) against generic classes via class generic map, searching both @field annotations and extends tables ({[integer]:T})
• generic.lua: Preserve generic-to-generic resolution wrappers (V->T) in mt:resolve when the resolved value is another generic parameter
• compiler.lua: Allow resolved generic wrappers through the return type filter in bindReturnOfFunction

4. Double angle brackets in display (infer.lua)

Generic type parameters were displayed with double brackets: list<<T>> instead of list<T>. Fixed by stripping outer <> from generic name views when rendering doc.type.sign parameters, since the sign already wraps them.

5. Nil crash in invisible diagnostics (visible.lua)

getParentClass crashed with "attempt to index nil value" when a doc.field had no associated class. Added nil guard.

Test Plan

• All existing tests pass (type_inference, hover, completion, diagnostics, full suite)
• New tests for ipairs(self) with @field [integer] T pattern
• New tests for ipairs(self) with @class list<T>: {[integer]:T} pattern
• Updated display tests: table<K, V> instead of table<<K>, <V>>
• Manual testing in VSCode with generic class code

[gemini-code-assist]

Code Review

This pull request implements several fixes for type inference and generic resolution, specifically addressing type loss in control flow blocks due to circular dependencies and improving the inference of the x == nil and "default" or x idiom. It also enhances the handling of generic classes, arrays, and method return types, while preventing a nil crash in getParentClass and cleaning up generic type display formatting. Review feedback suggests documenting all major fixes in the changelog, extracting duplicated logic for identifying purely generic nodes into a shared utility, and refactoring deeply nested logic in script/vm/sign.lua for better maintainability.

[gemini-code-assist]

The changelog entries are for secondary fixes in this PR. Please also add entries for the main fixes related to generic type resolution as described in the PR summary. For example:

• FIX Resolve generic class method return types.
• FIX Correctly resolve nested generics in doc.type.sign.
• FIX Resolve loop variables for ipairs(self) in generic methods.
• FIX Fix display of generic types with double angle brackets (e.g., list<<T>>).
• FIX Prevent nil crash in getParentClass for doc.field without a class.

[RomanSpector]

Done. Added changelog entries for all main generic resolution fixes.

[gemini-code-assist]

This logic to check if a resolved node contains only generic names is duplicated in this file (lines 1796-1801) and also in script/vm/generic.lua (lines 203-209). To improve maintainability and reduce duplication, consider extracting this into a helper function in a shared module, for example on the vm object.

For example, you could define a function in vm.vm:

function vm.isPurelyGenericNode(node)
    if not node then return false end
    for rn in node:eachObject() do
        if rn.type ~= 'doc.generic.name' then
            return false
        end
    end
    return true
end

Then you could simplify this block and the other occurrences by calling vm.isPurelyGenericNode(...).

[RomanSpector]

Done. Extracted vm.isResolvedToGeneric() helper in generic.lua to replace all 3 duplicated checks.

[gemini-code-assist]

This block of code has a couple of areas for improvement:

1. Deep Nesting: The logic to search extends tables (lines 114-136) is nested up to 6 levels deep. This reduces readability and makes the code harder to maintain. Consider refactoring this into smaller helper functions to reduce the nesting depth.

2. Inefficient Loops: The callbacks to guide.eachSourceType (lines 105-110 and 121-126) set handled = true, but the loops continue to iterate. If guide.eachSourceType can be made to break early (e.g., by returning a value from the callback), it would improve efficiency.

[RomanSpector]

Done. Extracted findGenericInTableFields() and simplified findGenericInExtendsTable() — max nesting reduced from 6 to 3 levels.