`inject-field` error (`exact`) is not working as expected?

[Rathoz]

How are you using the lua-language-server?

Visual Studio Code Extension (sumneko.lua)

Which OS are you using?

Windows

What is the issue affecting?

Type Checking

Expected Behaviour

Based on the wiki https://luals.github.io/wiki/annotations/#class I would expect that inject-field error only show up if exact is provided the class annotation

Actual Behaviour

Classes without exact gets inject-field error

Reproduction steps

---@class Foo
---@field a string
local Foo = {}

---@return Foo
function Foo.new()
    return {a = 'abc'} -- Pretend this make a proper new object or smt
end

local function doSomething()
    local foo = Foo.new()
    foo.bar = 'baz' --- Fields cannot be injected into the reference of `Foo` for `bar`. To do so, use `---@class` for `foo`. Lua Diagnostics.(inject-field)
end

Additional Notes

No response

Log File

No response

[tomlau10]

I would expect that inject-field error only show up if exact is provided the class annotation

Nope. This is the normal behavior. Basically You can declare class fields in 2 ways:

• directly use ---@field
• add fields (or methods) to the variable annotated by ---@class
• or use combination of the above

---

• In your example local Foo is annotated by ---@class, so you can add fields/methods to this variable and LuaLS will merges added fields into the class Foo:

  
  ---@class Foo
  ---@field a string  -- method1: you declared a string field `a` by `---@field`
  local Foo = {}

---@return Foo function Foo.new() -- method2: you are adding a new() function field to the class Foo return {a = 'abc'} -- Pretend this make a proper new object or smt end

- On the other hand, `---@class (exact)` means that you can only use **method 1** (`---@field`) to declare fields/function/methods of a class. That is if you write `---@class (exact) Foo`, your `function Foo.new` will already throw this `inject-field` warning.

---
A few ways to tackle this warning:
- declare the `bar` field in `---@class Foo`
- Add `---@class` for `foo` (as stated by the warning)
```lua
local function doSomething()
    ---@class Foo
    local foo = Foo.new()
    ...
end

• disable the inject-field warning

The last one is probably not a good idea, because in this case, LuaLS actually DOES NOT KNOW that Foo class has the field bar, and you can't do those goto defintion thing for this field.

[Rathoz]

Then the docs probably needs to be updated as they state

Marking the class as (exact) means fields cannot be injected after the definition.

With the example used as

---@class (exact) Point
---@field x number
---@field y number
local Point = {}
Point.x = 1 -- OK
Point.y = 2 -- OK
Point.z = 3 -- Warning

[tomlau10]

I think the example that you quoted from wiki is perfectly fine? It strictly follows the rule "fields cannot be injected after the definition"

• there exist x and y fields by using the ---@field annotation
• therefore the following Point.x and Point.y => OK
• but the last one Point.z triggers the inject-field warning

---

In my own opinion, there is indeed a difference between a class and an instance.

• when you annotate the variable using ---@class => this is a class variable and newly injected fields should be merged to class definition
• while in your first example local foo = Foo.new() => this just returns an instance of the Foo class, and generally no extra fields should be allowed to inject into an instance of Foo class, which will make this variable different from the definition of exiting Foo class. Unless you explicitly specify that the new variable acts as a class variable. 🤔

[Rathoz]

Alright, fair.

I still think the documentation should be clarified