redscript-mc 2.0.0 → 2.1.0

package/dist/src/typechecker/index.js

@@ -117,6 +117,7 @@ class TypeChecker {
         this.structs = new Map();
         this.enums = new Map();
         this.consts = new Map();
+        this.globals = new Map();
         this.currentFn = null;
         this.currentReturnType = null;
         this.scope = new Map();
@@ -152,6 +153,10 @@ class TypeChecker {
         for (const fn of program.declarations) {
             this.functions.set(fn.name, fn);
         }
+        // Register global variables (mutable) so functions can reference and assign them
+        for (const global of program.globals ?? []) {
+            this.globals.set(global.name, this.normalizeType(global.type));
+        }
         for (const implBlock of program.implBlocks ?? []) {
             let methods = this.implMethods.get(implBlock.typeName);
             if (!methods) {
@@ -206,6 +211,10 @@ class TypeChecker {
         return this.collector.getErrors();
     }
     checkFunction(fn) {
+        // Generic functions (with type params like <T>) are checked after monomorphization.
+        // Skip body checking here to avoid false errors for unresolved type params.
+        if (fn.typeParams && fn.typeParams.length > 0)
+            return;
         this.currentFn = fn;
         this.currentReturnType = this.normalizeType(fn.returnType);
         this.scope = new Map();
@@ -214,6 +223,9 @@ class TypeChecker {
         for (const [name, type] of this.consts.entries()) {
             this.scope.set(name, { type, mutable: false });
         }
+        for (const [name, type] of this.globals.entries()) {
+            this.scope.set(name, { type, mutable: true });
+        }
         // Add parameters to scope
         for (const param of fn.params) {
             this.scope.set(param.name, { type: this.normalizeType(param.type), mutable: true });
@@ -276,6 +288,9 @@ class TypeChecker {
             case 'let':
                 this.checkLetStmt(stmt);
                 break;
+            case 'let_destruct':
+                this.checkLetDestructStmt(stmt);
+                break;
             case 'return':
                 this.checkReturnStmt(stmt);
                 break;
@@ -324,7 +339,12 @@ class TypeChecker {
                 for (const arm of stmt.arms) {
                     if (arm.pattern) {
                         this.checkExpr(arm.pattern);
-                        if (!this.typesMatch(this.inferType(stmt.expr), this.inferType(arm.pattern))) {
+                        const subjectType = this.inferType(stmt.expr);
+                        const patternType = this.inferType(arm.pattern);
+                        // Skip check if either type is unknown (void) — struct field access not yet inferred
+                        const isUnknown = (t) => t.kind === 'named' && t.name === 'void';
+                        if (!isUnknown(subjectType) && !isUnknown(patternType) &&
+                            !this.typesMatch(subjectType, patternType)) {
                             this.report('Match arm pattern type must match subject type', arm.pattern);
                         }
                     }
@@ -375,6 +395,41 @@ class TypeChecker {
                 break;
         }
     }
+    checkLetDestructStmt(stmt) {
+        this.checkExpr(stmt.init);
+        const initType = this.inferType(stmt.init);
+        if (stmt.type) {
+            // Type annotation must be a tuple
+            const normalized = this.normalizeType(stmt.type);
+            if (normalized.kind !== 'tuple') {
+                this.report(`Destructuring type annotation must be a tuple type`, stmt);
+                return;
+            }
+            if (normalized.elements.length !== stmt.names.length) {
+                this.report(`Destructuring pattern has ${stmt.names.length} bindings but type has ${normalized.elements.length} elements`, stmt);
+            }
+            for (let i = 0; i < stmt.names.length; i++) {
+                const elemType = normalized.elements[i] ?? { kind: 'named', name: 'int' };
+                this.scope.set(stmt.names[i], { type: elemType, mutable: true });
+            }
+        }
+        else if (initType.kind === 'tuple') {
+            // Infer element types from tuple literal type
+            if (initType.elements.length !== stmt.names.length) {
+                this.report(`Destructuring pattern has ${stmt.names.length} bindings but tuple has ${initType.elements.length} elements`, stmt);
+            }
+            for (let i = 0; i < stmt.names.length; i++) {
+                const elemType = initType.elements[i] ?? { kind: 'named', name: 'int' };
+                this.scope.set(stmt.names[i], { type: elemType, mutable: true });
+            }
+        }
+        else {
+            // Can't infer element types — use int as fallback (tuple returns inferred as int from scoreboard)
+            for (const name of stmt.names) {
+                this.scope.set(name, { type: INT_TYPE, mutable: true });
+            }
+        }
+    }
     checkLetStmt(stmt) {
         // Check initializer
         const expectedType = stmt.type ? this.normalizeType(stmt.type) : undefined;
@@ -386,9 +441,15 @@ class TypeChecker {
         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);
+            !(actualType.kind === 'named' && actualType.name === 'void')) {
+            if (this.isNumericMismatch(expectedType, actualType)) {
+                // Explicit numeric conversion required for let assignments
+                this.report(`Type mismatch: cannot implicitly convert ${this.typeToString(actualType)} to ${this.typeToString(expectedType)}` +
+                    ` (use an explicit cast: 'as ${this.typeToString(expectedType)}')`, stmt);
+            }
+            else if (!this.typesMatch(expectedType, actualType)) {
+                this.report(`Type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`, stmt);
+            }
         }
     }
     checkReturnStmt(stmt) {
@@ -398,7 +459,12 @@ class TypeChecker {
         if (stmt.value) {
             const actualType = this.inferType(stmt.value, expectedType);
             this.checkExpr(stmt.value, expectedType);
-            if (!this.typesMatch(expectedType, actualType)) {
+            if (this.isNumericMismatch(expectedType, actualType)) {
+                // Explicit numeric conversion required for return statements
+                this.report(`Return type mismatch: cannot implicitly convert ${this.typeToString(actualType)} to ${this.typeToString(expectedType)}` +
+                    ` (use an explicit cast: 'as ${this.typeToString(expectedType)}')`, stmt);
+            }
+            else if (!this.typesMatch(expectedType, actualType)) {
                 this.report(`Return type mismatch: expected ${this.typeToString(expectedType)}, got ${this.typeToString(actualType)}`, stmt);
             }
         }
@@ -483,7 +549,10 @@ class TypeChecker {
                     }
                     this.checkExpr(part.expr);
                     const partType = this.inferType(part.expr);
-                    if (!(partType.kind === 'named' && (partType.name === 'int' || partType.name === 'string' || partType.name === 'format_string'))) {
+                    // Skip check if type is unknown (void) — struct field access not yet fully inferred
+                    const isUnknown = partType.kind === 'named' && partType.name === 'void';
+                    if (!isUnknown &&
+                        !(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);
                     }
                 }
@@ -493,9 +562,28 @@ class TypeChecker {
                     this.checkExpr(elem);
                 }
                 break;
+            case 'tuple_lit':
+                if (expr.elements.length < 2 || expr.elements.length > 8) {
+                    this.report(`Tuple must have 2-8 elements, got ${expr.elements.length}`, expr);
+                }
+                for (const elem of expr.elements) {
+                    this.checkExpr(elem);
+                }
+                break;
             case 'lambda':
                 this.checkLambdaExpr(expr, expectedType);
                 break;
+            case 'path_expr':
+                if (!this.enums.has(expr.enumName)) {
+                    this.report(`Unknown enum '${expr.enumName}'`, expr);
+                }
+                else {
+                    const variants = this.enums.get(expr.enumName);
+                    if (!variants.has(expr.variant)) {
+                        this.report(`Enum '${expr.enumName}' has no variant '${expr.variant}'`, expr);
+                    }
+                }
+                break;
             case 'blockpos':
                 break;
             // Literals don't need checking
@@ -530,6 +618,16 @@ class TypeChecker {
         // Check if function exists and arg count matches
         const fn = this.functions.get(expr.fn);
         if (fn) {
+            // Generic functions: skip param-type checking (monomorphizer handles it)
+            if (fn.typeParams && fn.typeParams.length > 0) {
+                const requiredParams = fn.params.filter(param => !param.default).length;
+                if (expr.args.length < requiredParams || expr.args.length > fn.params.length) {
+                    this.report(`Function '${expr.fn}' expects ${requiredParams}-${fn.params.length} arguments, got ${expr.args.length}`, expr);
+                }
+                for (const arg of expr.args)
+                    this.checkExpr(arg);
+                return;
+            }
             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
@@ -810,7 +908,15 @@ class TypeChecker {
                     return this.normalizeType(implMethod.returnType);
                 }
                 const fn = this.functions.get(expr.fn);
-                return fn?.returnType ?? INT_TYPE;
+                if (fn) {
+                    // For generic functions, the return type may be a type param (e.g. T).
+                    // If we have an expected type from context, trust it; otherwise return int as default.
+                    if (fn.typeParams && fn.typeParams.length > 0) {
+                        return expectedType ?? INT_TYPE;
+                    }
+                    return this.normalizeType(fn.returnType);
+                }
+                return INT_TYPE;
             }
             case 'static_call': {
                 const method = this.implMethods.get(expr.type)?.get(expr.method);
@@ -823,6 +929,11 @@ class TypeChecker {
                 }
                 return { kind: 'named', name: 'void' };
             }
+            case 'path_expr':
+                if (this.enums.has(expr.enumName)) {
+                    return { kind: 'enum', name: expr.enumName };
+                }
+                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 };
@@ -851,6 +962,11 @@ class TypeChecker {
                 if (expr.op === '!')
                     return { kind: 'named', name: 'bool' };
                 return this.inferType(expr.operand);
+            case 'selector': {
+                // Infer entity type from the selector
+                const entityType = this.inferEntityTypeFromSelector(expr.sel);
+                return { kind: 'selector', entityType: entityType ?? undefined };
+            }
             case 'array_lit':
                 if (expr.elements.length > 0) {
                     return { kind: 'array', elem: this.inferType(expr.elements[0]) };
@@ -864,6 +980,22 @@ class TypeChecker {
                     }
                 }
                 return { kind: 'named', name: 'void' };
+            case 'tuple_lit':
+                return {
+                    kind: 'tuple',
+                    elements: expr.elements.map(e => this.inferType(e)),
+                };
+            case 'some_lit': {
+                // Some(expr) → Option<T> where T is inferred from inner value
+                const innerType = this.inferType(expr.value, expectedType?.kind === 'option' ? expectedType.inner : undefined);
+                return { kind: 'option', inner: innerType };
+            }
+            case 'none_lit': {
+                // None → Option<T>, use expected type if available
+                if (expectedType?.kind === 'option')
+                    return expectedType;
+                return { kind: 'option', inner: { kind: 'named', name: 'void' } };
+            }
             case 'lambda':
                 return this.inferLambdaType(expr, expectedType && this.normalizeType(expectedType).kind === 'function_type'
                     ? this.normalizeType(expectedType)
@@ -954,14 +1086,54 @@ class TypeChecker {
     getCurrentSelfType() {
         return this.selfTypeStack[this.selfTypeStack.length - 1];
     }
+    /** Returns true if expected/actual are a numeric type mismatch (int vs float). */
+    isNumericMismatch(expected, actual) {
+        if (expected.kind !== 'named' || actual.kind !== 'named')
+            return false;
+        const numericPairs = [
+            ['int', 'float'], ['float', 'int'],
+            ['int', 'double'], ['double', 'int'],
+            ['float', 'double'], ['double', 'float'],
+        ];
+        return numericPairs.some(([e, a]) => expected.name === e && actual.name === a);
+    }
     typesMatch(expected, actual) {
+        // Enum values are backed by int — allow enum where int is expected and vice versa
+        if (expected.kind === 'named' && expected.name === 'int' && actual.kind === 'enum') {
+            return true;
+        }
+        if (expected.kind === 'enum' && actual.kind === 'named' && actual.name === 'int') {
+            return true;
+        }
+        // Selector/entity cross-kind compatibility (must come before kind guard)
+        if (expected.kind === 'selector' && actual.kind === 'entity') {
+            return true; // entity is a valid selector
+        }
+        if (expected.kind === 'entity' && actual.kind === 'selector') {
+            return true; // selector is a valid entity context
+        }
+        if (expected.kind === 'entity' && actual.kind === 'entity') {
+            return this.isEntitySubtype(actual.entityType, expected.entityType);
+        }
+        if (expected.kind === 'selector' && actual.kind === 'selector') {
+            return true; // any entity subtype is compatible
+        }
         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.name === actual.name)
+                return true;
+            // int→float/double implicit promotion in function calls (not for let/return — handled separately)
+            const numericPromotion = [
+                ['int', 'float'], ['int', 'double'], ['float', 'double'],
+                ['float', 'int'], ['double', 'int'], ['double', 'float'],
+            ];
+            if (numericPromotion.some(([e, a]) => expected.name === e && actual.name === a))
+                return true;
+            return false;
         }
         if (expected.kind === 'array' && actual.kind === 'array') {
             return this.typesMatch(expected.elem, actual.elem);
@@ -977,12 +1149,15 @@ 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);
+        if (expected.kind === 'tuple' && actual.kind === 'tuple') {
+            return expected.elements.length === actual.elements.length &&
+                expected.elements.every((elem, i) => this.typesMatch(elem, actual.elements[i]));
         }
-        // Selector matches any entity type
-        if (expected.kind === 'selector' && actual.kind === 'entity') {
+        if (expected.kind === 'option' && actual.kind === 'option') {
+            return this.typesMatch(expected.inner, actual.inner);
+        }
+        // Option<T> is compatible with None (void inner) or partially inferred types
+        if (expected.kind === 'option' && actual.kind === 'named' && actual.name === 'void') {
             return true;
         }
         return false;
@@ -1003,6 +1178,10 @@ class TypeChecker {
                 return type.entityType;
             case 'selector':
                 return 'selector';
+            case 'tuple':
+                return `(${type.elements.map(e => this.typeToString(e)).join(', ')})`;
+            case 'option':
+                return `Option<${this.typeToString(type.inner)}>`;
             default:
                 return 'unknown';
         }
@@ -1011,6 +1190,12 @@ class TypeChecker {
         if (type.kind === 'array') {
             return { kind: 'array', elem: this.normalizeType(type.elem) };
         }
+        if (type.kind === 'option') {
+            return { kind: 'option', inner: this.normalizeType(type.inner) };
+        }
+        if (type.kind === 'tuple') {
+            return { kind: 'tuple', elements: type.elements.map(e => this.normalizeType(e)) };
+        }
         if (type.kind === 'function_type') {
             return {
                 kind: 'function_type',

package/dist/src/types/mc-version.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Minecraft version target enumeration.
+ *
+ * Encoded as: major * 1000 + minor (patch is ignored for feature gating).
+ * e.g., 1.20.2 → 20002, 1.21 → 21000, 1.21.4 → 21004
+ */
+export declare enum McVersion {
+    v1_19 = 19000,
+    v1_20 = 20000,
+    v1_20_2 = 20002,
+    v1_20_4 = 20004,
+    v1_21 = 21000,
+    v1_21_4 = 21004
+}
+/**
+ * Parse a version string like "1.20.2" or "1.21" into a McVersion number.
+ * Throws if the string is not a valid Minecraft version.
+ */
+export declare function parseMcVersion(s: string): McVersion;
+/**
+ * Compare two McVersion values. Returns negative if a < b, 0 if equal, positive if a > b.
+ */
+export declare function compareMcVersion(a: McVersion, b: McVersion): number;
+export declare const DEFAULT_MC_VERSION = McVersion.v1_21;

package/dist/src/types/mc-version.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Minecraft version target enumeration.
+ *
+ * Encoded as: major * 1000 + minor (patch is ignored for feature gating).
+ * e.g., 1.20.2 → 20002, 1.21 → 21000, 1.21.4 → 21004
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MC_VERSION = exports.McVersion = void 0;
+exports.parseMcVersion = parseMcVersion;
+exports.compareMcVersion = compareMcVersion;
+var McVersion;
+(function (McVersion) {
+    McVersion[McVersion["v1_19"] = 19000] = "v1_19";
+    McVersion[McVersion["v1_20"] = 20000] = "v1_20";
+    McVersion[McVersion["v1_20_2"] = 20002] = "v1_20_2";
+    McVersion[McVersion["v1_20_4"] = 20004] = "v1_20_4";
+    McVersion[McVersion["v1_21"] = 21000] = "v1_21";
+    McVersion[McVersion["v1_21_4"] = 21004] = "v1_21_4";
+})(McVersion || (exports.McVersion = McVersion = {}));
+/**
+ * Parse a version string like "1.20.2" or "1.21" into a McVersion number.
+ * Throws if the string is not a valid Minecraft version.
+ */
+function parseMcVersion(s) {
+    const parts = s.trim().split('.');
+    if (parts.length < 2 || parts.length > 3) {
+        throw new Error(`Invalid MC version: "${s}" — expected format "1.20" or "1.20.2"`);
+    }
+    const [majorStr, minorStr, patchStr = '0'] = parts;
+    const major = parseInt(majorStr, 10);
+    const minor = parseInt(minorStr, 10);
+    const patch = parseInt(patchStr, 10);
+    if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+        throw new Error(`Invalid MC version: "${s}" — non-numeric component`);
+    }
+    if (major !== 1) {
+        throw new Error(`Invalid MC version: "${s}" — only Minecraft 1.x is supported`);
+    }
+    return minor * 1000 + patch;
+}
+/**
+ * Compare two McVersion values. Returns negative if a < b, 0 if equal, positive if a > b.
+ */
+function compareMcVersion(a, b) {
+    return a - b;
+}
+exports.DEFAULT_MC_VERSION = McVersion.v1_21;
+//# sourceMappingURL=mc-version.js.map