redscript-mc 1.2.0 → 1.2.1

package/dist/parser/index.js

@@ -792,6 +792,16 @@ class Parser {
             this.advance();
             return this.withLoc({ kind: 'float_lit', value: parseFloat(token.value) }, token);
         }
+        // Relative coordinate: ~  ~5  ~-3  ~0.5
+        if (token.kind === 'rel_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'rel_coord', value: token.value }, token);
+        }
+        // Local coordinate: ^  ^5  ^-3  ^0.5
+        if (token.kind === 'local_coord') {
+            this.advance();
+            return this.withLoc({ kind: 'local_coord', value: token.value }, token);
+        }
         // NBT suffix literals
         if (token.kind === 'byte_lit') {
             this.advance();
@@ -814,6 +824,10 @@ class Parser {
             this.advance();
             return this.parseStringExpr(token);
         }
+        if (token.kind === 'f_string') {
+            this.advance();
+            return this.parseFStringExpr(token);
+        }
         // MC name literal: #health → mc_name node (value = "health", without #)
         if (token.kind === 'mc_name') {
             this.advance();
@@ -965,6 +979,56 @@ class Parser {
         }
         return this.withLoc({ kind: 'str_interp', parts }, token);
     }
+    parseFStringExpr(token) {
+        const parts = [];
+        let current = '';
+        let index = 0;
+        while (index < token.value.length) {
+            if (token.value[index] === '{') {
+                if (current) {
+                    parts.push({ kind: 'text', value: current });
+                    current = '';
+                }
+                index++;
+                let depth = 1;
+                let exprSource = '';
+                let inString = false;
+                while (index < token.value.length && depth > 0) {
+                    const char = token.value[index];
+                    if (char === '"' && token.value[index - 1] !== '\\') {
+                        inString = !inString;
+                    }
+                    if (!inString) {
+                        if (char === '{') {
+                            depth++;
+                        }
+                        else if (char === '}') {
+                            depth--;
+                            if (depth === 0) {
+                                index++;
+                                break;
+                            }
+                        }
+                    }
+                    if (depth > 0) {
+                        exprSource += char;
+                    }
+                    index++;
+                }
+                if (depth !== 0) {
+                    this.error('Unterminated f-string interpolation');
+                }
+                parts.push({ kind: 'expr', expr: this.parseEmbeddedExpr(exprSource) });
+                continue;
+            }
+            current += token.value[index];
+            index++;
+        }
+        if (current) {
+            parts.push({ kind: 'text', value: current });
+        }
+        return this.withLoc({ kind: 'f_string', parts }, token);
+    }
     parseEmbeddedExpr(source) {
         const tokens = new lexer_1.Lexer(source, this.filePath).tokenize();
         const parser = new Parser(tokens, source, this.filePath);
@@ -1112,19 +1176,10 @@ class Parser {
         if (token.kind === '-') {
             return this.peek(offset + 1).kind === 'int_lit' ? 2 : 0;
         }
-        if (token.kind !== '~' && token.kind !== '^') {
-            return 0;
-        }
-        const next = this.peek(offset + 1);
-        if (next.kind === ',' || next.kind === ')') {
+        // rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) are single tokens now
+        if (token.kind === 'rel_coord' || token.kind === 'local_coord') {
             return 1;
         }
-        if (next.kind === 'int_lit') {
-            return 2;
-        }
-        if (next.kind === '-' && this.peek(offset + 2).kind === 'int_lit') {
-            return 3;
-        }
         return 0;
     }
     parseBlockPos() {
@@ -1139,15 +1194,25 @@ class Parser {
     }
     parseCoordComponent() {
         const token = this.peek();
-        if (token.kind === '~' || token.kind === '^') {
+        // Handle rel_coord (~, ~5, ~-3) and local_coord (^, ^5, ^-3) tokens
+        if (token.kind === 'rel_coord') {
             this.advance();
-            const offset = this.parseSignedCoordOffset();
-            return token.kind === '~'
-                ? { kind: 'relative', offset }
-                : { kind: 'local', offset };
+            // Parse the offset from the token value (e.g., "~5" -> 5, "~" -> 0, "~-3" -> -3)
+            const offset = this.parseCoordOffsetFromValue(token.value.slice(1));
+            return { kind: 'relative', offset };
+        }
+        if (token.kind === 'local_coord') {
+            this.advance();
+            const offset = this.parseCoordOffsetFromValue(token.value.slice(1));
+            return { kind: 'local', offset };
         }
         return { kind: 'absolute', value: this.parseSignedCoordOffset(true) };
     }
+    parseCoordOffsetFromValue(value) {
+        if (value === '' || value === undefined)
+            return 0;
+        return parseFloat(value);
+    }
     parseSignedCoordOffset(requireValue = false) {
         let sign = 1;
         if (this.match('-')) {

package/dist/typechecker/index.d.ts

@@ -17,6 +17,7 @@ export declare class TypeChecker {
     private currentReturnType;
     private scope;
     private selfTypeStack;
+    private readonly richTextBuiltins;
     constructor(source?: string, filePath?: string);
     private getNodeLocation;
     private report;
@@ -32,6 +33,7 @@ export declare class TypeChecker {
     private checkReturnStmt;
     private checkExpr;
     private checkCallExpr;
+    private checkRichTextBuiltinCall;
     private checkInvokeExpr;
     private checkFunctionCallArgs;
     private checkTpCall;

package/dist/typechecker/index.js

@@ -61,6 +61,8 @@ const MC_TYPE_TO_ENTITY = {
 };
 const VOID_TYPE = { kind: 'named', name: 'void' };
 const INT_TYPE = { kind: 'named', name: 'int' };
+const STRING_TYPE = { kind: 'named', name: 'string' };
+const FORMAT_STRING_TYPE = { kind: 'named', name: 'format_string' };
 const BUILTIN_SIGNATURES = {
     setTimeout: {
         params: [INT_TYPE, { kind: 'function_type', params: [], return: VOID_TYPE }],
@@ -90,6 +92,15 @@ class TypeChecker {
         this.scope = new Map();
         // Stack for tracking @s type in different contexts
         this.selfTypeStack = ['entity'];
+        this.richTextBuiltins = new Map([
+            ['say', { messageIndex: 0 }],
+            ['announce', { messageIndex: 0 }],
+            ['tell', { messageIndex: 1 }],
+            ['tellraw', { messageIndex: 1 }],
+            ['title', { messageIndex: 1 }],
+            ['actionbar', { messageIndex: 1 }],
+            ['subtitle', { messageIndex: 1 }],
+        ]);
         this.collector = new diagnostics_1.DiagnosticCollector(source, filePath);
     }
     getNodeLocation(node) {
@@ -435,6 +446,18 @@ class TypeChecker {
                     }
                 }
                 break;
+            case 'f_string':
+                for (const part of expr.parts) {
+                    if (part.kind !== 'expr') {
+                        continue;
+                    }
+                    this.checkExpr(part.expr);
+                    const partType = this.inferType(part.expr);
+                    if (!(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);
+                    }
+                }
+                break;
             case 'array_lit':
                 for (const elem of expr.elements) {
                     this.checkExpr(elem);
@@ -464,6 +487,11 @@ class TypeChecker {
         if (expr.fn === 'tp' || expr.fn === 'tp_to') {
             this.checkTpCall(expr);
         }
+        const richTextBuiltin = this.richTextBuiltins.get(expr.fn);
+        if (richTextBuiltin) {
+            this.checkRichTextBuiltinCall(expr, richTextBuiltin.messageIndex);
+            return;
+        }
         const builtin = BUILTIN_SIGNATURES[expr.fn];
         if (builtin) {
             this.checkFunctionCallArgs(expr.args, builtin.params, expr.fn, expr);
@@ -506,6 +534,20 @@ class TypeChecker {
         }
         // Built-in functions are not checked for arg count
     }
+    checkRichTextBuiltinCall(expr, messageIndex) {
+        for (let i = 0; i < expr.args.length; i++) {
+            this.checkExpr(expr.args[i], i === messageIndex ? undefined : STRING_TYPE);
+        }
+        const message = expr.args[messageIndex];
+        if (!message) {
+            return;
+        }
+        const messageType = this.inferType(message);
+        if (messageType.kind !== 'named' ||
+            (messageType.name !== 'string' && messageType.name !== 'format_string')) {
+            this.report(`Argument ${messageIndex + 1} of '${expr.fn}' expects string or format_string, got ${this.typeToString(messageType)}`, message);
+        }
+    }
     checkInvokeExpr(expr) {
         this.checkExpr(expr.callee);
         const calleeType = this.inferType(expr.callee);
@@ -695,6 +737,13 @@ class TypeChecker {
                     }
                 }
                 return { kind: 'named', name: 'string' };
+            case 'f_string':
+                for (const part of expr.parts) {
+                    if (part.kind === 'expr') {
+                        this.checkExpr(part.expr);
+                    }
+                }
+                return FORMAT_STRING_TYPE;
             case 'blockpos':
                 return { kind: 'named', name: 'BlockPos' };
             case 'ident':