Recognize a class inheriting a generic one as a child of its parent

A parent given with arguments (`---@Class A : B<string>`) is parsed into `doc.type.sign`,
which keeps the name one level down. The inheritance walk only looked at plain names, so
such a parent was skipped entirely: `A` was not recognized as a child of whatever `B`
itself inherits, and passing it where the base type is expected reported a mismatch.

The name is now taken from the sign node as well.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: RomanSpector

script/vm/type.lua

@@ -589,9 +589,21 @@ function vm.isSubType(uri, child, parent, mark, errs)
             for _, set in ipairs(childClass:getSets(uri)) do
                 if set.type == 'doc.class' and set.extends then
                     for _, ext in ipairs(set.extends) do
-                        if  ext.type == 'doc.extends.name'
-                        and (not isBasicType or guide.isBasicType(ext[1]))
-                        and vm.isSubType(uri, ext[1], parent, mark, errs) == true then
+                        -- A parent given with arguments (`---@class A : B<string>`) is
+                        -- parsed into `doc.type.sign`, keeping the name one level down.
+                        -- Without looking inside, such a parent is skipped entirely and
+                        -- the class is not recognized as its child.
+                        local extName
+                        if ext.type == 'doc.extends.name' then
+                            extName = ext[1]
+                        elseif ext.type == 'doc.type.sign'
+                        and    ext.node
+                        and    ext.node.type == 'doc.extends.name' then
+                            extName = ext.node[1]
+                        end
+                        if  extName
+                        and (not isBasicType or guide.isBasicType(extName))
+                        and vm.isSubType(uri, extName, parent, mark, errs) == true then
                             mark[childName] = nil
                             return true
                         end

test/diagnostics/param-type-mismatch.lua

@@ -394,4 +394,23 @@ local function f(y) end
 f(x)
 ]]
 
+-- A class inheriting a generic one is still a child of that generic's own parent: the
+-- parent given with arguments is parsed one level down and used to be skipped.
+TEST [[
+---@class Base
+
+---@class Middle<T> : Base
+---@field Value T
+
+---@class Child : Middle<boolean>
+
+---@param value Base
+local function f(value) end
+
+---@type Child
+local child
+
+f(child)
+]]
+
 config.set(nil, 'Lua.type.checkTableShape', false)