redscript-mc 2.3.0 → 2.4.1

package/dist/typechecker/index.js

@@ -0,0 +1,1034 @@
+"use strict";
+/**
+ * RedScript Type Checker
+ *
+ * Performs basic type checking between Parser and Lowering phases.
+ * Collects errors but doesn't block compilation (warn mode).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeChecker = void 0;
+const diagnostics_1 = require("../diagnostics");
+const types_1 = require("../events/types");
+// Entity type hierarchy for subtype checking
+const ENTITY_HIERARCHY = {
+    'entity': null,
+    'Player': 'entity',
+    'Mob': 'entity',
+    'HostileMob': 'Mob',
+    'PassiveMob': 'Mob',
+    'Zombie': 'HostileMob',
+    'Skeleton': 'HostileMob',
+    'Creeper': 'HostileMob',
+    'Spider': 'HostileMob',
+    'Enderman': 'HostileMob',
+    'Blaze': 'HostileMob',
+    'Witch': 'HostileMob',
+    'Slime': 'HostileMob',
+    'ZombieVillager': 'HostileMob',
+    'Husk': 'HostileMob',
+    'Drowned': 'HostileMob',
+    'Stray': 'HostileMob',
+    'WitherSkeleton': 'HostileMob',
+    'CaveSpider': 'HostileMob',
+    'Pig': 'PassiveMob',
+    'Cow': 'PassiveMob',
+    'Sheep': 'PassiveMob',
+    'Chicken': 'PassiveMob',
+    'Villager': 'PassiveMob',
+    'WanderingTrader': 'PassiveMob',
+    'ArmorStand': 'entity',
+    'Item': 'entity',
+    'Arrow': 'entity',
+};
+// Map Minecraft type names to entity types
+const MC_TYPE_TO_ENTITY = {
+    'zombie': 'Zombie',
+    'minecraft:zombie': 'Zombie',
+    'skeleton': 'Skeleton',
+    'minecraft:skeleton': 'Skeleton',
+    'creeper': 'Creeper',
+    'minecraft:creeper': 'Creeper',
+    'spider': 'Spider',
+    'minecraft:spider': 'Spider',
+    'enderman': 'Enderman',
+    'minecraft:enderman': 'Enderman',
+    'blaze': 'Blaze',
+    'minecraft:blaze': 'Blaze',
+    'witch': 'Witch',
+    'minecraft:witch': 'Witch',
+    'slime': 'Slime',
+    'minecraft:slime': 'Slime',
+    'zombie_villager': 'ZombieVillager',
+    'minecraft:zombie_villager': 'ZombieVillager',
+    'husk': 'Husk',
+    'minecraft:husk': 'Husk',
+    'drowned': 'Drowned',
+    'minecraft:drowned': 'Drowned',
+    'stray': 'Stray',
+    'minecraft:stray': 'Stray',
+    'wither_skeleton': 'WitherSkeleton',
+    'minecraft:wither_skeleton': 'WitherSkeleton',
+    'cave_spider': 'CaveSpider',
+    'minecraft:cave_spider': 'CaveSpider',
+    'pig': 'Pig',
+    'minecraft:pig': 'Pig',
+    'cow': 'Cow',
+    'minecraft:cow': 'Cow',
+    'sheep': 'Sheep',
+    'minecraft:sheep': 'Sheep',
+    'chicken': 'Chicken',
+    'minecraft:chicken': 'Chicken',
+    'villager': 'Villager',
+    'minecraft:villager': 'Villager',
+    'wandering_trader': 'WanderingTrader',
+    'minecraft:wandering_trader': 'WanderingTrader',
+    'armor_stand': 'ArmorStand',
+    'minecraft:armor_stand': 'ArmorStand',
+    'item': 'Item',
+    'minecraft:item': 'Item',
+    'arrow': 'Arrow',
+    'minecraft:arrow': 'Arrow',
+};
+const VOID_TYPE = { kind: 'named', name: 'void' };
+const INT_TYPE = { kind: 'named', name: 'int' };
+const STRING_TYPE = { kind: 'named', name: 'string' };
+const FORMAT_STRING_TYPE = { kind: 'named', name: 'format_string' };
+const BUILTIN_SIGNATURES = {
+    setTimeout: {
+        params: [INT_TYPE, { kind: 'function_type', params: [], return: VOID_TYPE }],
+        return: VOID_TYPE,
+    },
+    setInterval: {
+        params: [INT_TYPE, { kind: 'function_type', params: [], return: VOID_TYPE }],
+        return: INT_TYPE,
+    },
+    clearInterval: {
+        params: [INT_TYPE],
+        return: VOID_TYPE,
+    },
+};
+// ---------------------------------------------------------------------------
+// Type Checker
+// ---------------------------------------------------------------------------
+class TypeChecker {
+    constructor(source, filePath) {
+        this.functions = new Map();
+        this.implMethods = new Map();
+        this.structs = new Map();
+        this.enums = new Map();
+        this.consts = new Map();
+        this.currentFn = null;
+        this.currentReturnType = null;
+        this.scope = new Map();
+        // Stack for tracking @s type in different contexts
+        this.selfTypeStack = ['entity'];
+        this.richTextBuiltins = new Map([
+            ['say', { messageIndex: 0 }],
+            ['announce', { messageIndex: 0 }],
+            ['tell', { messageIndex: 1 }],
+            ['tellraw', { messageIndex: 1 }],
+            ['title', { messageIndex: 1 }],
+            ['actionbar', { messageIndex: 1 }],
+            ['subtitle', { messageIndex: 1 }],
+        ]);
+        this.collector = new diagnostics_1.DiagnosticCollector(source, filePath);
+    }
+    getNodeLocation(node) {
+        const span = node?.span;
+        return {
+            line: span?.line ?? 1,
+            col: span?.col ?? 1,
+        };
+    }
+    report(message, node) {
+        const { line, col } = this.getNodeLocation(node);
+        this.collector.error('TypeError', message, line, col);
+    }
+    /**
+     * Type check a program. Returns collected errors.
+     */
+    check(program) {
+        // First pass: collect function and struct declarations
+        for (const fn of program.declarations) {
+            this.functions.set(fn.name, fn);
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            let methods = this.implMethods.get(implBlock.typeName);
+            if (!methods) {
+                methods = new Map();
+                this.implMethods.set(implBlock.typeName, methods);
+            }
+            for (const method of implBlock.methods) {
+                const selfIndex = method.params.findIndex(param => param.name === 'self');
+                if (selfIndex > 0) {
+                    this.report(`Method '${method.name}' must declare 'self' as the first parameter`, method.params[selfIndex]);
+                }
+                if (selfIndex === 0) {
+                    const selfType = this.normalizeType(method.params[0].type);
+                    if (selfType.kind !== 'struct' || selfType.name !== implBlock.typeName) {
+                        this.report(`Method '${method.name}' has invalid 'self' type`, method.params[0]);
+                    }
+                }
+                methods.set(method.name, method);
+            }
+        }
+        for (const struct of program.structs ?? []) {
+            const fields = new Map();
+            for (const field of struct.fields) {
+                fields.set(field.name, field.type);
+            }
+            this.structs.set(struct.name, fields);
+        }
+        for (const enumDecl of program.enums ?? []) {
+            const variants = new Map();
+            for (const variant of enumDecl.variants) {
+                variants.set(variant.name, variant.value ?? 0);
+            }
+            this.enums.set(enumDecl.name, variants);
+        }
+        for (const constDecl of program.consts ?? []) {
+            const constType = this.normalizeType(constDecl.type);
+            const actualType = this.inferType(constDecl.value);
+            if (!this.typesMatch(constType, actualType)) {
+                this.report(`Type mismatch: expected ${this.typeToString(constType)}, got ${this.typeToString(actualType)}`, constDecl.value);
+            }
+            this.consts.set(constDecl.name, constType);
+        }
+        // Second pass: type check function bodies
+        for (const fn of program.declarations) {
+            this.checkFunction(fn);
+        }
+        for (const implBlock of program.implBlocks ?? []) {
+            for (const method of implBlock.methods) {
+                this.checkFunction(method);
+            }
+        }
+        return this.collector.getErrors();
+    }
+    checkFunction(fn) {
+        this.currentFn = fn;
+        this.currentReturnType = this.normalizeType(fn.returnType);
+        this.scope = new Map();
+        let seenDefault = false;
+        this.checkFunctionDecorators(fn);
+        for (const [name, type] of this.consts.entries()) {
+            this.scope.set(name, { type, mutable: false });
+        }
+        // Add parameters to scope
+        for (const param of fn.params) {
+            this.scope.set(param.name, { type: this.normalizeType(param.type), mutable: true });
+            if (param.default) {
+                seenDefault = true;
+                this.checkExpr(param.default);
+                const defaultType = this.inferType(param.default);
+                const paramType = this.normalizeType(param.type);
+                if (!this.typesMatch(paramType, defaultType)) {
+                    this.report(`Default value for '${param.name}' must be ${this.typeToString(paramType)}, got ${this.typeToString(defaultType)}`, param.default);
+                }
+            }
+            else if (seenDefault) {
+                this.report(`Parameter '${param.name}' cannot follow a default parameter`, param);
+            }
+        }
+        // Check body
+        this.checkBlock(fn.body);
+        this.currentFn = null;
+        this.currentReturnType = null;
+    }
+    checkFunctionDecorators(fn) {
+        const eventDecorators = fn.decorators.filter(decorator => decorator.name === 'on');
+        if (eventDecorators.length === 0) {
+            return;
+        }
+        if (eventDecorators.length > 1) {
+            this.report(`Function '${fn.name}' cannot have multiple @on decorators`, fn);
+            return;
+        }
+        const eventType = eventDecorators[0].args?.eventType;
+        if (!eventType) {
+            this.report(`Function '${fn.name}' is missing an event type in @on(...)`, fn);
+            return;
+        }
+        if (!(0, types_1.isEventTypeName)(eventType)) {
+            this.report(`Unknown event type '${eventType}'`, fn);
+            return;
+        }
+        const expectedParams = (0, types_1.getEventParamSpecs)(eventType);
+        if (fn.params.length !== expectedParams.length) {
+            this.report(`Event handler '${fn.name}' for ${eventType} must declare ${expectedParams.length} parameter(s), got ${fn.params.length}`, fn);
+            return;
+        }
+        for (let i = 0; i < expectedParams.length; i++) {
+            const actual = this.normalizeType(fn.params[i].type);
+            const expected = this.normalizeType(expectedParams[i].type);
+            if (!this.typesMatch(expected, actual)) {
+                this.report(`Event handler '${fn.name}' parameter ${i + 1} must be ${this.typeToString(expected)}, got ${this.typeToString(actual)}`, fn.params[i]);
+            }
+        }
+    }
+    checkBlock(stmts) {
+        for (const stmt of stmts) {
+            this.checkStmt(stmt);
+        }
+    }
+    checkStmt(stmt) {
+        switch (stmt.kind) {
+            case 'let':
+                this.checkLetStmt(stmt);
+                break;
+            case 'return':
+                this.checkReturnStmt(stmt);
+                break;
+            case 'if':
+                this.checkExpr(stmt.cond);
+                this.checkIfBranches(stmt);
+                break;
+            case 'while':
+                this.checkExpr(stmt.cond);
+                this.checkBlock(stmt.body);
+                break;
+            case 'for':
+                if (stmt.init)
+                    this.checkStmt(stmt.init);
+                this.checkExpr(stmt.cond);
+                this.checkExpr(stmt.step);
+                this.checkBlock(stmt.body);
+                break;
+            case 'foreach':
+                this.checkExpr(stmt.iterable);
+                if (stmt.iterable.kind === 'selector') {
+                    // Infer entity type from selector (access .sel for the EntitySelector)
+                    const entityType = this.inferEntityTypeFromSelector(stmt.iterable.sel);
+                    this.scope.set(stmt.binding, {
+                        type: { kind: 'entity', entityType },
+                        mutable: false // Entity bindings are not reassignable
+                    });
+                    // Push self type context for @s inside the loop
+                    this.pushSelfType(entityType);
+                    this.checkBlock(stmt.body);
+                    this.popSelfType();
+                }
+                else {
+                    const iterableType = this.inferType(stmt.iterable);
+                    if (iterableType.kind === 'array') {
+                        this.scope.set(stmt.binding, { type: iterableType.elem, mutable: true });
+                    }
+                    else {
+                        this.scope.set(stmt.binding, { type: { kind: 'named', name: 'void' }, mutable: true });
+                    }
+                    this.checkBlock(stmt.body);
+                }
+                break;
+            case 'match':
+                this.checkExpr(stmt.expr);
+                for (const arm of stmt.arms) {
+                    if (arm.pattern) {
+                        this.checkExpr(arm.pattern);
+                        if (!this.typesMatch(this.inferType(stmt.expr), this.inferType(arm.pattern))) {
+                            this.report('Match arm pattern type must match subject type', arm.pattern);
+                        }
+                    }
+                    this.checkBlock(arm.body);
+                }
+                break;
+            case 'as_block': {
+                // as block changes @s to the selector's entity type
+                const entityType = this.inferEntityTypeFromSelector(stmt.selector);
+                this.pushSelfType(entityType);
+                this.checkBlock(stmt.body);
+                this.popSelfType();
+                break;
+            }
+            case 'at_block':
+                // at block doesn't change @s type, only position
+                this.checkBlock(stmt.body);
+                break;
+            case 'as_at': {
+                // as @x at @y - @s becomes the as selector's type
+                const entityType = this.inferEntityTypeFromSelector(stmt.as_sel);
+                this.pushSelfType(entityType);
+                this.checkBlock(stmt.body);
+                this.popSelfType();
+                break;
+            }
+            case 'execute':
+                // execute with subcommands - check for 'as' subcommands
+                for (const sub of stmt.subcommands) {
+                    if (sub.kind === 'as' && sub.selector) {
+                        const entityType = this.inferEntityTypeFromSelector(sub.selector);
+                        this.pushSelfType(entityType);
+                    }
+                }
+                this.checkBlock(stmt.body);
+                // Pop for each 'as' subcommand
+                for (const sub of stmt.subcommands) {
+                    if (sub.kind === 'as') {
+                        this.popSelfType();
+                    }
+                }
+                break;
+            case 'expr':
+                this.checkExpr(stmt.expr);
+                break;
+            case 'raw':
+                // Raw commands are not type checked
+                break;
+        }
+    }
+    checkLetStmt(stmt) {
+        // Check initializer
+        const expectedType = stmt.type ? this.normalizeType(stmt.type) : undefined;
+        this.checkExpr(stmt.init, expectedType);
+        // Add variable to scope
+        const type = expectedType ?? this.inferType(stmt.init);
+        this.scope.set(stmt.name, { type, mutable: true });
+        const actualType = this.inferType(stmt.init, expectedType);
+        if (expectedType &&
+            stmt.init.kind !== 'struct_lit' &&
+            stmt.init.kind !== 'array_lit' &&
+            !(actualType.kind === 'named' && actualType.name === 'void') &&
+            !this.typesMatch(expectedType, actualType)) {
+            this.report(`Type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`, stmt);
+        }
+    }
+    checkReturnStmt(stmt) {
+        if (!this.currentReturnType)
+            return;
+        const expectedType = this.currentReturnType;
+        if (stmt.value) {
+            const actualType = this.inferType(stmt.value, expectedType);
+            this.checkExpr(stmt.value, expectedType);
+            if (!this.typesMatch(expectedType, actualType)) {
+                this.report(`Return type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`, stmt);
+            }
+        }
+        else {
+            // No return value
+            if (expectedType.kind !== 'named' || expectedType.name !== 'void') {
+                this.report(`Missing return value: expected ${this.typeToString(expectedType)}`, stmt);
+            }
+        }
+    }
+    checkExpr(expr, expectedType) {
+        switch (expr.kind) {
+            case 'ident':
+                if (!this.scope.has(expr.name)) {
+                    this.report(`Variable '${expr.name}' used before declaration`, expr);
+                }
+                break;
+            case 'call':
+                this.checkCallExpr(expr);
+                break;
+            case 'invoke':
+                this.checkInvokeExpr(expr);
+                break;
+            case 'member':
+                this.checkMemberExpr(expr);
+                break;
+            case 'static_call':
+                this.checkStaticCallExpr(expr);
+                break;
+            case 'binary':
+                this.checkExpr(expr.left);
+                this.checkExpr(expr.right);
+                break;
+            case 'is_check': {
+                this.checkExpr(expr.expr);
+                const checkedType = this.inferType(expr.expr);
+                if (checkedType.kind !== 'entity') {
+                    this.report(`'is' checks require an entity expression, got ${this.typeToString(checkedType)}`, expr.expr);
+                }
+                break;
+            }
+            case 'unary':
+                this.checkExpr(expr.operand);
+                break;
+            case 'assign':
+                if (!this.scope.has(expr.target)) {
+                    this.report(`Variable '${expr.target}' used before declaration`, expr);
+                }
+                else if (!this.scope.get(expr.target)?.mutable) {
+                    this.report(`Cannot assign to const '${expr.target}'`, expr);
+                }
+                this.checkExpr(expr.value, this.scope.get(expr.target)?.type);
+                break;
+            case 'member_assign':
+                this.checkExpr(expr.obj);
+                this.checkExpr(expr.value);
+                break;
+            case 'index':
+                this.checkExpr(expr.obj);
+                this.checkExpr(expr.index);
+                const indexType = this.inferType(expr.index);
+                if (indexType.kind !== 'named' || indexType.name !== 'int') {
+                    this.report('Array index must be int', expr.index);
+                }
+                break;
+            case 'struct_lit':
+                for (const field of expr.fields) {
+                    this.checkExpr(field.value);
+                }
+                break;
+            case 'str_interp':
+                for (const part of expr.parts) {
+                    if (typeof part !== 'string') {
+                        this.checkExpr(part);
+                    }
+                }
+                break;
+            case 'f_string':
+                for (const part of expr.parts) {
+                    if (part.kind !== 'expr') {
+                        continue;
+                    }
+                    this.checkExpr(part.expr);
+                    const partType = this.inferType(part.expr);
+                    if (!(partType.kind === 'named' && (partType.name === 'int' || partType.name === 'string' || partType.name === 'format_string'))) {
+                        this.report(`f-string placeholder must be int or string, got ${this.typeToString(partType)}`, part.expr);
+                    }
+                }
+                break;
+            case 'array_lit':
+                for (const elem of expr.elements) {
+                    this.checkExpr(elem);
+                }
+                break;
+            case 'lambda':
+                this.checkLambdaExpr(expr, expectedType);
+                break;
+            case 'blockpos':
+                break;
+            // Literals don't need checking
+            case 'int_lit':
+            case 'float_lit':
+            case 'bool_lit':
+            case 'str_lit':
+            case 'mc_name':
+            case 'range_lit':
+            case 'selector':
+            case 'byte_lit':
+            case 'short_lit':
+            case 'long_lit':
+            case 'double_lit':
+                break;
+        }
+    }
+    checkCallExpr(expr) {
+        if (expr.fn === 'tp' || expr.fn === 'tp_to') {
+            this.checkTpCall(expr);
+        }
+        const richTextBuiltin = this.richTextBuiltins.get(expr.fn);
+        if (richTextBuiltin) {
+            this.checkRichTextBuiltinCall(expr, richTextBuiltin.messageIndex);
+            return;
+        }
+        const builtin = BUILTIN_SIGNATURES[expr.fn];
+        if (builtin) {
+            this.checkFunctionCallArgs(expr.args, builtin.params, expr.fn, expr);
+            return;
+        }
+        // Check if function exists and arg count matches
+        const fn = this.functions.get(expr.fn);
+        if (fn) {
+            const requiredParams = fn.params.filter(param => !param.default).length;
+            if (expr.args.length < requiredParams || expr.args.length > fn.params.length) {
+                const expectedRange = requiredParams === fn.params.length
+                    ? `${fn.params.length}`
+                    : `${requiredParams}-${fn.params.length}`;
+                this.report(`Function '${expr.fn}' expects ${expectedRange} arguments, got ${expr.args.length}`, expr);
+            }
+            for (let i = 0; i < expr.args.length; i++) {
+                const paramType = fn.params[i] ? this.normalizeType(fn.params[i].type) : undefined;
+                if (paramType) {
+                    this.checkExpr(expr.args[i], paramType);
+                }
+                const argType = this.inferType(expr.args[i], paramType);
+                if (paramType && !this.typesMatch(paramType, argType)) {
+                    this.report(`Argument ${i + 1} of '${expr.fn}' expects ${this.typeToString(paramType)}, got ${this.typeToString(argType)}`, expr.args[i]);
+                }
+            }
+            return;
+        }
+        const varType = this.scope.get(expr.fn)?.type;
+        if (varType?.kind === 'function_type') {
+            this.checkFunctionCallArgs(expr.args, varType.params, expr.fn, expr);
+            return;
+        }
+        const implMethod = this.resolveInstanceMethod(expr);
+        if (implMethod) {
+            this.checkFunctionCallArgs(expr.args, implMethod.params.map(param => this.normalizeType(param.type)), implMethod.name, expr);
+            return;
+        }
+        for (const arg of expr.args) {
+            this.checkExpr(arg);
+        }
+        // Built-in functions are not checked for arg count
+    }
+    checkRichTextBuiltinCall(expr, messageIndex) {
+        for (let i = 0; i < expr.args.length; i++) {
+            this.checkExpr(expr.args[i], i === messageIndex ? undefined : STRING_TYPE);
+        }
+        const message = expr.args[messageIndex];
+        if (!message) {
+            return;
+        }
+        const messageType = this.inferType(message);
+        if (messageType.kind !== 'named' ||
+            (messageType.name !== 'string' && messageType.name !== 'format_string')) {
+            this.report(`Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`, message);
+        }
+    }
+    checkInvokeExpr(expr) {
+        this.checkExpr(expr.callee);
+        const calleeType = this.inferType(expr.callee);
+        if (calleeType.kind !== 'function_type') {
+            this.report('Attempted to call a non-function value', expr.callee);
+            for (const arg of expr.args) {
+                this.checkExpr(arg);
+            }
+            return;
+        }
+        this.checkFunctionCallArgs(expr.args, calleeType.params, 'lambda', expr);
+    }
+    checkFunctionCallArgs(args, params, calleeName, node) {
+        if (args.length !== params.length) {
+            this.report(`Function '${calleeName}' expects ${params.length} arguments, got ${args.length}`, node);
+        }
+        for (let i = 0; i < args.length; i++) {
+            const paramType = params[i];
+            if (!paramType) {
+                this.checkExpr(args[i]);
+                continue;
+            }
+            this.checkExpr(args[i], paramType);
+            const argType = this.inferType(args[i], paramType);
+            if (!this.typesMatch(paramType, argType)) {
+                this.report(`Argument ${i + 1} of '${calleeName}' expects ${this.typeToString(paramType)}, got ${this.typeToString(argType)}`, args[i]);
+            }
+        }
+    }
+    checkTpCall(expr) {
+        const dest = expr.args[1];
+        if (!dest) {
+            return;
+        }
+        const destType = this.inferType(dest);
+        if (destType.kind === 'named' && destType.name === 'BlockPos') {
+            return;
+        }
+        if (dest.kind === 'selector' && !dest.isSingle) {
+            this.report('tp destination must be a single-entity selector (@s, @p, @r, or limit=1)', dest);
+        }
+    }
+    checkMemberExpr(expr) {
+        if (!(expr.obj.kind === 'ident' && this.enums.has(expr.obj.name))) {
+            this.checkExpr(expr.obj);
+        }
+        // Check if accessing member on appropriate type
+        if (expr.obj.kind === 'ident') {
+            if (this.enums.has(expr.obj.name)) {
+                const enumVariants = this.enums.get(expr.obj.name);
+                if (!enumVariants.has(expr.field)) {
+                    this.report(`Enum '${expr.obj.name}' has no variant '${expr.field}'`, expr);
+                }
+                return;
+            }
+            const varSymbol = this.scope.get(expr.obj.name);
+            const varType = varSymbol?.type;
+            if (varType) {
+                // Allow member access on struct types
+                if (varType.kind === 'struct') {
+                    const structFields = this.structs.get(varType.name);
+                    if (structFields && !structFields.has(expr.field)) {
+                        this.report(`Struct '${varType.name}' has no field '${expr.field}'`, expr);
+                    }
+                }
+                else if (varType.kind === 'array') {
+                    if (expr.field !== 'len' && expr.field !== 'push' && expr.field !== 'pop') {
+                        this.report(`Array has no field '${expr.field}'`, expr);
+                    }
+                }
+                else if (varType.kind === 'named') {
+                    // Entity marker (void) - allow all members
+                    if (varType.name !== 'void') {
+                        // Only warn for primitive types
+                        if (['int', 'bool', 'float', 'string', 'byte', 'short', 'long', 'double'].includes(varType.name)) {
+                            this.report(`Cannot access member '${expr.field}' on ${this.typeToString(varType)}`, expr);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    checkStaticCallExpr(expr) {
+        const method = this.implMethods.get(expr.type)?.get(expr.method);
+        if (!method) {
+            this.report(`Type '${expr.type}' has no static method '${expr.method}'`, expr);
+            for (const arg of expr.args) {
+                this.checkExpr(arg);
+            }
+            return;
+        }
+        if (method.params[0]?.name === 'self') {
+            this.report(`Method '${expr.type}::${expr.method}' is an instance method`, expr);
+            return;
+        }
+        this.checkFunctionCallArgs(expr.args, method.params.map(param => this.normalizeType(param.type)), `${expr.type}::${expr.method}`, expr);
+    }
+    checkLambdaExpr(expr, expectedType) {
+        const normalizedExpected = expectedType ? this.normalizeType(expectedType) : undefined;
+        const expectedFnType = normalizedExpected?.kind === 'function_type' ? normalizedExpected : undefined;
+        const lambdaType = this.inferLambdaType(expr, expectedFnType);
+        if (expectedFnType && !this.typesMatch(expectedFnType, lambdaType)) {
+            this.report(`Type mismatch: expected ${this.typeToString(expectedFnType)}, got ${this.typeToString(lambdaType)}`, expr);
+            return;
+        }
+        const outerScope = this.scope;
+        const outerReturnType = this.currentReturnType;
+        const lambdaScope = new Map(this.scope);
+        const paramTypes = expectedFnType?.params ?? lambdaType.params;
+        for (let i = 0; i < expr.params.length; i++) {
+            lambdaScope.set(expr.params[i].name, {
+                type: paramTypes[i] ?? { kind: 'named', name: 'void' },
+                mutable: true,
+            });
+        }
+        this.scope = lambdaScope;
+        this.currentReturnType = expr.returnType
+            ? this.normalizeType(expr.returnType)
+            : (expectedFnType?.return ?? lambdaType.return);
+        if (Array.isArray(expr.body)) {
+            this.checkBlock(expr.body);
+        }
+        else {
+            this.checkExpr(expr.body, this.currentReturnType);
+            const actualType = this.inferType(expr.body, this.currentReturnType);
+            if (!this.typesMatch(this.currentReturnType, actualType)) {
+                this.report(`Return type mismatch: expected ${this.typeToString(this.currentReturnType)}, got ${this.typeToString(actualType)}`, expr.body);
+            }
+        }
+        this.scope = outerScope;
+        this.currentReturnType = outerReturnType;
+    }
+    checkIfBranches(stmt) {
+        const narrowed = this.getThenBranchNarrowing(stmt.cond);
+        if (narrowed) {
+            const thenScope = new Map(this.scope);
+            thenScope.set(narrowed.name, { type: narrowed.type, mutable: narrowed.mutable });
+            const outerScope = this.scope;
+            this.scope = thenScope;
+            this.checkBlock(stmt.then);
+            this.scope = outerScope;
+        }
+        else {
+            this.checkBlock(stmt.then);
+        }
+        if (stmt.else_) {
+            this.checkBlock(stmt.else_);
+        }
+    }
+    getThenBranchNarrowing(cond) {
+        if (cond.kind !== 'is_check' || cond.expr.kind !== 'ident') {
+            return null;
+        }
+        const symbol = this.scope.get(cond.expr.name);
+        if (!symbol || symbol.type.kind !== 'entity') {
+            return null;
+        }
+        return {
+            name: cond.expr.name,
+            type: { kind: 'entity', entityType: cond.entityType },
+            mutable: symbol.mutable,
+        };
+    }
+    inferType(expr, expectedType) {
+        switch (expr.kind) {
+            case 'int_lit':
+                return { kind: 'named', name: 'int' };
+            case 'float_lit':
+                return { kind: 'named', name: 'float' };
+            case 'byte_lit':
+                return { kind: 'named', name: 'byte' };
+            case 'short_lit':
+                return { kind: 'named', name: 'short' };
+            case 'long_lit':
+                return { kind: 'named', name: 'long' };
+            case 'double_lit':
+                return { kind: 'named', name: 'double' };
+            case 'bool_lit':
+                return { kind: 'named', name: 'bool' };
+            case 'str_lit':
+            case 'mc_name':
+                return { kind: 'named', name: 'string' };
+            case 'str_interp':
+                for (const part of expr.parts) {
+                    if (typeof part !== 'string') {
+                        this.checkExpr(part);
+                    }
+                }
+                return { kind: 'named', name: 'string' };
+            case 'f_string':
+                for (const part of expr.parts) {
+                    if (part.kind === 'expr') {
+                        this.checkExpr(part.expr);
+                    }
+                }
+                return FORMAT_STRING_TYPE;
+            case 'blockpos':
+                return { kind: 'named', name: 'BlockPos' };
+            case 'ident':
+                return this.scope.get(expr.name)?.type ?? { kind: 'named', name: 'void' };
+            case 'call': {
+                const builtin = BUILTIN_SIGNATURES[expr.fn];
+                if (builtin) {
+                    return builtin.return;
+                }
+                if (expr.fn === '__array_push') {
+                    return VOID_TYPE;
+                }
+                if (expr.fn === '__array_pop') {
+                    const target = expr.args[0];
+                    if (target && target.kind === 'ident') {
+                        const targetType = this.scope.get(target.name)?.type;
+                        if (targetType?.kind === 'array')
+                            return targetType.elem;
+                    }
+                    return INT_TYPE;
+                }
+                if (expr.fn === 'bossbar_get_value') {
+                    return INT_TYPE;
+                }
+                if (expr.fn === 'random_sequence') {
+                    return VOID_TYPE;
+                }
+                const varType = this.scope.get(expr.fn)?.type;
+                if (varType?.kind === 'function_type') {
+                    return varType.return;
+                }
+                const implMethod = this.resolveInstanceMethod(expr);
+                if (implMethod) {
+                    return this.normalizeType(implMethod.returnType);
+                }
+                const fn = this.functions.get(expr.fn);
+                return fn?.returnType ?? INT_TYPE;
+            }
+            case 'static_call': {
+                const method = this.implMethods.get(expr.type)?.get(expr.method);
+                return method ? this.normalizeType(method.returnType) : { kind: 'named', name: 'void' };
+            }
+            case 'invoke': {
+                const calleeType = this.inferType(expr.callee);
+                if (calleeType.kind === 'function_type') {
+                    return calleeType.return;
+                }
+                return { kind: 'named', name: 'void' };
+            }
+            case 'member':
+                if (expr.obj.kind === 'ident' && this.enums.has(expr.obj.name)) {
+                    return { kind: 'enum', name: expr.obj.name };
+                }
+                if (expr.obj.kind === 'ident') {
+                    const objTypeNode = this.scope.get(expr.obj.name)?.type;
+                    if (objTypeNode?.kind === 'array' && expr.field === 'len') {
+                        return { kind: 'named', name: 'int' };
+                    }
+                }
+                return { kind: 'named', name: 'void' };
+            case 'index': {
+                const objType = this.inferType(expr.obj);
+                if (objType.kind === 'array')
+                    return objType.elem;
+                return { kind: 'named', name: 'void' };
+            }
+            case 'binary':
+                if (['==', '!=', '<', '<=', '>', '>=', '&&', '||'].includes(expr.op)) {
+                    return { kind: 'named', name: 'bool' };
+                }
+                return this.inferType(expr.left);
+            case 'is_check':
+                return { kind: 'named', name: 'bool' };
+            case 'unary':
+                if (expr.op === '!')
+                    return { kind: 'named', name: 'bool' };
+                return this.inferType(expr.operand);
+            case 'array_lit':
+                if (expr.elements.length > 0) {
+                    return { kind: 'array', elem: this.inferType(expr.elements[0]) };
+                }
+                return { kind: 'array', elem: { kind: 'named', name: 'int' } };
+            case 'struct_lit':
+                if (expectedType) {
+                    const normalized = this.normalizeType(expectedType);
+                    if (normalized.kind === 'struct') {
+                        return normalized;
+                    }
+                }
+                return { kind: 'named', name: 'void' };
+            case 'lambda':
+                return this.inferLambdaType(expr, expectedType && this.normalizeType(expectedType).kind === 'function_type'
+                    ? this.normalizeType(expectedType)
+                    : undefined);
+            default:
+                return { kind: 'named', name: 'void' };
+        }
+    }
+    inferLambdaType(expr, expectedType) {
+        const params = expr.params.map((param, index) => {
+            if (param.type) {
+                return this.normalizeType(param.type);
+            }
+            const inferred = expectedType?.params[index];
+            if (inferred) {
+                return inferred;
+            }
+            this.report(`Lambda parameter '${param.name}' requires a type annotation`, expr);
+            return { kind: 'named', name: 'void' };
+        });
+        let returnType = expr.returnType
+            ? this.normalizeType(expr.returnType)
+            : expectedType?.return;
+        if (!returnType) {
+            returnType = Array.isArray(expr.body) ? { kind: 'named', name: 'void' } : this.inferType(expr.body);
+        }
+        return { kind: 'function_type', params, return: returnType };
+    }
+    // ---------------------------------------------------------------------------
+    // Entity Type Helpers
+    // ---------------------------------------------------------------------------
+    /** Infer entity type from a selector */
+    inferEntityTypeFromSelector(selector) {
+        // @a, @p, @r always return Player
+        if (selector.kind === '@a' || selector.kind === '@p' || selector.kind === '@r') {
+            return 'Player';
+        }
+        // @e or @s with type= filter
+        if (selector.filters?.type) {
+            const mcType = selector.filters.type.toLowerCase();
+            return MC_TYPE_TO_ENTITY[mcType] ?? 'entity';
+        }
+        // @s uses current context
+        if (selector.kind === '@s') {
+            return this.selfTypeStack[this.selfTypeStack.length - 1];
+        }
+        // Default to entity
+        return 'entity';
+    }
+    resolveInstanceMethod(expr) {
+        const receiver = expr.args[0];
+        if (!receiver) {
+            return null;
+        }
+        const receiverType = this.inferType(receiver);
+        if (receiverType.kind !== 'struct') {
+            return null;
+        }
+        const method = this.implMethods.get(receiverType.name)?.get(expr.fn);
+        if (!method || method.params[0]?.name !== 'self') {
+            return null;
+        }
+        return method;
+    }
+    /** Check if childType is a subtype of parentType */
+    isEntitySubtype(childType, parentType) {
+        if (childType === parentType)
+            return true;
+        let current = childType;
+        while (current !== null) {
+            if (current === parentType)
+                return true;
+            current = ENTITY_HIERARCHY[current];
+        }
+        return false;
+    }
+    /** Push a new self type context */
+    pushSelfType(entityType) {
+        this.selfTypeStack.push(entityType);
+    }
+    /** Pop self type context */
+    popSelfType() {
+        if (this.selfTypeStack.length > 1) {
+            this.selfTypeStack.pop();
+        }
+    }
+    /** Get current @s type */
+    getCurrentSelfType() {
+        return this.selfTypeStack[this.selfTypeStack.length - 1];
+    }
+    typesMatch(expected, actual) {
+        if (expected.kind !== actual.kind)
+            return false;
+        if (expected.kind === 'named' && actual.kind === 'named') {
+            // void matches anything (for inferred types)
+            if (actual.name === 'void')
+                return true;
+            return expected.name === actual.name;
+        }
+        if (expected.kind === 'array' && actual.kind === 'array') {
+            return this.typesMatch(expected.elem, actual.elem);
+        }
+        if (expected.kind === 'struct' && actual.kind === 'struct') {
+            return expected.name === actual.name;
+        }
+        if (expected.kind === 'enum' && actual.kind === 'enum') {
+            return expected.name === actual.name;
+        }
+        if (expected.kind === 'function_type' && actual.kind === 'function_type') {
+            return expected.params.length === actual.params.length &&
+                expected.params.every((param, index) => this.typesMatch(param, actual.params[index])) &&
+                this.typesMatch(expected.return, actual.return);
+        }
+        // Entity type matching with subtype support
+        if (expected.kind === 'entity' && actual.kind === 'entity') {
+            return this.isEntitySubtype(actual.entityType, expected.entityType);
+        }
+        // Selector matches any entity type
+        if (expected.kind === 'selector' && actual.kind === 'entity') {
+            return true;
+        }
+        return false;
+    }
+    typeToString(type) {
+        switch (type.kind) {
+            case 'named':
+                return type.name;
+            case 'array':
+                return `${this.typeToString(type.elem)}[]`;
+            case 'struct':
+                return type.name;
+            case 'enum':
+                return type.name;
+            case 'function_type':
+                return `(${type.params.map(param => this.typeToString(param)).join(', ')}) -> ${this.typeToString(type.return)}`;
+            case 'entity':
+                return type.entityType;
+            case 'selector':
+                return 'selector';
+            default:
+                return 'unknown';
+        }
+    }
+    normalizeType(type) {
+        if (type.kind === 'array') {
+            return { kind: 'array', elem: this.normalizeType(type.elem) };
+        }
+        if (type.kind === 'function_type') {
+            return {
+                kind: 'function_type',
+                params: type.params.map(param => this.normalizeType(param)),
+                return: this.normalizeType(type.return),
+            };
+        }
+        if ((type.kind === 'struct' || type.kind === 'enum') && this.enums.has(type.name)) {
+            return { kind: 'enum', name: type.name };
+        }
+        if (type.kind === 'struct' && type.name in ENTITY_HIERARCHY) {
+            return { kind: 'entity', entityType: type.name };
+        }
+        if (type.kind === 'named' && type.name in ENTITY_HIERARCHY) {
+            return { kind: 'entity', entityType: type.name };
+        }
+        return type;
+    }
+}
+exports.TypeChecker = TypeChecker;
+//# sourceMappingURL=index.js.map