Inherited field loses type when reassigned in child class

[LnxFCA]

How are you using the lua-language-server?

Visual Studio Code Extension (sumneko.lua)

Which OS are you using?

Linux

What is the issue affecting?

Type Checking, Diagnostics/Syntax Checking

Expected Behaviour

---@class TArg
---@field x number
---@field y number

---@class Parent
---@field T TArg

---@class Child : Parent
Child = {}

function Child:init()
    self.T = { y = 1, w = 1}  --- Expect type warning
end

print(Child.T) -- Expect T to be TArg but got `table`

• LuaLS should warn that { y = 1, w = 1 } does not match TArg (since w is not defined).
• Child.T should retain its inherited type (TArg), not become table.

Actual Behaviour

• LuaLS does not warn about the incorrect structure.
• T in Child is now treated as unknown or table, instead of TArg.

Reproduction steps

• Paste the code snippet on any editor and check the types

Additional Notes

Possible workarounds

• Manually redeclaring T in Child

---@class Child : Parent
---@field T TArg

This issue is particularly problematic in large projects where inheritance is heavily used. Manually re-declaring every inherited field just because it gets reassigned is redundant and error-prone.

Log File

No response

[tomlau10]

Maybe the exact class attribute is what you want 🤔
https://luals.github.io/wiki/annotations/#class

---@class TArg
---@field x number
---@field y number

---@class Parent
---@field T TArg

---@class (exact) Child: Parent
local Child = {}

function Child:init()
    self.T = { y = 1, w = 1}  --> Missing required fields in type `TArg`: `x`
end

print(Child.T) --> Child.T: TArg

• the (exact) attribute means nothing can be injected to the class, so it will only use what it has already defined
• but I don't know why it doesn't work on global namespace, i.e. if you don't use local Child = {} this doesn't work, maybe that's another bug
• however with the (exact) class attribute, you can't auto inject fields either

function Child:setName(name)
    self.name = name  --> Fields cannot be injected into the reference of `Child` for `name`.
end

=> you must define it first using @field under your Child class

[LnxFCA]

Maybe the exact class attribute is what you want 🤔 https://luals.github.io/wiki/annotations/#class

Looks like (exact) is what I need.

• types.lua

---@meta

---@class TArg
---@field x number
---@field y number

---@class Parent
---@field T TArg

---@class (exact) Child : Parent

• main.lua

---@type Child
Child = {}

function Child:init()
    self.T = { y = 1, w = 1}  --> Missing required fields in type `TArg`: `x`
end

This method seems to work, however it requires using a definition file for global variables.

[tomlau10]

I don't think @type is used in this way. 😕

The main difference between using @class or @type to annotate a variable is that:

• for @class, all injected methods and fields will be treated as definition of that class automatically
  for example:

---@class A
local A = {}

function A:setName(name)
    self.name = name
end

--> even though we didn't write any `@field`, luals will auto infer `class A` to have:
-- `setName` method
-- and `name` field
-- will provide auto completion for the above

---@type A
local a
a. --> suggests `name`, `setName(self, name)`
a: --> suggests `setName(name)`

• but if you use @type for the namespace, no fields are injected, they won't be in the completion

---@class A

---@type A
local A = {}

function A:setName(name) --> Fields cannot be injected into the reference of `A` for `setName`. To do so, use `---@class` for `A`.
    self.name = name --> Fields cannot be injected into the reference of `A` for `name`. To do so, use `---@class` for `self`.
end

---@type A
local a
a. --> suggests nothing
a: --> suggests nothing

---

Another workaround

If you really want the Child namespace to be in the global scope, another workaround is like this:

---@meta

---@class TArg
---@field x number
---@field y number

---@class Parent
---@field T TArg

---@class (exact) Child : Parent
local Child = {}
_G.Child = Child

function Child:init()
    self.T = { y = 1, w = 1}  --> Missing required fields in type `TArg`: `x`
end

• first define it as local
• then export it to _G (luals will add it to global scope)
• finally in your other files, when you access Child global
  => it will be inferred as @type Child, and will have completions as expected

[LnxFCA]

I understand what you mean, but in my case I have to use the ---@type method, since I'm writing definition files for code that's not mine, so I'm not allowed to make significant editions on the base code, for that reason I'm using a definition file to write the types and ---@type to apply them.

[LnxFCA]

Another workaround
If you really want the Child namespace to be in the global scope, another workaround is like...

After testing your example for some time, I found that maybe the problem isn't with the LS but how I was using the annotation system, using your workaround works for me and there's not type loss on the Child class and subclasses of it.