@thigasdevelopment/luam 0.19.0 → 0.19.2

package/README.md

@@ -275,12 +275,15 @@ VSCodium and Windsurf. The language server itself is editor-agnostic and speaks
 
 ## Known limitations
 
-- **Narrowing reaches names, not fields.** `if value ~= nil then` refines a local;
-  `self.value` keeps its declared type however you test it.
+- **Narrowing follows a path, not an alias.** `if self.value ~= nil then` refines
+  the field inside the block; storing the test in a variable does not carry it.
 - **A class is a type everywhere, a value from its declaration** — `extends` may
   name a parent written further down, a top-level `new` may not.
 - **The MTA catalog can lag a release** — a newer function stays `any`.
-- **No static members, declared metamethods, or generic classes.**
+- **Three metamethods stay blocked** — `__index`, `__newindex` and `__call`.
+  Generic classes are supported.
+- **A method the receiver does not declare is not reported** — `counter:missing()`
+  keeps returning `any`; annotate the receiver to have the call checked.
 - **The editor re-checks by declaration** — a declaration change re-analyzes every
   file that can see it, an edit inside a function body only its own file.
 - **An export is named, never verified** against the side that calls it.

package/lua/class.lua

@@ -2,6 +2,22 @@ local classes = {}
 
 local constructors = {}
 
+local ALLOWED_METAMETHODS = {
+    ['__tostring'] = true,
+    ['__eq'] = true,
+    ['__lt'] = true,
+    ['__le'] = true,
+    ['__len'] = true,
+    ['__concat'] = true,
+    ['__unm'] = true,
+    ['__add'] = true,
+    ['__sub'] = true,
+    ['__mul'] = true,
+    ['__div'] = true,
+    ['__mod'] = true,
+    ['__pow'] = true,
+}
+
 local BLOCKED_METAMETHODS = {
     ['__call'] = true,
     ['__index'] = true,
@@ -73,7 +89,7 @@ local function create(name, struct, options)
 
     definition = definition or { __name = name }
 
-    definition.__pending = nil
+    definition.__pending = false
     definition.__super = options.super
     definition.__metamethods = options.metamethods
 
@@ -140,19 +156,41 @@ function class(name)
     })
 end
 
-local function instanceMetatable(definition)
-    local meta = { __index = definition }
-
-    if not definition.__metamethods then
-        return meta
-    end
-
-    for key, value in pairs(definition.__metamethods) do
+local function installMetamethods(meta, source)
+    for key, value in pairs(source) do
         if BLOCKED_METAMETHODS[key] then
             error('Cannot override metamethod ' .. tostring(key) .. '.')
         end
 
-        meta[key] = value
+        if ALLOWED_METAMETHODS[key] then
+            meta[key] = value
+        end
+    end
+end
+
+local function inheritedMetamethods(meta, definition)
+    local chain = {}
+    local current = definition.__super
+
+    while type(current) == 'table' do
+        table.insert(chain, current)
+
+        current = current.__super
+    end
+
+    for index = #chain, 1, -1 do
+        installMetamethods(meta, chain[index])
+    end
+end
+
+local function instanceMetatable(definition)
+    local meta = { __index = definition }
+
+    inheritedMetamethods(meta, definition)
+    installMetamethods(meta, definition)
+
+    if definition.__metamethods then
+        installMetamethods(meta, definition.__metamethods)
     end
 
     return meta

package/lua/validate.lua

