redscript-mc 2.4.1 → 2.6.0

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);
     }
     // -------------------------------------------------------------------------
@@ -443,7 +445,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 +508,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 +537,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 +658,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 +668,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() {
@@ -721,6 +734,18 @@ class Parser {
             return this.parseForRangeStmt(forToken);
         }
         this.expect('(');
+        // Detect for-in-array syntax: for ( let ident in ident , lenExpr ) { ... }
+        if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(2).kind === 'in' && this.peek(3).kind === 'ident' && this.peek(4).kind === ',') {
+            this.advance(); // consume 'let'
+            const binding = this.expect('ident').value;
+            this.expect('in');
+            const arrayName = this.expect('ident').value;
+            this.expect(',');
+            const lenExpr = this.parseExpr();
+            this.expect(')');
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'for_in_array', binding, arrayName, lenExpr, body }, forToken);
+        }
         // Init: either let statement (without semicolon) or empty
         let init;
         if (this.check('let')) {
@@ -751,29 +776,50 @@ 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
+            start = this.parseExpr();
+            // 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');
@@ -1022,7 +1068,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);
     }
@@ -1199,10 +1245,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(')')) {
@@ -1306,6 +1374,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'
@@ -1625,6 +1700,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' ||
@@ -1856,21 +1932,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/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.
      */
@@ -472,6 +483,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 +527,23 @@ class TypeChecker {
             case 'static_call':
                 this.checkStaticCallExpr(expr);
                 break;
-            case 'binary':
+            case 'binary': {
                 this.checkExpr(expr.left);
                 this.checkExpr(expr.right);
+                // Warn when float is used in arithmetic — float is a MC NBT system boundary type,
+                // not suitable for computation. Use fixed (×10000) instead.
+                const arithmeticOps = ['+', '-', '*', '/', '%'];
+                if (arithmeticOps.includes(expr.op)) {
+                    const leftType = this.inferType(expr.left);
+                    const rightType = this.inferType(expr.right);
+                    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);
@@ -617,6 +650,9 @@ class TypeChecker {
             case 'long_lit':
             case 'double_lit':
                 break;
+            case 'type_cast':
+                this.checkExpr(expr.expr);
+                break;
         }
     }
     checkCallExpr(expr) {
@@ -776,7 +812,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 +914,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 +1066,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 +1159,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 +1204,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;
         }