[lewis6991]

Table literals passed to the standard table<K, V> type can report inject-field for valid entries, while invalid keys or values can go unchecked.

---@param values table<integer, string>
local function accept(values) return values end
accept({'a'})        -- valid
accept({name = 'a'}) -- invalid key
accept({1})          -- invalid value

Validate constructor contents through the shared type checker. The call-selection and recursive-type changes support this validation: they preserve the correct parameter contract and let nested checks finish without skipping invalid fields.

Table contents

• Check array elements, dictionary entries, and record fields, including nested constructors reached through variables and module references.
• Check literal keys and values exactly. Require one union alternative to accept the whole constructor and require every intersection component to accept it.
• Check every non-nil value alternative. Follow Lua's rules for nil entries, integral float keys, and multiple results in the final unkeyed field.
• Keep closed-class field checks for user-defined types, including classes named table.

Calls and diagnostics

Separate call checks could select different overloads, ignore required arguments, or lose generic bindings and method receiver offsets:

---@param values table<integer, string>
---@overload fun(values: table<string, integer>, required: boolean)
local function accept(values) return values end
accept({count = 1}, true)       -- valid
pcall(accept, {count = 1}, true) -- valid
accept({count = 1})             -- invalid

Filter table overloads by argument count, then use one candidate and its bindings for type and field errors. Share this selection between direct calls and pcall, and remove the duplicate call loops from the assignment and field checkers.

Report call type errors as param-type-mismatch. Prefer enabled field errors over a duplicate argument error, while retaining the type error when field diagnostics are disabled.

Recursive and optional values

Re-entry detection alone does not catch recursive steps that create different type identities:

---@alias Tree<T> table<string, string | Tree<T[]>>

Stabilize unused recursive arguments while preserving arguments that affect fields, including indirect dependencies. Reuse the shared comparison queue and mark constructor field traversal as structural. This lets cyclic module values terminate without hiding an invalid leaf.

Preserve optional object and mapped fields as unions with nil. Check absent required fields through the normal type checker, and preserve non-nil narrowing when the built-in type function guards the same access path.