fix: handle composite generic return types (T[], Wrapper<T>)

Address PR review comment: The previous implementation only handled direct
T → string substitution but failed for composite types like T[] or Wrapper<T>.

Changes:
- Use vm.cloneObject on the actual return annotation (doc.return) instead
  of iterating through compiled node objects
- Extend vm.cloneObject to handle doc.type.name when name matches a generic
  param (converts to doc.generic.name with _resolved set)
- Extend vm.cloneObject to handle doc.type.sign for nested generic types,
  but only when signs contain doc.type.name needing resolution (preserves
  function-level generics like Callback<<T>>)

Added test cases for:
- T[] resolving to string[]
- Wrapper<T> resolving to Wrapper<string>

Author: ian-pascoe

script/vm/compiler.lua

@@ -1584,26 +1584,27 @@ local function bindReturnOfFunction(source, mfunc, index, args)
                                 end
                             end
 
-                            if next(genericMap) then
-                                -- Check the return node for global type references that match generic params
-                                local newReturnNode = vm.createNode()
-                                local hasReplacement = false
-                                for retNode in returnNode:eachObject() do
-                                    if retNode.type == 'global' and retNode.cate == 'type' then
-                                        local resolvedNode = genericMap[retNode.name]
-                                        if resolvedNode then
-                                            newReturnNode:merge(resolvedNode)
-                                            hasReplacement = true
-                                        else
-                                            newReturnNode:merge(retNode)
+                            if next(genericMap) and mfunc.bindDocs then
+                                for _, doc in ipairs(mfunc.bindDocs) do
+                                    if doc.type == 'doc.return' then
+                                        for _, rtn in ipairs(doc.returns) do
+                                            if rtn.returnIndex == index then
+                                                local newRtn = vm.cloneObject(rtn, genericMap)
+                                                if newRtn then
+                                                    returnNode = vm.compileNode(newRtn)
+                                                    for rnode in returnNode:eachObject() do
+                                                        if rnode.type == 'generic' then
+                                                            returnNode = rnode:resolve(guide.getUri(source), args)
+                                                            break
+                                                        end
+                                                    end
+                                                end
+                                                break
+                                            end
                                         end
-                                    else
-                                        newReturnNode:merge(retNode)
+                                        break
                                     end
                                 end
-                                if hasReplacement then
-                                    returnNode = newReturnNode
-                                end
                             end
                             break
                         end

script/vm/generic.lua

@@ -34,6 +34,21 @@ local function cloneObject(source, resolved)
         end
         return newName
     end
+    if source.type == 'doc.type.name' then
+        local key = source[1]
+        if resolved[key] then
+            local newName = {
+                type   = 'doc.generic.name',
+                start  = source.start,
+                finish = source.finish,
+                parent = source.parent,
+                [1]    = source[1],
+            }
+            vm.setNode(newName, resolved[key], true)
+            newName._resolved = resolved[key]
+            return newName
+        end
+    end
     if source.type == 'doc.type' then
         local newType = {
             type     = source.type,
@@ -113,6 +128,36 @@ local function cloneObject(source, resolved)
         end
         return newDocFunc
     end
+    if source.type == 'doc.type.sign' and source.signs then
+        local needsClone = false
+        for _, sign in ipairs(source.signs) do
+            if sign.type == 'doc.type' then
+                for _, tp in ipairs(sign.types) do
+                    if tp.type == 'doc.type.name' and resolved[tp[1]] then
+                        needsClone = true
+                        break
+                    end
+                end
+            elseif sign.type == 'doc.type.name' and resolved[sign[1]] then
+                needsClone = true
+            end
+            if needsClone then break end
+        end
+        if needsClone then
+            local newSign = {
+                type   = source.type,
+                start  = source.start,
+                finish = source.finish,
+                parent = source.parent,
+                node   = source.node,
+                signs  = {},
+            }
+            for i, sign in ipairs(source.signs) do
+                newSign.signs[i] = cloneObject(sign, resolved)
+            end
+            return newSign
+        end
+    end
     return source
 end
 

test/type_inference/common.lua

@@ -5011,3 +5011,38 @@ TEST 'store<string>' [[
 
 local <?string_store?> ---@type store<string>
 ]]
+
+-- Test composite return types with generics (T[] should resolve to string[])
+TEST 'string[]' [[
+---@class Container<T>
+local Container = {}
+
+---@return T[]
+function Container:getAll()
+    return {}
+end
+
+---@type Container<string>
+local c
+
+local <?items?> = c:getAll()
+]]
+
+-- Test nested generic return types (Wrapper<T> should resolve to Wrapper<string>)
+TEST 'Wrapper<string>' [[
+---@class Wrapper<V>
+---@field value V
+
+---@class Factory<T>
+local Factory = {}
+
+---@return Wrapper<T>
+function Factory:wrap()
+    return {}
+end
+
+---@type Factory<string>
+local f
+
+local <?wrapped?> = f:wrap()
+]]