lt-script 1.0.1 → 1.0.5

package/dist/compiler/semantics/SemanticAnalyzer.js

@@ -0,0 +1,682 @@
+import * as AST from '../parser/AST.js';
+class Scope {
+    symbols = new Map();
+    parent;
+    constructor(parent) {
+        this.parent = parent;
+    }
+    define(name, kind, type, line) {
+        // In strict mode we might check for redeclaration here
+        this.symbols.set(name, { name, kind, type, definedAtLine: line });
+    }
+    lookup(name) {
+        let current = this;
+        while (current) {
+            if (current.symbols.has(name)) {
+                return current.symbols.get(name);
+            }
+            current = current.parent;
+        }
+        return undefined;
+    }
+}
+export class SemanticAnalyzer {
+    globalScope = new Scope();
+    currentScope = this.globalScope;
+    typeRegistry = new Map(); // Stores interface fields
+    typeAliasRegistry = new Map(); // Stores type alias strings
+    memberTypes = new Map(); // Tracks Table.Field -> type mappings
+    functionRegistry = new Map(); // Stores function signatures
+    analyze(program) {
+        // Reset scope for fresh analysis (though typically instance is fresh)
+        this.currentScope = this.globalScope;
+        this.typeRegistry.clear();
+        this.typeAliasRegistry.clear();
+        this.memberTypes.clear();
+        this.functionRegistry.clear();
+        // First pass: Register types (to allow forward references)
+        for (const stmt of program.body) {
+            if (stmt.kind === AST.NodeType.TypeDecl) {
+                this.visitTypeDecl(stmt);
+            }
+            else if (stmt.kind === AST.NodeType.TypeAliasDecl) {
+                this.visitTypeAliasDecl(stmt);
+            }
+        }
+        // Second pass: Analyze code
+        for (const stmt of program.body) {
+            if (stmt.kind !== AST.NodeType.TypeDecl && stmt.kind !== AST.NodeType.TypeAliasDecl) {
+                this.visitStatement(stmt);
+            }
+        }
+    }
+    enterScope() {
+        this.currentScope = new Scope(this.currentScope);
+    }
+    exitScope() {
+        if (this.currentScope.parent) {
+            this.currentScope = this.currentScope.parent;
+        }
+    }
+    visitStatement(stmt) {
+        switch (stmt.kind) {
+            case AST.NodeType.VariableDecl:
+                this.visitVariableDecl(stmt);
+                break;
+            case AST.NodeType.TypeDecl:
+                this.visitTypeDecl(stmt);
+                break;
+            case AST.NodeType.AssignmentStmt:
+                this.visitAssignmentStmt(stmt);
+                break;
+            case AST.NodeType.CompoundAssignment:
+                this.visitCompoundAssignment(stmt);
+                break;
+            case AST.NodeType.FunctionDecl:
+                this.visitFunctionDecl(stmt);
+                break;
+            case AST.NodeType.Block:
+                this.visitBlock(stmt);
+                break;
+            case AST.NodeType.IfStmt:
+                {
+                    const s = stmt;
+                    this.visitExpression(s.condition);
+                    this.visitBlock(s.thenBody);
+                    s.elseIfClauses?.forEach(c => {
+                        this.visitExpression(c.condition);
+                        this.visitBlock(c.body);
+                    });
+                    if (s.elseBody)
+                        this.visitBlock(s.elseBody);
+                }
+                break;
+            case AST.NodeType.WhileStmt:
+                {
+                    const s = stmt;
+                    this.visitExpression(s.condition);
+                    this.visitBlock(s.body);
+                }
+                break;
+            case AST.NodeType.ForStmt:
+                {
+                    const s = stmt;
+                    this.enterScope(); // For loop creates scope for iterators
+                    s.iterators.forEach(i => this.currentScope.define(i.name, 'let', 'any', s.line || 0)); // Iterators can be anything in generic for
+                    this.visitExpression(s.iterable);
+                    // We can treat the body as part of this scope or nested. 
+                    // AST.Block usually suggests its own scope, but let's reuse this one or just visit statements.
+                    // Since AST.Block logic below creates a NEW scope, we have: Scope(Iterators) -> Scope(Body). This is correct.
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            case AST.NodeType.RangeForStmt:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    this.currentScope.define(s.counter.name, 'let', 'number', s.line || 0); // Range for is always number
+                    this.visitExpression(s.start);
+                    this.visitExpression(s.end);
+                    if (s.step)
+                        this.visitExpression(s.step);
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            // ... Handle other control flows that have blocks ...
+            case AST.NodeType.CommandStmt:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    s.params.forEach(p => this.currentScope.define(p.name.name, 'param', 'string', s.line || 0)); // Command params are strings (usually)
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            case AST.NodeType.EventHandler:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    s.params.forEach(p => this.currentScope.define(p.name.name, 'param', 'any', s.line || 0));
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            case AST.NodeType.TryCatchStmt:
+                {
+                    const s = stmt;
+                    this.visitBlock(s.tryBody);
+                    this.enterScope();
+                    this.currentScope.define(s.catchParam.name, 'let', 'any', s.line || 0);
+                    this.visitBlock(s.catchBody);
+                    this.exitScope();
+                }
+                break;
+            // Handle expression statements (standalone function calls like ProcessNumber("hello"))
+            case AST.NodeType.CallExpr:
+                this.visitExpression(stmt);
+                break;
+            // Basic fallback recursive visiting
+            default:
+                // Identify other nodes that contain blocks/expressions to visit
+                this.visitChildren(stmt);
+        }
+    }
+    visitChildren(node) {
+        if (!node || typeof node !== 'object')
+            return;
+        for (const key in node) {
+            if (key === 'kind')
+                continue;
+            const val = node[key];
+            if (Array.isArray(val)) {
+                val.forEach(v => {
+                    if (v && typeof v === 'object' && 'kind' in v) {
+                        if (v.kind.endsWith('Stmt') || v.kind === 'VariableDecl' || v.kind === 'Block') {
+                            this.visitStatement(v);
+                        }
+                        else {
+                            this.visitExpression(v);
+                        }
+                    }
+                });
+            }
+            else if (val && typeof val === 'object' && 'kind' in val) {
+                if (val.kind.endsWith('Stmt') || val.kind === 'VariableDecl' || val.kind === 'Block') {
+                    this.visitStatement(val);
+                }
+                else {
+                    this.visitExpression(val);
+                }
+            }
+        }
+    }
+    visitVariableDecl(decl) {
+        // Visit values first
+        if (decl.values) {
+            decl.values.forEach(v => this.visitExpression(v));
+        }
+        const kind = decl.scope === 'const' ? 'const' : 'let';
+        decl.names.forEach((n, index) => {
+            let type = 'any';
+            let customTypeName;
+            // 1. Try to get type from annotation
+            if (decl.typeAnnotations && decl.typeAnnotations[index]) {
+                const annotation = decl.typeAnnotations[index];
+                customTypeName = this.typeRegistry.has(annotation) ? annotation : undefined;
+                type = this.stringToType(annotation);
+            }
+            // 2. Try to infer from value if available
+            if (decl.values && decl.values[index]) {
+                const value = decl.values[index];
+                const inferred = this.inferType(value);
+                const annotation = decl.typeAnnotations && decl.typeAnnotations[index];
+                // If it's an array type (e.g., RobberyConfig[] or number[]) and value is a table, validate each element
+                if (annotation && annotation.endsWith('[]') && value.kind === AST.NodeType.TableLiteral) {
+                    const elementTypeName = annotation.slice(0, -2); // Remove []
+                    const expectedElementType = this.stringToType(elementTypeName);
+                    const tableValue = value;
+                    // Iterate through each element and validate
+                    for (let i = 0; i < tableValue.fields.length; i++) {
+                        const field = tableValue.fields[i];
+                        // If element is a TableLiteral and element type is an interface, validate against interface
+                        if (field.value.kind === AST.NodeType.TableLiteral && this.typeRegistry.has(elementTypeName)) {
+                            this.validateTableAgainstType(field.value, elementTypeName, decl.line || 0);
+                        }
+                        else {
+                            // For primitive types (number[], string[], etc.), check each element type
+                            const actualType = this.inferType(field.value);
+                            if (expectedElementType !== 'any' && actualType !== 'any' && expectedElementType !== actualType) {
+                                throw new Error(`Type mismatch in array at line ${decl.line}: Element ${i + 1} expected '${elementTypeName}', got '${actualType}'`);
+                            }
+                        }
+                    }
+                }
+                // If we have a custom type annotation and the value is a table (not array), validate it
+                else if (customTypeName && value.kind === AST.NodeType.TableLiteral) {
+                    this.validateTableAgainstType(value, customTypeName, decl.line || 0);
+                }
+                // If we have an annotation, check compatibility
+                if (type !== 'any' && inferred !== 'any' && type !== inferred) {
+                    throw new Error(`Type mismatch at line ${decl.line}: Expected '${type}', but got '${inferred}'`);
+                }
+                // If no annotation, keep type as 'any' (default)
+                // if (type === 'any' && (!decl.typeAnnotations || !decl.typeAnnotations[index])) {
+                //     type = inferred;
+                // }
+            }
+            if (n.kind === AST.NodeType.Identifier) {
+                this.currentScope.define(n.name, kind, type, decl.line || 0);
+            }
+            else if (n.kind === AST.NodeType.ObjectDestructure) {
+                n.properties.forEach(p => {
+                    this.currentScope.define(p.name, kind, 'any', decl.line || 0);
+                });
+            }
+            else if (n.kind === AST.NodeType.ArrayDestructure) {
+                n.elements.forEach(el => {
+                    this.currentScope.define(el.name, kind, 'any', decl.line || 0);
+                });
+            }
+        });
+    }
+    visitAssignmentStmt(stmt) {
+        // Check RHS
+        stmt.values.forEach(v => this.visitExpression(v));
+        // Check LHS
+        stmt.targets.forEach((t, index) => {
+            // If it's a simple identifier, check const and TYPE
+            if (t.kind === AST.NodeType.Identifier) {
+                const name = t.name;
+                const sym = this.currentScope.lookup(name);
+                if (sym) {
+                    if (sym.kind === 'const') {
+                        throw new Error(`Assignment to constant variable '${name}' at line ${stmt.line}`);
+                    }
+                    // Type Checking
+                    if (stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (sym.type !== 'any' && valueType !== 'any' && sym.type !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: Variable '${name}' is type '${sym.type}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+            }
+            // Handle member expression type checking
+            if (t.kind === AST.NodeType.MemberExpr) {
+                const member = t;
+                // 1. Strict Property Existence Check
+                if (member.object.kind === AST.NodeType.Identifier && !member.computed) {
+                    const objName = member.object.name;
+                    const sym = this.currentScope.lookup(objName);
+                    const propName = member.property.name;
+                    if (sym && sym.type !== 'any' && sym.type !== 'table') {
+                        // Check if it's an interface or alias
+                        let fields;
+                        // Remove array suffix for type lookup if needed (though variable shouldn't be array if accessing prop directly)
+                        const baseType = sym.type.replace('[]', '');
+                        if (this.typeRegistry.has(baseType)) {
+                            fields = this.typeRegistry.get(baseType);
+                        }
+                        else if (this.typeAliasRegistry.has(baseType)) {
+                            const aliasStr = this.typeAliasRegistry.get(baseType);
+                            if (aliasStr.startsWith('{')) {
+                                fields = this.parseObjectLiteralType(aliasStr);
+                            }
+                        }
+                        if (fields) {
+                            const fieldExists = fields.some(f => f.name === propName);
+                            if (!fieldExists) {
+                                throw new Error(`Property '${propName}' does not exist on type '${sym.type}' at line ${stmt.line}`);
+                            }
+                        }
+                    }
+                }
+                const memberKey = this.getMemberExprKey(t);
+                // If this assignment has a type annotation, register it
+                if (stmt.typeAnnotation && index === 0) {
+                    const type = this.stringToType(stmt.typeAnnotation);
+                    this.memberTypes.set(memberKey, type);
+                    // Also check that the value matches the declared type
+                    if (stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (type !== 'any' && valueType !== 'any' && type !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: '${memberKey}' is declared as '${stmt.typeAnnotation}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+                else {
+                    // Check if this member has a registered type
+                    const registeredType = this.memberTypes.get(memberKey);
+                    if (registeredType && stmt.values[index]) {
+                        const valueType = this.inferType(stmt.values[index]);
+                        if (registeredType !== 'any' && valueType !== 'any' && registeredType !== valueType) {
+                            throw new Error(`Type mismatch at line ${stmt.line}: '${memberKey}' is type '${registeredType}', but assigned '${valueType}'`);
+                        }
+                    }
+                }
+            }
+            this.visitExpression(t);
+        });
+    }
+    // Helper to get a string key for a member expression (e.g., "Config.Locale")
+    getMemberExprKey(expr) {
+        let parts = [];
+        let current = expr;
+        while (current.kind === AST.NodeType.MemberExpr) {
+            const memberExpr = current;
+            if (memberExpr.property.kind === AST.NodeType.Identifier) {
+                parts.unshift(memberExpr.property.name);
+            }
+            current = memberExpr.object;
+        }
+        if (current.kind === AST.NodeType.Identifier) {
+            parts.unshift(current.name);
+        }
+        return parts.join('.');
+    }
+    visitCompoundAssignment(stmt) {
+        this.visitExpression(stmt.value);
+        if (stmt.target.kind === AST.NodeType.Identifier) {
+            const name = stmt.target.name;
+            const sym = this.currentScope.lookup(name);
+            if (sym && sym.kind === 'const') {
+                throw new Error(`Assignment to constant variable '${name}' at line ${stmt.line}`);
+            }
+        }
+        this.visitExpression(stmt.target);
+    }
+    visitFunctionDecl(decl) {
+        // Name is defined in CURRENT scope
+        let funcName;
+        if (decl.name && decl.name.kind === AST.NodeType.Identifier) {
+            funcName = decl.name.name;
+            this.currentScope.define(funcName, 'const', 'function', decl.line || 0);
+        }
+        // Register function signature for call validation
+        const paramTypes = [];
+        decl.params.forEach(p => {
+            let type = 'any';
+            if (p.typeAnnotation) {
+                type = this.stringToType(p.typeAnnotation);
+            }
+            paramTypes.push({ name: p.name.name, type });
+        });
+        if (funcName) {
+            this.functionRegistry.set(funcName, { params: paramTypes });
+        }
+        this.enterScope();
+        decl.params.forEach(p => {
+            // Parse param type annotation
+            let type = 'any';
+            if (p.typeAnnotation) {
+                type = this.stringToType(p.typeAnnotation);
+            }
+            this.currentScope.define(p.name.name, 'param', type, decl.line || 0);
+            if (p.defaultValue) {
+                const defType = this.inferType(p.defaultValue);
+                if (type !== 'any' && defType !== 'any' && type !== defType) {
+                    throw new Error(`Type mismatch in parameter default value at line ${decl.line}`);
+                }
+                this.visitExpression(p.defaultValue);
+            }
+        });
+        this.visitBlock(decl.body);
+        this.exitScope();
+    }
+    visitBlock(block) {
+        this.enterScope();
+        block.statements.forEach(s => this.visitStatement(s));
+        this.exitScope();
+    }
+    visitExpression(expr) {
+        // Mostly just traversing to find nested scopes in functions/arrows
+        if (!expr)
+            return;
+        // Check for undefined variable usage
+        if (expr.kind === AST.NodeType.Identifier) {
+            const id = expr;
+            const sym = this.currentScope.lookup(id.name);
+            // Skip globals/builtins - only check if it looks like a user variable
+            // FiveM/Lua has many globals, so we only warn for simple lowercase identifiers
+            // that are not common Lua globals
+            const luaGlobals = ['print', 'type', 'tostring', 'tonumber', 'pairs', 'ipairs',
+                'next', 'error', 'assert', 'pcall', 'xpcall', 'require',
+                'table', 'string', 'math', 'os', 'io', 'coroutine', 'debug',
+                'setmetatable', 'getmetatable', 'rawget', 'rawset', 'rawequal',
+                'collectgarbage', 'dofile', 'load', 'loadfile', 'select',
+                'unpack', '_G', '_VERSION', 'true', 'false', 'nil',
+                // FiveM common globals
+                'Citizen', 'CreateThread', 'Wait', 'GetGameTimer', 'vector3',
+                'vector2', 'vector4', 'GetCurrentResourceName', 'exports',
+                'PlayerPedId', 'GetPlayerPed', 'GetEntityCoords', 'TriggerEvent',
+                'TriggerServerEvent', 'TriggerClientEvent', 'RegisterNetEvent',
+                'AddEventHandler', 'RegisterCommand', 'IsControlJustPressed',
+                'AddEventHandler', 'RegisterCommand', 'LocalPlayer', 'PlayerId',
+                'GetPlayerServerId', 'source', 'SetEntityHealth', 'ESX', 'QBCore',
+                // Additional FiveM/Lua globals
+                'Config', 'Framework', 'MySQL', 'lib', 'cache', 'json',
+                'NetworkGetNetworkIdFromEntity', 'NetworkGetEntityFromNetworkId',
+                'GetPlayerPed', 'GetVehiclePedIsIn', 'IsPedInAnyVehicle',
+                'SetPedCanRagdoll', 'SetTimeout', 'SetInterval', 'ClearTimeout',
+                'GetHashKey', 'IsModelValid', 'RequestModel', 'HasModelLoaded'];
+            if (!sym && !luaGlobals.includes(id.name)) {
+                // Check if it's a type name (not a variable)
+                if (!this.typeRegistry.has(id.name) && !this.typeAliasRegistry.has(id.name)) {
+                    throw new Error(`Undefined variable '${id.name}' at line ${id.line ?? 0}`);
+                }
+            }
+            return;
+        }
+        if (expr.kind === AST.NodeType.ArrowFunc) {
+            const arrow = expr;
+            this.enterScope();
+            arrow.params.forEach(p => {
+                let type = 'any';
+                if (p.typeAnnotation) {
+                    type = this.stringToType(p.typeAnnotation);
+                }
+                this.currentScope.define(p.name.name, 'param', type, expr.line || 0);
+                if (p.defaultValue)
+                    this.visitExpression(p.defaultValue);
+            });
+            if ('kind' in arrow.body && arrow.body.kind === AST.NodeType.Block) {
+                this.visitBlock(arrow.body);
+            }
+            else {
+                this.visitExpression(arrow.body);
+            }
+            this.exitScope();
+            return;
+        }
+        if (expr.kind === AST.NodeType.FunctionDecl) {
+            this.visitFunctionDecl(expr);
+            return;
+        }
+        // Handle TableLiteral - recurse into field values only
+        if (expr.kind === AST.NodeType.TableLiteral) {
+            const table = expr;
+            for (const field of table.fields) {
+                // Don't check keys - they are field names, not variable references
+                // Only check computed keys like [expression] or string keys
+                if (field.key && field.key.kind !== AST.NodeType.Identifier) {
+                    this.visitExpression(field.key);
+                }
+                this.visitExpression(field.value);
+            }
+            return;
+        }
+        // Handle BinaryExpr
+        if (expr.kind === AST.NodeType.BinaryExpr) {
+            const bin = expr;
+            this.visitExpression(bin.left);
+            this.visitExpression(bin.right);
+            return;
+        }
+        // Handle CallExpr - recurse into callee and args, validate argument types
+        if (expr.kind === AST.NodeType.CallExpr) {
+            const call = expr;
+            this.visitExpression(call.callee);
+            // Validate argument types if callee is a known function
+            if (call.callee.kind === AST.NodeType.Identifier) {
+                const funcName = call.callee.name;
+                const funcInfo = this.functionRegistry.get(funcName);
+                if (funcInfo) {
+                    // Check each argument against expected param type
+                    for (let i = 0; i < call.args.length && i < funcInfo.params.length; i++) {
+                        const expectedType = funcInfo.params[i].type;
+                        const argType = this.inferType(call.args[i]);
+                        if (expectedType !== 'any' && argType !== 'any' && expectedType !== argType) {
+                            throw new Error(`Type mismatch in function call '${funcName}' at line ${call.line || 0}: Argument ${i + 1} expects '${expectedType}', got '${argType}'`);
+                        }
+                    }
+                }
+            }
+            for (const arg of call.args) {
+                this.visitExpression(arg);
+            }
+            return;
+        }
+        // Handle MemberExpr - only check the object, not property (obj.property)
+        if (expr.kind === AST.NodeType.MemberExpr) {
+            const member = expr;
+            this.visitExpression(member.object);
+            // Don't check member.property - it's a field access, not a variable
+            return;
+        }
+    }
+    inferType(expr) {
+        if (!expr)
+            return 'any';
+        switch (expr.kind) {
+            case AST.NodeType.NumberLiteral: return 'number';
+            case AST.NodeType.StringLiteral: return 'string';
+            case AST.NodeType.InterpolatedString: return 'string';
+            case AST.NodeType.BooleanLiteral: return 'boolean';
+            case AST.NodeType.NilLiteral: return 'nil';
+            case AST.NodeType.VectorLiteral: return 'vector';
+            case AST.NodeType.TableLiteral: return 'table';
+            case AST.NodeType.FunctionDecl: return 'function';
+            case AST.NodeType.ArrowFunc: return 'function';
+            case AST.NodeType.Identifier:
+                const sym = this.currentScope.lookup(expr.name);
+                return sym ? sym.type : 'any';
+            // TODO: Improve binary expr inference (e.g. number + number = number)
+            case AST.NodeType.BinaryExpr: return 'any';
+            default:
+                return 'any';
+        }
+    }
+    stringToType(str) {
+        // Array types are tables
+        if (str.endsWith('[]'))
+            return 'table';
+        // Remove array notation for basic type check: string[] -> string
+        const baseStr = str.replace(/\[\]/g, '');
+        switch (baseStr) {
+            case 'string': return 'string';
+            case 'number': return 'number';
+            case 'boolean': return 'boolean';
+            case 'vector':
+            case 'vector2':
+            case 'vector3':
+            case 'vector4': return 'vector';
+            case 'table': return 'table';
+            case 'function': return 'function';
+            case 'any': return 'any';
+            default:
+                // Check if it's a registered interface
+                if (this.typeRegistry.has(baseStr)) {
+                    return 'table';
+                }
+                // Check if it's a type alias
+                if (this.typeAliasRegistry.has(baseStr)) {
+                    // If alias resolves to a primitive, return that. If object literal, return 'table'
+                    const aliased = this.typeAliasRegistry.get(baseStr);
+                    if (aliased.startsWith('{'))
+                        return 'table';
+                    return this.stringToType(aliased);
+                }
+                return 'any';
+        }
+    }
+    visitTypeAliasDecl(decl) {
+        this.typeAliasRegistry.set(decl.name.name, decl.type);
+        // If it's an object literal type, validate field types
+        if (decl.type.startsWith('{')) {
+            const fields = this.parseObjectLiteralType(decl.type);
+            for (const field of fields) {
+                this.validateTypeExists(field.type, decl.name.line ?? 0, `type '${decl.name.name}'`);
+            }
+        }
+        else {
+            // It's a simple alias, validate the aliased type exists
+            this.validateTypeExists(decl.type, decl.name.line ?? 0, `type '${decl.name.name}'`);
+        }
+    }
+    visitTypeDecl(decl) {
+        const typeName = decl.name.name;
+        // Register the type
+        this.typeRegistry.set(typeName, decl.fields);
+        // Validate that all field types exist
+        for (const field of decl.fields) {
+            this.validateTypeExists(field.type, decl.name.line ?? 0, `interface '${typeName}'`);
+        }
+    }
+    validateTypeExists(typeStr, line, context) {
+        // Remove array brackets for base type check
+        const baseType = typeStr.replace(/\[\]/g, '').trim();
+        // Skip object literal types (they are inline definitions)
+        if (baseType.startsWith('{'))
+            return;
+        // Check primitive types (including FiveM vector types)
+        const primitives = ['string', 'number', 'boolean', 'nil', 'any', 'table', 'function', 'vector', 'void', 'vector2', 'vector3', 'vector4'];
+        if (primitives.includes(baseType))
+            return;
+        // Check type registry (interfaces)
+        if (this.typeRegistry.has(baseType))
+            return;
+        // Check type alias registry
+        if (this.typeAliasRegistry.has(baseType))
+            return;
+        // Type not found!
+        throw new Error(`Unknown type '${baseType}' in ${context} at line ${line}`);
+    }
+    validateTableAgainstType(table, typeName, line) {
+        let fields;
+        // Remove array brackets if present (e.g. validating a single object against MyType[])
+        // This shouldn't happen often in this function call context but good for safety
+        typeName = typeName.replace(/\[\]/g, '');
+        // 1. Check Interface Registry
+        if (this.typeRegistry.has(typeName)) {
+            fields = this.typeRegistry.get(typeName);
+        }
+        // 2. Check Type Aliases (specifically object literal aliases)
+        else if (this.typeAliasRegistry.has(typeName)) {
+            const aliasStr = this.typeAliasRegistry.get(typeName);
+            if (aliasStr.startsWith('{')) {
+                fields = this.parseObjectLiteralType(aliasStr);
+            }
+        }
+        if (!fields)
+            return; // Unknown type, skip validation
+        const providedFields = new Map();
+        for (const field of table.fields) {
+            if (field.key && field.key.kind === AST.NodeType.Identifier) {
+                providedFields.set(field.key.name, field.value);
+            }
+            else if (field.key && field.key.kind === AST.NodeType.StringLiteral) {
+                providedFields.set(field.key.value, field.value);
+            }
+        }
+        // Check each expected field
+        for (const expected of fields) {
+            const provided = providedFields.get(expected.name);
+            if (!provided) {
+                throw new Error(`Type '${typeName}' requires field '${expected.name}' at line ${line}`);
+            }
+            const providedType = this.inferType(provided);
+            const expectedType = this.stringToType(expected.type);
+            if (expectedType !== 'any' && providedType !== 'any' && expectedType !== providedType) {
+                throw new Error(`Type mismatch: field '${expected.name}' should be '${expected.type}', got '${providedType}' at line ${line}`);
+            }
+        }
+    }
+    parseObjectLiteralType(typeStr) {
+        const content = typeStr.trim().slice(1, -1);
+        if (!content)
+            return [];
+        const fields = [];
+        const parts = content.split(/,|;/);
+        for (const part of parts) {
+            if (!part.trim())
+                continue;
+            const [key, val] = part.split(':').map(s => s.trim());
+            if (key && val) {
+                fields.push({ name: key.replace('?', ''), type: val });
+            }
+        }
+        return fields;
+    }
+}