@@ -0,0 +1,239 @@
+local MAX_DEPTH = 16
+local MAX_ENTRIES = 4096
+local MAX_STRING = 65536
+
+local describe
+
+local function joinPath(path, segment)
+    if path == '' then
+        return segment
+    end
+
+    return path .. '.' .. segment
+end
+
+local function describeUnion(descriptor)
+    local parts = {}
+
+    for index = 1, #descriptor.options do
+        parts[index] = describe(descriptor.options[index])
+    end
+
+    return table.concat(parts, ' | ')
+end
+
+describe = function(descriptor)
+    local kind = descriptor.kind
+
+    if kind == 'literal' then
+        if type(descriptor.value) == 'string' then
+            return "'" .. descriptor.value .. "'"
+        end
+
+        return tostring(descriptor.value)
+    end
+
+    if kind == 'optional' then
+        return describe(descriptor.element) .. '?'
+    end
+
+    if kind == 'array' then
+        return describe(descriptor.element) .. '[]'
+    end
+
+    if kind == 'map' then
+        return 'table<' .. describe(descriptor.key) .. ', ' .. describe(descriptor.value) .. '>'
+    end
+
+    if kind == 'union' then
+        return describeUnion(descriptor)
+    end
+
+    if kind == 'record' or kind == 'instance' then
+        return descriptor.name
+    end
+
+    return kind
+end
+
+local function fail(path, descriptor, reason)
+    local place = path == '' and 'value' or ('"' .. path .. '"')
+
+    if reason ~= nil then
+        error('luam-validate: ' .. place .. ' ' .. reason, 0)
+    end
+
+    error('luam-validate: ' .. place .. ' expected "' .. describe(descriptor) .. '"', 0)
+end
+
+local function countEntries(value, path, descriptor)
+    local total = 0
+
+    for _ in pairs(value) do
+        total = total + 1
+
+        if total > MAX_ENTRIES then
+            fail(path, descriptor, 'has more than ' .. MAX_ENTRIES .. ' entries')
+        end
+    end
+
+    return total
+end
+
+local function isInstanceOf(value, name)
+    local meta = getmetatable(value)
+    local definition = meta and meta.__index
+    local depth = 0
+
+    while type(definition) == 'table' and depth <= MAX_DEPTH do
+        if definition.__name == name then
+            return true
+        end
+
+        definition = definition.__super
+        depth = depth + 1
+    end
+
+    return false
+end
+
+local check
+
+local function checkRecord(value, descriptor, path, depth)
+    countEntries(value, path, descriptor)
+
+    for index = 1, #descriptor.members do
+        local member = descriptor.members[index]
+
+        check(value[member.key], member.value, joinPath(path, member.key), depth + 1)
+    end
+
+    return value
+end
+
+local function checkArray(value, descriptor, path, depth)
+    local total = countEntries(value, path, descriptor)
+
+    for index = 1, total do
+        check(value[index], descriptor.element, path .. '[' .. index .. ']', depth + 1)
+    end
+
+    return value
+end
+
+local function checkMap(value, descriptor, path, depth)
+    countEntries(value, path, descriptor)
+
+    for key, entry in pairs(value) do
+        check(key, descriptor.key, joinPath(path, tostring(key)) .. ' (key)', depth + 1)
+        check(entry, descriptor.value, joinPath(path, tostring(key)), depth + 1)
+    end
+
+    return value
+end
+
+local function matches(value, descriptor, depth)
+    local ok = pcall(check, value, descriptor, '', depth)
+
+    return ok
+end
+
+check = function(value, descriptor, path, depth)
+    if depth > MAX_DEPTH then
+        fail(path, descriptor, 'is nested deeper than ' .. MAX_DEPTH .. ' levels')
+    end
+
+    local kind = descriptor.kind
+
+    if kind == 'any' then
+        return value
+    end
+
+    if kind == 'optional' then
+        if value == nil then
+            return value
+        end
+
+        return check(value, descriptor.element, path, depth)
+    end
+
+    if kind == 'nil' then
+        if value ~= nil then
+            fail(path, descriptor)
+        end
+
+        return value
+    end
+
+    if kind == 'literal' then
+        if value ~= descriptor.value then
+            fail(path, descriptor)
+        end
+
+        return value
+    end
+
+    if kind == 'string' or kind == 'number' or kind == 'boolean' or kind == 'userdata' or kind == 'thread' or kind == 'function' then
+        if type(value) ~= kind then
+            fail(path, descriptor)
+        end
+
+        if kind == 'string' and #value > MAX_STRING then
+            fail(path, descriptor, 'is longer than ' .. MAX_STRING .. ' characters')
+        end
+
+        return value
+    end
+
+    if kind == 'table' then
+        if type(value) ~= 'table' then
+            fail(path, descriptor)
+        end
+
+        return value
+    end
+
+    if kind == 'union' then
+        for index = 1, #descriptor.options do
+            if matches(value, descriptor.options[index], depth) then
+                return value
+            end
+        end
+
+        fail(path, descriptor)
+    end
+
+    if type(value) ~= 'table' then
+        fail(path, descriptor)
+    end
+
+    if kind == 'record' then
+        return checkRecord(value, descriptor, path, depth)
+    end
+
+    if kind == 'array' then
+        return checkArray(value, descriptor, path, depth)
+    end
+
+    if kind == 'map' then
+        return checkMap(value, descriptor, path, depth)
+    end
+
+    if kind == 'instance' then
+        if not isInstanceOf(value, descriptor.name) then
+            fail(path, descriptor)
+        end
+
+        return value
+    end
+
+    return value
+end
+
+function __luam_validate(value, descriptor)
+    return check(value, descriptor, '', 1)
+end
+
+function __luam_matches(value, descriptor)
+    return matches(value, descriptor, 1)
+end