redscript-mc 2.5.0 → 2.6.2

package/dist/src/parser/index.js

@@ -69,6 +69,8 @@ class Parser {
          *  `librarySources` compile option, each source is parsed by its own fresh
          *  Parser instance, so this flag never bleeds into user code. */
         this.inLibraryMode = false;
+        /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+        this.warnings = [];
         this.tokens = tokens;
         this.sourceLines = source?.split('\n') ?? [];
         this.filePath = filePath;
@@ -148,7 +150,7 @@ class Parser {
             this.advance();
             const name = this.expect('ident');
             namespace = name.value;
-            this.expect(';');
+            this.match(';');
         }
         // Check for module declaration: `module library;` or `module <name>;`
         // Library-mode: all functions parsed from this point are marked isLibraryFn=true.
@@ -165,7 +167,7 @@ class Parser {
                 // Named module declaration: `module math;`
                 moduleName = modKind.value;
             }
-            this.expect(';');
+            this.match(';');
         }
         // Parse struct, function, and import declarations
         while (!this.check('eof')) {
@@ -206,7 +208,7 @@ class Parser {
                 else {
                     symbol = this.expect('ident').value;
                 }
-                this.expect(';');
+                this.match(';');
                 imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
             }
             else {
@@ -283,7 +285,7 @@ class Parser {
         // Infer type from value if not provided
         const inferredType = type ?? (value.kind === 'str_lit' ? { kind: 'named', name: 'string' } :
             value.kind === 'bool_lit' ? { kind: 'named', name: 'bool' } :
-                value.kind === 'float_lit' ? { kind: 'named', name: 'float' } :
+                value.kind === 'float_lit' ? { kind: 'named', name: 'fixed' } :
                     { kind: 'named', name: 'int' });
         return this.withLoc({ name, type: inferredType, value }, constToken);
     }
@@ -294,7 +296,7 @@ class Parser {
         const type = this.parseType();
         this.expect('=');
         const init = this.parseExpr();
-        this.expect(';');
+        this.match(';');
         return this.withLoc({ kind: 'global', name, type, init, mutable }, token);
     }
     // -------------------------------------------------------------------------
@@ -338,8 +340,12 @@ class Parser {
             returnType = this.parseType();
         }
         const body = this.parseBlock();
+        // Record the closing '}' line as endLine for accurate LSP scope detection
+        const closingBraceLine = this.tokens[this.pos - 1]?.line;
         const fn = this.withLoc({ name, typeParams, params, returnType, decorators: filteredDecorators, body,
             isLibraryFn: this.inLibraryMode || undefined, isExported }, fnToken);
+        if (fn.span && closingBraceLine)
+            fn.span.endLine = closingBraceLine;
         return fn;
     }
     /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -443,7 +449,7 @@ class Parser {
                 args.batch = parseInt(val, 10);
             }
             else if (key === 'onDone') {
-                args.onDone = val;
+                args.onDone = val.replace(/^["']|["']$/g, '');
             }
             else if (key === 'trigger') {
                 args.trigger = val;
@@ -506,8 +512,14 @@ class Parser {
             // It's a tuple type
             return { kind: 'tuple', elements };
         }
-        if (token.kind === 'int' || token.kind === 'bool' ||
-            token.kind === 'float' || token.kind === 'string' || token.kind === 'void' ||
+        if (token.kind === 'float') {
+            this.advance();
+            const filePart = this.filePath ? `${this.filePath}:` : '';
+            this.warnings.push(`[DeprecatedType] ${filePart}line ${token.line}, col ${token.col}: 'float' is deprecated, use 'fixed' instead (×10000 fixed-point)`);
+            type = { kind: 'named', name: 'float' };
+        }
+        else if (token.kind === 'int' || token.kind === 'bool' ||
+            token.kind === 'fixed' || token.kind === 'string' || token.kind === 'void' ||
             token.kind === 'BlockPos') {
             this.advance();
             type = { kind: 'named', name: token.kind };
@@ -529,6 +541,11 @@ class Parser {
                 this.expect('>');
                 type = { kind: 'option', inner };
             }
+            else if (token.value === 'double' || token.value === 'byte' ||
+                token.value === 'short' || token.value === 'long' ||
+                token.value === 'format_string') {
+                type = { kind: 'named', name: token.value };
+            }
             else {
                 type = { kind: 'struct', name: token.value };
             }
@@ -645,7 +662,7 @@ class Parser {
             }
             this.expect('=');
             const init = this.parseExpr();
-            this.expect(';');
+            this.match(';');
             return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken);
         }
         const name = this.expect('ident').value;
@@ -655,16 +672,16 @@ class Parser {
         }
         this.expect('=');
         const init = this.parseExpr();
-        this.expect(';');
+        this.match(';');
         return this.withLoc({ kind: 'let', name, type, init }, letToken);
     }
     parseReturnStmt() {
         const returnToken = this.expect('return');
         let value;
-        if (!this.check(';')) {
+        if (!this.check(';') && !this.check('}') && !this.check('eof')) {
             value = this.parseExpr();
         }
-        this.expect(';');
+        this.match(';');
         return this.withLoc({ kind: 'return', value }, returnToken);
     }
     parseIfStmt() {
@@ -763,29 +780,57 @@ class Parser {
         this.expect('in');
         let start;
         let end;
+        let inclusive = false;
         if (this.check('range_lit')) {
-            // Literal range: 0..10, 0..count, 0..=9
+            // Literal range: 0..10, 0..count, 0..=9, 0..=count
             const rangeToken = this.advance();
-            const range = this.parseRangeValue(rangeToken.value);
+            const raw = rangeToken.value;
+            // Detect inclusive: ends with = after .. (e.g. "0..=" or "..=")
+            const incl = raw.includes('..=');
+            inclusive = incl;
+            const range = this.parseRangeValue(raw);
             start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken);
             if (range.max !== null && range.max !== undefined) {
-                // Fully numeric: 0..10
+                // Fully numeric: 0..10 or 0..=9
                 end = this.withLoc({ kind: 'int_lit', value: range.max }, rangeToken);
             }
             else {
-                // Open-ended: "0.." — parse the end expression from next tokens
+                // Open-ended: "0.." or "0..=" — parse the end expression from next tokens
                 end = this.parseUnaryExpr();
             }
         }
         else {
-            // Dynamic range: expr..expr (e.g. start..end) — not yet supported
-            // Fall back to: parse as int_lit 0..0 (safe default)
-            start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
-            end = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
-            this.error('Dynamic range start requires a literal integer (e.g. 0..count)');
+            // Dynamic range: expr..expr or expr..=expr
+            // parseExpr stops before range_lit (not in BINARY_OPS), so this is safe
+            const arrayOrStart = this.parseExpr();
+            // --- for_each detection: for item in arr { ... } ---
+            // If after parsing the expression there is no range_lit, it's a for_each (array iteration)
+            if (!this.check('range_lit')) {
+                const body = this.parseBlock();
+                return this.withLoc({ kind: 'for_each', binding: varName, array: arrayOrStart, body }, forToken);
+            }
+            start = arrayOrStart;
+            // Consume the range_lit token which should be ".." or "..="
+            if (this.check('range_lit')) {
+                const rangeOp = this.advance();
+                inclusive = rangeOp.value.includes('=');
+                // If the range_lit captured digits after .., use them as end
+                const afterOp = rangeOp.value.replace(/^\.\.=?/, '');
+                if (afterOp.length > 0) {
+                    end = this.withLoc({ kind: 'int_lit', value: parseInt(afterOp, 10) }, rangeOp);
+                }
+                else {
+                    end = this.parseExpr();
+                }
+            }
+            else {
+                this.error('Expected .. or ..= in for-range expression');
+                start = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
+                end = this.withLoc({ kind: 'int_lit', value: 0 }, this.peek());
+            }
         }
         const body = this.parseBlock();
-        return this.withLoc({ kind: 'for_range', varName, start, end, body }, forToken);
+        return this.withLoc({ kind: 'for_range', varName, start, end, inclusive, body }, forToken);
     }
     parseForeachStmt() {
         const foreachToken = this.expect('foreach');
@@ -809,24 +854,60 @@ class Parser {
         const body = this.parseBlock();
         return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken);
     }
+    parseMatchPattern() {
+        // Wildcard: _
+        if (this.check('ident') && this.peek().value === '_') {
+            this.advance();
+            return { kind: 'PatWild' };
+        }
+        // None
+        if (this.check('ident') && this.peek().value === 'None') {
+            this.advance();
+            return { kind: 'PatNone' };
+        }
+        // Some(x)
+        if (this.check('ident') && this.peek().value === 'Some') {
+            this.advance(); // consume 'Some'
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            return { kind: 'PatSome', binding };
+        }
+        // Integer literal
+        if (this.check('int_lit')) {
+            const tok = this.advance();
+            return { kind: 'PatInt', value: parseInt(tok.value, 10) };
+        }
+        // Negative integer literal: -N
+        if (this.check('-') && this.peek(1).kind === 'int_lit') {
+            this.advance(); // consume '-'
+            const tok = this.advance();
+            return { kind: 'PatInt', value: -parseInt(tok.value, 10) };
+        }
+        // Legacy: range_lit or any other expression (e.g. 0..59)
+        const e = this.parseExpr();
+        return { kind: 'PatExpr', expr: e };
+    }
     parseMatchStmt() {
         const matchToken = this.expect('match');
-        this.expect('(');
-        const expr = this.parseExpr();
-        this.expect(')');
+        // Support both `match (expr)` (legacy) and `match expr` (new syntax)
+        let expr;
+        if (this.check('(')) {
+            // Peek ahead — if it looks like `(expr)` followed by `{`, consume parens
+            this.advance(); // consume '('
+            expr = this.parseExpr();
+            this.expect(')');
+        }
+        else {
+            expr = this.parseExpr();
+        }
         this.expect('{');
         const arms = [];
         while (!this.check('}') && !this.check('eof')) {
-            let pattern;
-            if (this.check('ident') && this.peek().value === '_') {
-                this.advance();
-                pattern = null;
-            }
-            else {
-                pattern = this.parseExpr();
-            }
+            const pattern = this.parseMatchPattern();
             this.expect('=>');
             const body = this.parseBlock();
+            this.match(','); // optional trailing comma
             arms.push({ pattern, body });
         }
         this.expect('}');
@@ -1034,7 +1115,7 @@ class Parser {
     }
     parseExprStmt() {
         const expr = this.parseExpr();
-        this.expect(';');
+        this.match(';');
         const exprToken = this.getLocToken(expr) ?? this.peek();
         return this.withLoc({ kind: 'expr', expr }, exprToken);
     }
@@ -1211,10 +1292,32 @@ class Parser {
                 expr = this.withLoc({ kind: 'member', obj: expr, field }, this.getLocToken(expr) ?? this.tokens[this.pos - 1]);
                 continue;
             }
+            // Type cast: expr as Type
+            // Only parse 'as' as a cast when followed by a type token (not a selector like @a)
+            if (this.check('as') && this.isTypeCastAs()) {
+                const asToken = this.advance(); // consume 'as'
+                const targetType = this.parseType();
+                expr = this.withLoc({ kind: 'type_cast', expr, targetType }, this.getLocToken(expr) ?? asToken);
+                continue;
+            }
             break;
         }
         return expr;
     }
+    /** Returns true if the current 'as' token is a type cast (not a context block) */
+    isTypeCastAs() {
+        // Look ahead past 'as' to see if the next token looks like a type
+        const next = this.tokens[this.pos + 1];
+        if (!next)
+            return false;
+        const typeStartTokens = new Set(['int', 'bool', 'float', 'fixed', 'string', 'void', 'BlockPos', '(']);
+        if (typeStartTokens.has(next.kind))
+            return true;
+        if (next.kind === 'ident' && (next.value === 'double' || next.value === 'byte' || next.value === 'short' ||
+            next.value === 'long' || next.value === 'selector' || next.value === 'Option'))
+            return true;
+        return false;
+    }
     parseArgs() {
         const args = [];
         if (!this.check(')')) {
@@ -1318,6 +1421,13 @@ class Parser {
                 sel: this.parseSelectorValue(token.value),
             }, token);
         }
+        // Named struct literal: TypeName { field: value, ... }
+        // Require at least one field (ident + :) to avoid ambiguity with blocks.
+        if (token.kind === 'ident' && this.peek(1).kind === '{' &&
+            this.peek(2).kind === 'ident' && this.peek(3).kind === ':') {
+            this.advance(); // consume type name (used only for disambiguation, dropped from AST)
+            return this.parseStructLit();
+        }
         // Some(expr) — Option constructor
         if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
             this.advance(); // consume 'Some'
@@ -1637,6 +1747,7 @@ class Parser {
         const isNamedType = token.kind === 'int' ||
             token.kind === 'bool' ||
             token.kind === 'float' ||
+            token.kind === 'fixed' ||
             token.kind === 'string' ||
             token.kind === 'void' ||
             token.kind === 'BlockPos' ||
@@ -1868,21 +1979,42 @@ class Parser {
     }
     parseRangeValue(value) {
         // ..5 → { max: 5 }
+        // ..=5 → { max: 5 }
         // 1.. → { min: 1 }
+        // 1..= → { min: 1 } (open-ended inclusive, end parsed separately)
         // 1..10 → { min: 1, max: 10 }
+        // 1..=10 → { min: 1, max: 10 }
         // 5 → { min: 5, max: 5 } (exact match)
+        if (value.startsWith('..=')) {
+            const rest = value.slice(3);
+            if (!rest)
+                return {}; // open upper bound, no max
+            const max = parseInt(rest, 10);
+            return { max };
+        }
         if (value.startsWith('..')) {
-            const max = parseInt(value.slice(2), 10);
+            const rest = value.slice(2);
+            if (!rest)
+                return {}; // open upper bound, no max
+            const max = parseInt(rest, 10);
             return { max };
         }
-        if (value.endsWith('..')) {
-            const min = parseInt(value.slice(0, -2), 10);
-            return { min };
+        const inclIdx = value.indexOf('..=');
+        if (inclIdx !== -1) {
+            const min = parseInt(value.slice(0, inclIdx), 10);
+            const rest = value.slice(inclIdx + 3);
+            if (!rest)
+                return { min }; // open-ended inclusive
+            const max = parseInt(rest, 10);
+            return { min, max };
         }
         const dotIndex = value.indexOf('..');
         if (dotIndex !== -1) {
             const min = parseInt(value.slice(0, dotIndex), 10);
-            const max = parseInt(value.slice(dotIndex + 2), 10);
+            const rest = value.slice(dotIndex + 2);
+            if (!rest)
+                return { min }; // open-ended
+            const max = parseInt(rest, 10);
             return { min, max };
         }
         // Exact value

package/dist/src/runtime/index.js

@@ -240,6 +240,11 @@ class MCRuntime {
         this.namespace = namespace;
         // Initialize default objective
         this.scoreboard.set('rs', new Map());
+        // Pre-populate math:tables with the sin LUT (same values as _math_init in math.mcrs).
+        // This avoids requiring a real MC server for unit tests that use sin_fixed/cos_fixed.
+        // Values: sin(0°..90°) × 1000, 91 entries.
+        const SIN_TABLE = [0, 17, 35, 52, 70, 87, 105, 122, 139, 156, 174, 191, 208, 225, 242, 259, 276, 292, 309, 326, 342, 358, 375, 391, 407, 423, 438, 454, 469, 485, 500, 515, 530, 545, 559, 574, 588, 602, 616, 629, 643, 656, 669, 682, 695, 707, 719, 731, 743, 755, 766, 777, 788, 799, 809, 819, 829, 839, 848, 857, 866, 875, 883, 891, 899, 906, 914, 921, 927, 934, 940, 946, 951, 956, 961, 966, 970, 974, 978, 982, 985, 988, 990, 993, 995, 996, 998, 999, 999, 1000, 1000];
+        this.setStorageField('math:tables', 'sin', SIN_TABLE);
     }
     // -------------------------------------------------------------------------
     // Datapack Loading
@@ -729,6 +734,25 @@ class MCRuntime {
     // -------------------------------------------------------------------------
     execFunctionCmd(cmd, executor) {
         let fnRef = cmd.slice(9).trim(); // remove 'function '
+        // Handle storage_get_int builtin — compiled as `function ns:storage_get_int`
+        // Parameters: $p0=0 (storagePath, lost as string), $p1=0 (fieldName, lost),
+        // $p2=index. Since string params are lost, we use a hardcoded lookup against
+        // the pre-populated math:tables.sin (the only stdlib user of this builtin).
+        // The result is written to $ret.
+        if (fnRef.endsWith(':storage_get_int')) {
+            const ns = this.namespace;
+            const obj = `__${ns}`;
+            const idx = this.getScore('$p2', obj);
+            const arr = this.getStorageField('math:tables', 'sin');
+            const value = Array.isArray(arr) ? (arr[idx] ?? 0) : 0;
+            this.setScore('$ret', obj, value);
+            return true;
+        }
+        // Handle storage_set_array builtin — compiled as `function ns:storage_set_array`
+        // The sin LUT is already pre-populated in the constructor; this is a no-op.
+        if (fnRef.endsWith(':storage_set_array')) {
+            return true;
+        }
         // Handle 'function ns:name with storage ns:path' — MC macro calling convention.
         // The called function may have $( ) placeholders that need to be expanded
         // using the provided storage compound. We execute the function after

package/dist/src/typechecker/index.d.ts

@@ -8,6 +8,8 @@ import type { Program } from '../ast/types';
 import { DiagnosticError } from '../diagnostics';
 export declare class TypeChecker {
     private collector;
+    private filePath?;
+    private lintWarnings;
     private functions;
     private implMethods;
     private structs;
@@ -24,6 +26,9 @@ export declare class TypeChecker {
     constructor(source?: string, filePath?: string);
     private getNodeLocation;
     private report;
+    private warnLint;
+    /** Returns lint warnings (non-blocking). */
+    getWarnings(): string[];
     /**
      * Type check a program. Returns collected errors.
      */
@@ -59,7 +64,9 @@ export declare class TypeChecker {
     private popSelfType;
     /** Get current @s type */
     private getCurrentSelfType;
-    /** Returns true if expected/actual are a numeric type mismatch (int vs float). */
+    /** Returns true if expected/actual are a numeric type mismatch (int vs float/fixed/double).
+     * These pairs are NOT implicitly compatible — require explicit `as` cast.
+     * Only int↔byte/short/long remain implicitly compatible (MC NBT narrowing). */
     private isNumericMismatch;
     private typesMatch;
     private typeToString;

package/dist/src/typechecker/index.js

@@ -112,6 +112,7 @@ const BUILTIN_SIGNATURES = {
 // ---------------------------------------------------------------------------
 class TypeChecker {
     constructor(source, filePath) {
+        this.lintWarnings = [];
         this.functions = new Map();
         this.implMethods = new Map();
         this.structs = new Map();
@@ -136,6 +137,7 @@ class TypeChecker {
             ['subtitle', { messageIndex: 1 }],
         ]);
         this.collector = new diagnostics_1.DiagnosticCollector(source, filePath);
+        this.filePath = filePath;
     }
     getNodeLocation(node) {
         const span = node?.span;
@@ -148,6 +150,15 @@ class TypeChecker {
         const { line, col } = this.getNodeLocation(node);
         this.collector.error('TypeError', message, line, col);
     }
+    warnLint(message, node) {
+        const { line, col } = this.getNodeLocation(node);
+        const filePart = this.filePath ? `${this.filePath}:` : '';
+        this.lintWarnings.push(`${filePart}line ${line}, col ${col}: ${message}`);
+    }
+    /** Returns lint warnings (non-blocking). */
+    getWarnings() {
+        return this.lintWarnings;
+    }
     /**
      * Type check a program. Returns collected errors.
      */
@@ -350,17 +361,19 @@ class TypeChecker {
             case 'match':
                 this.checkExpr(stmt.expr);
                 for (const arm of stmt.arms) {
-                    if (arm.pattern) {
-                        this.checkExpr(arm.pattern);
+                    if (arm.pattern.kind === 'PatExpr') {
+                        // Legacy: check the wrapped expression against the subject type
+                        this.checkExpr(arm.pattern.expr);
                         const subjectType = this.inferType(stmt.expr);
-                        const patternType = this.inferType(arm.pattern);
+                        const patternType = this.inferType(arm.pattern.expr);
                         // 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);
+                            this.report('Match arm pattern type must match subject type', arm.pattern.expr);
                         }
                     }
+                    // PatSome / PatNone / PatInt / PatWild are structurally typed — no expr to check
                     this.checkBlock(arm.body);
                 }
                 break;
@@ -472,6 +485,15 @@ class TypeChecker {
         if (stmt.value) {
             const actualType = this.inferType(stmt.value, expectedType);
             this.checkExpr(stmt.value, expectedType);
+            // Warn when returning a float-typed result of arithmetic — the arithmetic
+            // itself is the problem, not just the type annotation.
+            const returnIsFloat = expectedType.kind === 'named' && expectedType.name === 'float';
+            if (returnIsFloat && stmt.value.kind === 'binary') {
+                const arithmeticOps = ['+', '-', '*', '/', '%'];
+                if (arithmeticOps.includes(stmt.value.op)) {
+                    this.warnLint(`[FloatArithmetic] 'float' is a system boundary type (MC NBT float); use 'fixed' for arithmetic instead.`, stmt.value);
+                }
+            }
             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)}` +
@@ -507,10 +529,28 @@ class TypeChecker {
             case 'static_call':
                 this.checkStaticCallExpr(expr);
                 break;
-            case 'binary':
+            case 'binary': {
                 this.checkExpr(expr.left);
                 this.checkExpr(expr.right);
+                const arithmeticOps = ['+', '-', '*', '/', '%'];
+                if (arithmeticOps.includes(expr.op)) {
+                    const leftType = this.inferType(expr.left);
+                    const rightType = this.inferType(expr.right);
+                    const leftIsString = leftType.kind === 'named' && (leftType.name === 'string' || leftType.name === 'format_string');
+                    const rightIsString = rightType.kind === 'named' && (rightType.name === 'string' || rightType.name === 'format_string');
+                    if (leftIsString || rightIsString) {
+                        // String concatenation with + is not supported. Use f-strings instead.
+                        this.report(`[StringConcat] String concatenation with '+' is not supported. Use f-strings instead: f"text{variable}" — e.g. f"Score: {score}"`, expr);
+                    }
+                    // Warn when float is used in arithmetic — float is a MC NBT system boundary type
+                    const leftIsFloat = leftType.kind === 'named' && leftType.name === 'float';
+                    const rightIsFloat = rightType.kind === 'named' && rightType.name === 'float';
+                    if (leftIsFloat || rightIsFloat) {
+                        this.warnLint(`[FloatArithmetic] 'float' is a system boundary type (MC NBT); use 'fixed' for arithmetic. Float arithmetic results are undefined.`, expr);
+                    }
+                }
                 break;
+            }
             case 'is_check': {
                 this.checkExpr(expr.expr);
                 const checkedType = this.inferType(expr.expr);
@@ -570,7 +610,7 @@ class TypeChecker {
                     // 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'))) {
+                        !(partType.kind === 'named' && ['int', 'string', 'format_string', 'fixed', 'double', 'bool', 'byte', 'short', 'long'].includes(partType.name))) {
                         this.report(`f-string placeholder must be int or string, got ${this.typeToString(partType)}`, part.expr);
                     }
                 }
@@ -617,6 +657,9 @@ class TypeChecker {
             case 'long_lit':
             case 'double_lit':
                 break;
+            case 'type_cast':
+                this.checkExpr(expr.expr);
+                break;
         }
     }
     checkCallExpr(expr) {
@@ -776,7 +819,7 @@ class TypeChecker {
                     // 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)) {
+                        if (['int', 'bool', 'float', 'fixed', 'string', 'byte', 'short', 'long', 'double'].includes(varType.name)) {
                             this.report(`Cannot access member '${expr.field}' on ${this.typeToString(varType)}`, expr);
                         }
                     }
@@ -878,7 +921,7 @@ class TypeChecker {
             case 'int_lit':
                 return { kind: 'named', name: 'int' };
             case 'float_lit':
-                return { kind: 'named', name: 'float' };
+                return { kind: 'named', name: 'fixed' };
             case 'byte_lit':
                 return { kind: 'named', name: 'byte' };
             case 'short_lit':
@@ -1030,6 +1073,9 @@ class TypeChecker {
                     return expectedType;
                 return { kind: 'option', inner: { kind: 'named', name: 'void' } };
             }
+            case 'type_cast':
+                // The result type of (expr as T) is T
+                return this.normalizeType(expr.targetType);
             case 'lambda':
                 return this.inferLambdaType(expr, expectedType && this.normalizeType(expectedType).kind === 'function_type'
                     ? this.normalizeType(expectedType)
@@ -1120,14 +1166,19 @@ class TypeChecker {
     getCurrentSelfType() {
         return this.selfTypeStack[this.selfTypeStack.length - 1];
     }
-    /** Returns true if expected/actual are a numeric type mismatch (int vs float). */
+    /** Returns true if expected/actual are a numeric type mismatch (int vs float/fixed/double).
+     * These pairs are NOT implicitly compatible — require explicit `as` cast.
+     * Only int↔byte/short/long remain implicitly compatible (MC NBT narrowing). */
     isNumericMismatch(expected, actual) {
         if (expected.kind !== 'named' || actual.kind !== 'named')
             return false;
         const numericPairs = [
             ['int', 'float'], ['float', 'int'],
+            ['int', 'fixed'], ['fixed', 'int'],
             ['int', 'double'], ['double', 'int'],
             ['float', 'double'], ['double', 'float'],
+            ['fixed', 'double'], ['double', 'fixed'],
+            // float and fixed are compatible (float is deprecated alias for fixed)
         ];
         return numericPairs.some(([e, a]) => expected.name === e && actual.name === a);
     }
@@ -1160,12 +1211,20 @@ class TypeChecker {
                 return true;
             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'],
+            // float is a deprecated alias for fixed — they are interchangeable
+            const floatFixed = (expected.name === 'float' || expected.name === 'fixed') &&
+                (actual.name === 'float' || actual.name === 'fixed');
+            if (floatFixed)
+                return true;
+            // No implicit numeric promotions between int/fixed/double/float.
+            // Users must use explicit `as` casts: x as fixed, x as double, etc.
+            // Only byte/short/long ↔ int remain implicitly compatible (MC NBT type narrowing).
+            const nbtNarrowing = [
+                ['int', 'byte'], ['byte', 'int'],
+                ['int', 'short'], ['short', 'int'],
+                ['int', 'long'], ['long', 'int'],
             ];
-            if (numericPromotion.some(([e, a]) => expected.name === e && actual.name === a))
+            if (nbtNarrowing.some(([e, a]) => expected.name === e && actual.name === a))
                 return true;
             return false;
         }