redscript-mc 1.1.0 → 1.2.1

package/dist/typechecker/index.js

@@ -8,18 +8,99 @@
 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',
+    'Pig': 'PassiveMob',
+    'Cow': 'PassiveMob',
+    'Sheep': 'PassiveMob',
+    'Chicken': 'PassiveMob',
+    'Villager': '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',
+    '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',
+    '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) {
@@ -41,6 +122,26 @@ class TypeChecker {
         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) {
@@ -67,6 +168,11 @@ class TypeChecker {
         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) {
@@ -74,6 +180,7 @@ class TypeChecker {
         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 });
         }
@@ -98,6 +205,37 @@ class TypeChecker {
         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);
@@ -113,9 +251,7 @@ class TypeChecker {
                 break;
             case 'if':
                 this.checkExpr(stmt.cond);
-                this.checkBlock(stmt.then);
-                if (stmt.else_)
-                    this.checkBlock(stmt.else_);
+                this.checkIfBranches(stmt);
                 break;
             case 'while':
                 this.checkExpr(stmt.cond);
@@ -131,7 +267,16 @@ class TypeChecker {
             case 'foreach':
                 this.checkExpr(stmt.iterable);
                 if (stmt.iterable.kind === 'selector') {
-                    this.scope.set(stmt.binding, { type: { kind: 'named', name: 'void' }, mutable: true }); // Entity marker
+                    // 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);
@@ -141,8 +286,8 @@ class TypeChecker {
                     else {
                         this.scope.set(stmt.binding, { type: { kind: 'named', name: 'void' }, mutable: true });
                     }
+                    this.checkBlock(stmt.body);
                 }
-                this.checkBlock(stmt.body);
                 break;
             case 'match':
                 this.checkExpr(stmt.expr);
@@ -156,15 +301,41 @@ class TypeChecker {
                     this.checkBlock(arm.body);
                 }
                 break;
-            case 'as_block':
+            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':
+            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);
@@ -224,10 +395,21 @@ class TypeChecker {
             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;
@@ -264,6 +446,18 @@ class TypeChecker {
                     }
                 }
                 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);
@@ -274,11 +468,6 @@ class TypeChecker {
                 break;
             case 'blockpos':
                 break;
-            case 'static_call':
-                for (const arg of expr.args) {
-                    this.checkExpr(arg);
-                }
-                break;
             // Literals don't need checking
             case 'int_lit':
             case 'float_lit':
@@ -298,6 +487,16 @@ class TypeChecker {
         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) {
@@ -325,11 +524,30 @@ class TypeChecker {
             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);
@@ -412,6 +630,21 @@ class TypeChecker {
             }
         }
     }
+    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;
@@ -447,6 +680,37 @@ class TypeChecker {
         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':
@@ -473,13 +737,24 @@ class TypeChecker {
                     }
                 }
                 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 { kind: 'named', name: 'void' };
+                    return VOID_TYPE;
                 }
                 if (expr.fn === '__array_pop') {
                     const target = expr.args[0];
@@ -488,20 +763,28 @@ class TypeChecker {
                         if (targetType?.kind === 'array')
                             return targetType.elem;
                     }
-                    return { kind: 'named', name: 'int' };
+                    return INT_TYPE;
                 }
                 if (expr.fn === 'bossbar_get_value') {
-                    return { kind: 'named', name: 'int' };
+                    return INT_TYPE;
                 }
                 if (expr.fn === 'random_sequence') {
-                    return { kind: 'named', name: 'void' };
+                    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 ?? { kind: 'named', name: 'int' };
+                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);
@@ -532,6 +815,8 @@ class TypeChecker {
                     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' };
@@ -541,6 +826,14 @@ class TypeChecker {
                     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)
@@ -569,6 +862,68 @@ class TypeChecker {
         }
         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;
@@ -592,6 +947,14 @@ class TypeChecker {
                 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) {
@@ -606,6 +969,12 @@ class TypeChecker {
                 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) {
@@ -622,6 +991,12 @@ class TypeChecker {
         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;
     }
 }