redscript-mc 2.5.0 → 2.6.0

package/dist/src/optimizer/constant_fold.js

@@ -9,6 +9,10 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.constantFold = constantFold;
+/** Wrap a JS number to Java signed int32 (MC scoreboard semantics). */
+function int32(n) {
+    return (n | 0);
+}
 function constantFold(fn) {
     return {
         ...fn,
@@ -30,27 +34,27 @@ function tryFold(instr) {
     switch (instr.kind) {
         case 'add':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value + instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value + instr.b.value) };
             break;
         case 'sub':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value - instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value - instr.b.value) };
             break;
         case 'mul':
             if (isConst(instr.a) && isConst(instr.b))
-                return { kind: 'const', dst: instr.dst, value: instr.a.value * instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value * instr.b.value) };
             break;
         case 'div':
             if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-                return { kind: 'const', dst: instr.dst, value: Math.trunc(instr.a.value / instr.b.value) };
+                return { kind: 'const', dst: instr.dst, value: int32(Math.trunc(instr.a.value / instr.b.value)) };
             break;
         case 'mod':
             if (isConst(instr.a) && isConst(instr.b) && instr.b.value !== 0)
-                return { kind: 'const', dst: instr.dst, value: instr.a.value % instr.b.value };
+                return { kind: 'const', dst: instr.dst, value: int32(instr.a.value % instr.b.value) };
             break;
         case 'neg':
             if (isConst(instr.src))
-                return { kind: 'const', dst: instr.dst, value: -instr.src.value };
+                return { kind: 'const', dst: instr.dst, value: int32(-instr.src.value) };
             break;
         case 'not':
             if (isConst(instr.src))

package/dist/src/optimizer/coroutine.js

@@ -112,18 +112,26 @@ function transformCoroutine(fn, info, objective) {
     // Continuation 1: entry block → until first yield
     // Continuation N: from loop header → until next yield or exit
     const continuations = partitionIntoContinuations(fn, loopHeaders, backEdges);
+    // Compute the dispatcher name and the exact scoreboard player for the PC slot.
+    // The LIR lowerer prefixes each temp with the function name, so the PC slot
+    // used by the dispatcher (function = `${prefix}_tick`) is:
+    //   player = `$${prefix}_tick_${pcTemp}`, obj = objective
+    // We pass this pre-computed player string into builders so they can emit
+    // side-effectful `score_write` instructions that survive DCE.
+    const dispatcherName = `${prefix}_tick`;
+    const pcPlayer = `$${dispatcherName}_${pcTemp}`;
     // Step 4: Build continuation functions with batch counting and variable promotion
     const contFunctions = [];
     for (let i = 0; i < continuations.length; i++) {
         const contId = i + 1;
         const cont = continuations[i];
-        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name);
+        const contFn = buildContinuationFunction(`${prefix}_cont_${contId}`, cont, info.batch, contId, continuations.length, promoted, pcTemp, batchCountTemp, objective, info.onDone, fn.name, pcPlayer);
         contFunctions.push(contFn);
     }
     // Step 5: Build the init function (replaces original)
-    const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective);
+    const initFn = buildInitFunction(fn, promoted, pcTemp, prefix, objective, pcPlayer);
     // Step 6: Build the @tick dispatcher
-    const dispatcher = buildDispatcher(`${prefix}_tick`, contFunctions, pcTemp, objective, fn.name);
+    const dispatcher = buildDispatcher(dispatcherName, contFunctions, pcTemp, objective, fn.name);
     return { initFn, continuations: contFunctions, dispatcher };
 }
 // ---------------------------------------------------------------------------
@@ -368,15 +376,15 @@ function partitionIntoContinuations(fn, loopHeaders, backEdges) {
 // ---------------------------------------------------------------------------
 // Step 4: Build continuation functions
 // ---------------------------------------------------------------------------
-function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName) {
+function buildContinuationFunction(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, originalFnName, pcPlayer) {
     if (cont.isLoopBody) {
-        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone);
+        return buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer);
     }
     else {
-        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone);
+        return buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer);
     }
 }
