redscript-mc 1.1.0 → 1.2.1

package/dist/parser/index.js

@@ -16,11 +16,31 @@ const PRECEDENCE = {
     '||': 1,
     '&&': 2,
     '==': 3, '!=': 3,
-    '<': 4, '<=': 4, '>': 4, '>=': 4,
+    '<': 4, '<=': 4, '>': 4, '>=': 4, 'is': 4,
     '+': 5, '-': 5,
     '*': 6, '/': 6, '%': 6,
 };
-const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', '+', '-', '*', '/', '%']);
+const BINARY_OPS = new Set(['||', '&&', '==', '!=', '<', '<=', '>', '>=', 'is', '+', '-', '*', '/', '%']);
+const ENTITY_TYPE_NAMES = new Set([
+    'entity',
+    'Player',
+    'Mob',
+    'HostileMob',
+    'PassiveMob',
+    'Zombie',
+    'Skeleton',
+    'Creeper',
+    'Spider',
+    'Enderman',
+    'Pig',
+    'Cow',
+    'Sheep',
+    'Chicken',
+    'Villager',
+    'ArmorStand',
+    'Item',
+    'Arrow',
+]);
 function computeIsSingle(raw) {
     if (/^@[spr](\[|$)/.test(raw))
         return true;
@@ -102,6 +122,7 @@ class Parser {
         const globals = [];
         const declarations = [];
         const structs = [];
+        const implBlocks = [];
         const enums = [];
         const consts = [];
         // Check for namespace declaration
@@ -119,6 +140,9 @@ class Parser {
             else if (this.check('struct')) {
                 structs.push(this.parseStructDecl());
             }
+            else if (this.check('impl')) {
+                implBlocks.push(this.parseImplBlock());
+            }
             else if (this.check('enum')) {
                 enums.push(this.parseEnumDecl());
             }
@@ -129,7 +153,7 @@ class Parser {
                 declarations.push(this.parseFnDecl());
             }
         }
-        return { namespace, globals, declarations, structs, enums, consts };
+        return { namespace, globals, declarations, structs, implBlocks, enums, consts };
     }
     // -------------------------------------------------------------------------
     // Struct Declaration
@@ -175,6 +199,17 @@ class Parser {
         this.expect('}');
         return this.withLoc({ name, variants }, enumToken);
     }
+    parseImplBlock() {
+        const implToken = this.expect('impl');
+        const typeName = this.expect('ident').value;
+        this.expect('{');
+        const methods = [];
+        while (!this.check('}') && !this.check('eof')) {
+            methods.push(this.parseFnDecl(typeName));
+        }
+        this.expect('}');
+        return this.withLoc({ kind: 'impl_block', typeName, methods }, implToken);
+    }
     parseConstDecl() {
         const constToken = this.expect('const');
         const name = this.expect('ident').value;
@@ -198,15 +233,15 @@ class Parser {
     // -------------------------------------------------------------------------
     // Function Declaration
     // -------------------------------------------------------------------------
-    parseFnDecl() {
+    parseFnDecl(implTypeName) {
         const decorators = this.parseDecorators();
         const fnToken = this.expect('fn');
         const name = this.expect('ident').value;
         this.expect('(');
-        const params = this.parseParams();
+        const params = this.parseParams(implTypeName);
         this.expect(')');
         let returnType = { kind: 'named', name: 'void' };
-        if (this.match('->')) {
+        if (this.match('->') || this.match(':')) {
             returnType = this.parseType();
         }
         const body = this.parseBlock();
@@ -222,7 +257,7 @@ class Parser {
         return decorators;
     }
     parseDecoratorValue(value) {
-        // Parse @tick or @on_trigger("name") or @on_advancement("story/mine_diamond")
+        // Parse @tick, @on(PlayerDeath), or @on_trigger("name")
         const match = value.match(/^@(\w+)(?:\(([^)]*)\))?$/);
         if (!match) {
             this.error(`Invalid decorator: ${value}`);
@@ -233,6 +268,13 @@ class Parser {
             return { name };
         }
         const args = {};
+        if (name === 'on') {
+            const eventTypeMatch = argsStr.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+            if (eventTypeMatch) {
+                args.eventType = eventTypeMatch[1];
+                return { name, args };
+            }
+        }
         // Handle @on_trigger("name"), @on_advancement("id"), @on_craft("item"), @on_join_team("team")
         if (name === 'on_trigger' || name === 'on_advancement' || name === 'on_craft' || name === 'on_join_team') {
             const strMatch = argsStr.match(/^"([^"]*)"$/);
@@ -273,14 +315,20 @@ class Parser {
         }
         return { name, args };
     }
-    parseParams() {
+    parseParams(implTypeName) {
         const params = [];
         if (!this.check(')')) {
             do {
                 const paramToken = this.expect('ident');
                 const name = paramToken.value;
-                this.expect(':');
-                const type = this.parseType();
+                let type;
+                if (implTypeName && params.length === 0 && name === 'self' && !this.check(':')) {
+                    type = { kind: 'struct', name: implTypeName };
+                }
+                else {
+                    this.expect(':');
+                    type = this.parseType();
+                }
                 let defaultValue;
                 if (this.match('=')) {
                     defaultValue = this.parseExpr();
@@ -612,6 +660,11 @@ class Parser {
             if (prec < minPrec)
                 break;
             const opToken = this.advance();
+            if (op === 'is') {
+                const entityType = this.parseEntityTypeName();
+                left = this.withLoc({ kind: 'is_check', expr: left, entityType }, this.getLocToken(left) ?? opToken);
+                continue;
+            }
             const right = this.parseBinaryExpr(prec + 1); // left associative
             left = this.withLoc({ kind: 'binary', op: op, left, right }, this.getLocToken(left) ?? opToken);
         }
@@ -630,6 +683,13 @@ class Parser {
         }
         return this.parsePostfixExpr();
     }
+    parseEntityTypeName() {
+        const token = this.expect('ident');
+        if (ENTITY_TYPE_NAMES.has(token.value)) {
+            return token.value;
+        }
+        this.error(`Unknown entity type '${token.value}'`);
+    }
     isSubtraction() {
         // Check if this minus is binary (subtraction) by looking at previous token
         // If previous was a value (literal, ident, ), ]) it's subtraction
@@ -710,6 +770,15 @@ class Parser {
     }
     parsePrimaryExpr() {
         const token = this.peek();
+        if (token.kind === 'ident' && this.peek(1).kind === '::') {
+            const typeToken = this.advance();
+            this.expect('::');
+            const methodToken = this.expect('ident');
+            this.expect('(');
+            const args = this.parseArgs();
+            this.expect(')');
+            return this.withLoc({ kind: 'static_call', type: typeToken.value, method: methodToken.value, args }, typeToken);
+        }
         if (token.kind === 'ident' && this.peek(1).kind === '=>') {
             return this.parseSingleParamLambda();
         }
@@ -723,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();
@@ -745,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();
@@ -896,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);
@@ -1043,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() {
@@ -1070,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

@@ -9,12 +9,15 @@ import { DiagnosticError } from '../diagnostics';
 export declare class TypeChecker {
     private collector;
     private functions;
+    private implMethods;
     private structs;
     private enums;
     private consts;
     private currentFn;
     private currentReturnType;
     private scope;
+    private selfTypeStack;
+    private readonly richTextBuiltins;
     constructor(source?: string, filePath?: string);
     private getNodeLocation;
     private report;
@@ -23,19 +26,35 @@ export declare class TypeChecker {
      */
     check(program: Program): DiagnosticError[];
     private checkFunction;
+    private checkFunctionDecorators;
     private checkBlock;
     private checkStmt;
     private checkLetStmt;
     private checkReturnStmt;
     private checkExpr;
     private checkCallExpr;
+    private checkRichTextBuiltinCall;
     private checkInvokeExpr;
     private checkFunctionCallArgs;
     private checkTpCall;
     private checkMemberExpr;
+    private checkStaticCallExpr;
     private checkLambdaExpr;
+    private checkIfBranches;
+    private getThenBranchNarrowing;
     private inferType;
     private inferLambdaType;
+    /** Infer entity type from a selector */
+    private inferEntityTypeFromSelector;
+    private resolveInstanceMethod;
+    /** Check if childType is a subtype of parentType */
+    private isEntitySubtype;
+    /** Push a new self type context */
+    private pushSelfType;
+    /** Pop self type context */
+    private popSelfType;
+    /** Get current @s type */
+    private getCurrentSelfType;
     private typesMatch;
     private typeToString;
     private normalizeType;