redscript-mc 1.0.0

package/dist/typechecker/index.d.ts

@@ -0,0 +1,42 @@
+/**
+ * RedScript Type Checker
+ *
+ * Performs basic type checking between Parser and Lowering phases.
+ * Collects errors but doesn't block compilation (warn mode).
+ */
+import type { Program } from '../ast/types';
+import { DiagnosticError } from '../diagnostics';
+export declare class TypeChecker {
+    private collector;
+    private functions;
+    private structs;
+    private enums;
+    private consts;
+    private currentFn;
+    private currentReturnType;
+    private scope;
+    constructor(source?: string, filePath?: string);
+    private getNodeLocation;
+    private report;
+    /**
+     * Type check a program. Returns collected errors.
+     */
+    check(program: Program): DiagnosticError[];
+    private checkFunction;
+    private checkBlock;
+    private checkStmt;
+    private checkLetStmt;
+    private checkReturnStmt;
+    private checkExpr;
+    private checkCallExpr;
+    private checkInvokeExpr;
+    private checkFunctionCallArgs;
+    private checkTpCall;
+    private checkMemberExpr;
+    private checkLambdaExpr;
+    private inferType;
+    private inferLambdaType;
+    private typesMatch;
+    private typeToString;
+    private normalizeType;
+}

package/dist/typechecker/index.js

@@ -0,0 +1,629 @@
+"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");
+// ---------------------------------------------------------------------------
+// Type Checker
+// ---------------------------------------------------------------------------
+class TypeChecker {
+    constructor(source, filePath) {
+        this.functions = new Map();
+        this.structs = new Map();
+        this.enums = new Map();
+        this.consts = new Map();
+        this.currentFn = null;
+        this.currentReturnType = null;
+        this.scope = new Map();
+        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 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);
+        }
+        return this.collector.getErrors();
+    }
+    checkFunction(fn) {
+        this.currentFn = fn;
+        this.currentReturnType = this.normalizeType(fn.returnType);
+        this.scope = new Map();
+        let seenDefault = false;
+        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;
+    }
+    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.checkBlock(stmt.then);
+                if (stmt.else_)
+                    this.checkBlock(stmt.else_);
+                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') {
+                    this.scope.set(stmt.binding, { type: { kind: 'named', name: 'void' }, mutable: true }); // Entity marker
+                }
+                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':
+            case 'at_block':
+                this.checkBlock(stmt.body);
+                break;
+            case 'as_at':
+                this.checkBlock(stmt.body);
+                break;
+            case 'execute':
+                this.checkBlock(stmt.body);
+                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 'binary':
+                this.checkExpr(expr.left);
+                this.checkExpr(expr.right);
+                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 'array_lit':
+                for (const elem of expr.elements) {
+                    this.checkExpr(elem);
+                }
+                break;
+            case 'lambda':
+                this.checkLambdaExpr(expr, expectedType);
+                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':
+            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);
+        }
+        // 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;
+        }
+        for (const arg of expr.args) {
+            this.checkExpr(arg);
+        }
+        // Built-in functions are not checked for arg count
+    }
+    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);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    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;
+    }
+    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 'blockpos':
+                return { kind: 'named', name: 'BlockPos' };
+            case 'ident':
+                return this.scope.get(expr.name)?.type ?? { kind: 'named', name: 'void' };
+            case 'call': {
+                if (expr.fn === '__array_push') {
+                    return { kind: 'named', name: 'void' };
+                }
+                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 { kind: 'named', name: 'int' };
+                }
+                if (expr.fn === 'bossbar_get_value') {
+                    return { kind: 'named', name: 'int' };
+                }
+                if (expr.fn === 'random_sequence') {
+                    return { kind: 'named', name: 'void' };
+                }
+                const varType = this.scope.get(expr.fn)?.type;
+                if (varType?.kind === 'function_type') {
+                    return varType.return;
+                }
+                const fn = this.functions.get(expr.fn);
+                return fn?.returnType ?? { kind: 'named', name: 'int' };
+            }
+            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 '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 '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 };
+    }
+    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);
+        }
+        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)}`;
+        }
+    }
+    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 };
+        }
+        return type;
+    }
+}
+exports.TypeChecker = TypeChecker;
+//# sourceMappingURL=index.js.map