-function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone) {
+function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted, pcTemp, batchCountTemp, objective, onDone, pcPlayer) {
     // Build a new function that:
     // 1. Initializes batch_count = 0
     // 2. Runs the loop body up to `batch` iterations
@@ -451,11 +459,15 @@ function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted,
             // Check if this block exits the loop
             const exitSuccs = succs.filter(s => !cont.blocks.some(b => b.id === s));
             if (exitSuccs.length > 0) {
-                // Redirect exit branch to an exit block that returns
+                // Redirect exit branch to an exit block that advances PC and returns.
+                // Setting PC to contId+1 tells the dispatcher to run the next continuation
+                // on the following tick (post-loop code / onDone).
                 const exitBlockId = `${block.id}_exit`;
                 const exitBlock = {
                     id: exitBlockId,
-                    instrs: [],
+                    instrs: [
+                        { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: contId + 1 } },
+                    ],
                     term: { kind: 'return', value: null },
                     preds: [block.id],
                 };
@@ -506,7 +518,7 @@ function buildLoopContinuation(name, cont, batch, contId, totalConts, promoted,
         isMacro: false,
     };
 }
-function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone) {
+function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objective, onDone, pcPlayer) {
     const blocks = [];
     // Rewrite blocks with promoted variables
     for (const block of cont.blocks) {
@@ -514,19 +526,20 @@ function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objecti
     }
     // The entry is the first block in the continuation
     const entry = cont.blocks[0]?.id ?? 'entry';
-    // Add onDone call if this is the last continuation
-    if (onDone) {
-        // Find blocks with return terminators and add onDone call before them
-        for (let i = 0; i < blocks.length; i++) {
-            if (blocks[i].term.kind === 'return') {
-                blocks[i] = {
-                    ...blocks[i],
-                    instrs: [
-                        ...blocks[i].instrs,
-                        { kind: 'call', dst: null, fn: onDone, args: [] },
-                    ],
-                };
+    // Add onDone call and PC reset on completion (this is the last continuation).
+    // Setting PC=0 marks the coroutine as done so the dispatcher stops running.
+    for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i].term.kind === 'return') {
+            const extraInstrs = [];
+            if (onDone) {
+                extraInstrs.push({ kind: 'call', dst: null, fn: onDone, args: [] });
             }
+            // Reset PC to 0 → dispatcher will find no matching continuation → coroutine done
+            extraInstrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } });
+            blocks[i] = {
+                ...blocks[i],
+                instrs: [...blocks[i].instrs, ...extraInstrs],
+            };
         }
     }
     return {
@@ -540,22 +553,55 @@ function buildPostLoopContinuation(name, cont, contId, promoted, pcTemp, objecti
 // ---------------------------------------------------------------------------
 // Step 5: Build init function (replaces original)
 // ---------------------------------------------------------------------------
-function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective) {
+function buildInitFunction(originalFn, promoted, pcTemp, prefix, objective, pcPlayer) {
     // The init function:
     // 1. Sets pc = 1 (start from continuation 1)
     // 2. Initializes promoted variables from the entry block's pre-loop code
+    //
+    // NOTE: We use `score_write` (side-effectful, not removed by DCE) to write
+    // directly to the dispatcher's PC scoreboard slot.  Using `const` would
+    // write to a function-local temp (prefixed with the init-function name) which
+    // is a *different* slot from the one the dispatcher reads.
     const instrs = [];
-    // Set pc = 1
-    instrs.push({ kind: 'const', dst: pcTemp, value: 1 });
-    // Initialize promoted variables from entry block instructions
-    // Walk the entry block and copy any const/copy instructions for promoted vars
+    // Set pc = 1 via score_write so DCE cannot eliminate it
+    instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } });
+    // Initialize promoted variables from entry block instructions.
+    // We must use score_write (side-effectful) rather than const/copy so that DCE
+    // does not eliminate these instructions (the dst is never read in the init fn).
+    // Continuations read promoted vars from `$${contName}_${promotedTemp}`, where
+    // contName = `${prefix}_cont_1` (the first continuation).
+    // We write to EACH continuation's slot so all continuations see the initial values.
+    // (In practice there is usually only one continuation with a loop.)
+    const dispatcherName = `${prefix}_cont_1`;
     const entryBlock = originalFn.blocks.find(b => b.id === originalFn.entry);
     if (entryBlock) {
         for (const instr of entryBlock.instrs) {
             const dst = getDst(instr);
             if (dst && promoted.has(dst)) {
-                // Rewrite to use promoted name
-                instrs.push(rewriteInstr(instr, promoted));
+                const promotedTemp = promoted.get(dst);
+                const player = `$${dispatcherName}_${promotedTemp}`;
+                if (instr.kind === 'const') {
+                    instrs.push({ kind: 'score_write', player, obj: objective, src: { kind: 'const', value: instr.value } });
+                }
+                else if (instr.kind === 'copy') {
+                    // src is an Operand; if it's a temp, resolve through promoted map
+                    let src;
+                    if (instr.src.kind === 'temp') {
+                        const srcTemp = promoted.get(instr.src.name) ?? instr.src.name;
+                        src = { kind: 'temp', name: srcTemp };
+                    }
+                    else {
+                        src = instr.src;
+                    }
+                    instrs.push({ kind: 'score_write', player, obj: objective, src });
+                }
+                else {
+                    // Fallback for other instruction types: rewrite and emit as-is.
+                    // These will have the init-function prefix, which may be wrong, but they
+                    // are uncommon — the promoted variable set only contains loop-carried vars
+                    // that are initialised with const/copy in the entry block.
+                    instrs.push(rewriteInstr(instr, promoted));
+                }
             }
         }
     }
@@ -640,13 +686,17 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
     // If there are no loops, the entire function body runs in one tick.
     // We still wrap it in the coroutine pattern for consistency (init → cont_1 → done).
     const contName = `${prefix}_cont_1`;
-    // Continuation = entire original function body, plus set pc=-1 at the end
+    const dispatcherName = `${prefix}_tick`;
+    const pcPlayer = `$${dispatcherName}_${pcTemp}`;
+    // Continuation = entire original function body, plus onDone call and PC reset at the end
     const contBlocks = fn.blocks.map(block => {
         if (block.term.kind === 'return') {
             const instrs = [...block.instrs];
             if (info.onDone) {
                 instrs.push({ kind: 'call', dst: null, fn: info.onDone, args: [] });
             }
+            // Reset PC to 0 so dispatcher stops after one run
+            instrs.push({ kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 0 } });
             return { ...block, instrs };
         }
         return block;
@@ -658,11 +708,11 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
         entry: fn.entry,
         isMacro: false,
     };
-    // Init: set pc = 1
+    // Init: set pc = 1 via score_write (side-effectful, not removed by DCE)
     const initBlock = {
         id: 'entry',
         instrs: [
-            { kind: 'const', dst: pcTemp, value: 1 },
+            { kind: 'score_write', player: pcPlayer, obj: objective, src: { kind: 'const', value: 1 } },
         ],
         term: { kind: 'return', value: null },
         preds: [],
@@ -674,7 +724,7 @@ function buildSingleContinuation(fn, info, prefix, pcTemp, objective) {
         entry: 'entry',
         isMacro: fn.isMacro,
     };
-    const dispatcher = buildDispatcher(`${prefix}_tick`, [contFn], pcTemp, objective, fn.name);
+    const dispatcher = buildDispatcher(dispatcherName, [contFn], pcTemp, objective, fn.name);
     return { initFn, continuations: [contFn], dispatcher };
 }
 // ---------------------------------------------------------------------------
@@ -719,6 +769,10 @@ function rewriteInstr(instr, promoted) {
             return { ...instr, src: rOp(instr.src) };
         case 'nbt_write_dynamic':
             return { ...instr, indexSrc: rOp(instr.indexSrc), valueSrc: rOp(instr.valueSrc) };
+        case 'score_read':
+            return { ...instr, dst: rTemp(instr.dst) };
+        case 'score_write':
+            return { ...instr, src: rOp(instr.src) };
         case 'call':
             return { ...instr, dst: instr.dst ? rTemp(instr.dst) : null, args: instr.args.map(rOp) };
         case 'call_macro':
@@ -814,6 +868,9 @@ function getUsedTemps(instr) {
         case 'nbt_read_dynamic':
             addOp(instr.indexSrc);
             break;
+        case 'score_write':
+            addOp(instr.src);
+            break;
         case 'call':
             instr.args.forEach(addOp);
             break;

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

@@ -16,6 +16,8 @@ export declare class Parser {
      *  `librarySources` compile option, each source is parsed by its own fresh
      *  Parser instance, so this flag never bleeds into user code. */
     private inLibraryMode;
+    /** Warnings accumulated during parsing (e.g. deprecated keyword usage). */
+    readonly warnings: string[];
     constructor(tokens: Token[], source?: string, filePath?: string);
     private peek;
     private advance;
@@ -72,6 +74,8 @@ export declare class Parser {
      */
     private tryParseTypeArgs;
     private parsePostfixExpr;
+    /** Returns true if the current 'as' token is a type cast (not a context block) */
+    private isTypeCastAs;
     private parseArgs;
     private parsePrimaryExpr;
     private parseLiteralExpr;

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() {
@@ -763,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');
@@ -1034,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);
     }
@@ -1211,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(')')) {
@@ -1318,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'
@@ -1637,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' ||
@@ -1868,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;