redscript-mc 1.0.0 → 1.2.0

package/dist/mc-test/runner.d.ts

@@ -1,11 +1,11 @@
 /**
  * RedScript MC Integration Test Runner
  *
- * Compiles a .rs file, installs it to a running Paper server,
+ * Compiles a .mcrs file, installs it to a running Paper server,
  * runs test scenarios, and reports results.
  *
  * Usage:
- *   npx ts-node src/mc-test/runner.ts src/examples/counter.rs
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
  *
  * Requires:
  *   - Paper server running with TestHarnessPlugin

package/dist/mc-test/runner.js

@@ -2,11 +2,11 @@
 /**
  * RedScript MC Integration Test Runner
  *
- * Compiles a .rs file, installs it to a running Paper server,
+ * Compiles a .mcrs file, installs it to a running Paper server,
  * runs test scenarios, and reports results.
  *
  * Usage:
- *   npx ts-node src/mc-test/runner.ts src/examples/counter.rs
+ *   npx ts-node src/mc-test/runner.ts src/examples/counter.mcrs
  *
  * Requires:
  *   - Paper server running with TestHarnessPlugin
@@ -115,7 +115,7 @@ async function runMCTests(sourceFile, tests, options = {}) {
 if (require.main === module) {
     const sourceFile = process.argv[2];
     if (!sourceFile) {
-        console.error('Usage: ts-node runner.ts <source.rs>');
+        console.error('Usage: ts-node runner.ts <source.mcrs>');
         process.exit(1);
     }
     // Example test suite (replace with actual tests)

package/dist/mc-test/setup.js

@@ -66,12 +66,12 @@ function main() {
     // Example files
     const exampleNamespaces = ['counter', 'world_manager'];
     for (const ns of exampleNamespaces) {
-        const file = path.join(EXAMPLES_DIR, `${ns}.rs`);
+        const file = path.join(EXAMPLES_DIR, `${ns}.mcrs`);
         if (fs.existsSync(file)) {
             writeFixture(fs.readFileSync(file, 'utf-8'), ns);
         }
         else {
-            console.log(`  ⚠ ${ns}.rs not found, skipping`);
+            console.log(`  ⚠ ${ns}.mcrs not found, skipping`);
         }
     }
     // Inline test fixtures

package/dist/parser/index.d.ts

@@ -23,7 +23,9 @@ export declare class Parser {
     parse(defaultNamespace?: string): Program;
     private parseStructDecl;
     private parseEnumDecl;
+    private parseImplBlock;
     private parseConstDecl;
+    private parseGlobalDecl;
     private parseFnDecl;
     private parseDecorators;
     private parseDecoratorValue;
@@ -48,6 +50,7 @@ export declare class Parser {
     private parseAssignment;
     private parseBinaryExpr;
     private parseUnaryExpr;
+    private parseEntityTypeName;
     private isSubtraction;
     private parsePostfixExpr;
     private parseArgs;
@@ -68,6 +71,7 @@ export declare class Parser {
     private parseCoordComponent;
     private parseSignedCoordOffset;
     private parseSelector;
+    private parseSelectorOrVarSelector;
     private parseSelectorValue;
     private parseSelectorFilters;
     private splitSelectorParams;

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;
@@ -99,8 +119,10 @@ class Parser {
     // -------------------------------------------------------------------------
     parse(defaultNamespace = 'redscript') {
         let namespace = defaultNamespace;
+        const globals = [];
         const declarations = [];
         const structs = [];
+        const implBlocks = [];
         const enums = [];
         const consts = [];
         // Check for namespace declaration
@@ -112,9 +134,15 @@ class Parser {
         }
         // Parse struct and function declarations
         while (!this.check('eof')) {
-            if (this.check('struct')) {
+            if (this.check('let')) {
+                globals.push(this.parseGlobalDecl(true));
+            }
+            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());
             }
@@ -125,7 +153,7 @@ class Parser {
                 declarations.push(this.parseFnDecl());
             }
         }
-        return { namespace, declarations, structs, enums, consts };
+        return { namespace, globals, declarations, structs, implBlocks, enums, consts };
     }
     // -------------------------------------------------------------------------
     // Struct Declaration
@@ -171,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;
@@ -181,18 +220,28 @@ class Parser {
         this.match(';');
         return this.withLoc({ name, type, value }, constToken);
     }
+    parseGlobalDecl(mutable) {
+        const token = this.advance(); // consume 'let'
+        const name = this.expect('ident').value;
+        this.expect(':');
+        const type = this.parseType();
+        this.expect('=');
+        const init = this.parseExpr();
+        this.expect(';');
+        return this.withLoc({ kind: 'global', name, type, init, mutable }, token);
+    }
     // -------------------------------------------------------------------------
     // 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();
@@ -208,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}`);
@@ -219,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(/^"([^"]*)"$/);
@@ -259,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();
@@ -534,16 +596,16 @@ class Parser {
                 if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
                     this.advance(); // consume 'entity'
                 }
-                const selector = this.parseSelector();
-                subcommands.push({ kind: 'if_entity', selector });
+                const selectorOrVar = this.parseSelectorOrVarSelector();
+                subcommands.push({ kind: 'if_entity', ...selectorOrVar });
             }
             else if (this.match('unless')) {
                 // Expect 'entity' keyword (as ident) or just parse selector directly  
                 if (this.peek().kind === 'ident' && this.peek().value === 'entity') {
                     this.advance(); // consume 'entity'
                 }
-                const selector = this.parseSelector();
-                subcommands.push({ kind: 'unless_entity', selector });
+                const selectorOrVar = this.parseSelectorOrVarSelector();
+                subcommands.push({ kind: 'unless_entity', ...selectorOrVar });
             }
             else if (this.match('in')) {
                 const dim = this.expect('ident').value;
@@ -598,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);
         }
@@ -616,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
@@ -645,6 +719,10 @@ class Parser {
                         'has_tag': '__entity_has_tag',
                         'push': '__array_push',
                         'pop': '__array_pop',
+                        'add': 'set_add',
+                        'contains': 'set_contains',
+                        'remove': 'set_remove',
+                        'clear': 'set_clear',
                     };
                     const internalFn = methodMap[expr.field];
                     if (internalFn) {
@@ -653,7 +731,11 @@ class Parser {
                         expr = this.withLoc({ kind: 'call', fn: internalFn, args: [expr.obj, ...args] }, this.getLocToken(expr) ?? openParenToken);
                         continue;
                     }
-                    this.error(`Unknown method '${expr.field}'`);
+                    // Generic method sugar: obj.method(args) → method(obj, args)
+                    const args = this.parseArgs();
+                    this.expect(')');
+                    expr = this.withLoc({ kind: 'call', fn: expr.field, args: [expr.obj, ...args] }, this.getLocToken(expr) ?? openParenToken);
+                    continue;
                 }
                 const args = this.parseArgs();
                 this.expect(')');
@@ -688,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();
         }
@@ -1077,6 +1168,37 @@ class Parser {
         const token = this.expect('selector');
         return this.parseSelectorValue(token.value);
     }
+    // Parse either a selector (@a[...]) or a variable with filters (p[...])
+    // Returns { selector } for selectors or { varName, filters } for variables
+    parseSelectorOrVarSelector() {
+        if (this.check('selector')) {
+            return { selector: this.parseSelector() };
+        }
+        // Must be an identifier (variable) possibly with filters
+        const varToken = this.expect('ident');
+        const varName = varToken.value;
+        // Check for optional filters [...]
+        if (this.check('[')) {
+            this.advance(); // consume '['
+            // Collect everything until ']'
+            let filterStr = '';
+            let depth = 1;
+            while (depth > 0 && !this.check('eof')) {
+                if (this.check('['))
+                    depth++;
+                else if (this.check(']'))
+                    depth--;
+                if (depth > 0) {
+                    filterStr += this.peek().value ?? this.peek().kind;
+                    this.advance();
+                }
+            }
+            this.expect(']');
+            const filters = this.parseSelectorFilters(filterStr);
+            return { varName, filters };
+        }
+        return { varName };
+    }
     parseSelectorValue(value) {
         // Parse @e[type=zombie, distance=..5]
         const bracketIndex = value.indexOf('[');
@@ -1129,6 +1251,21 @@ class Parser {
                 case 'scores':
                     filters.scores = this.parseScoresFilter(val);
                     break;
+                case 'x':
+                    filters.x = this.parseRangeValue(val);
+                    break;
+                case 'y':
+                    filters.y = this.parseRangeValue(val);
+                    break;
+                case 'z':
+                    filters.z = this.parseRangeValue(val);
+                    break;
+                case 'x_rotation':
+                    filters.x_rotation = this.parseRangeValue(val);
+                    break;
+                case 'y_rotation':
+                    filters.y_rotation = this.parseRangeValue(val);
+                    break;
             }
         }
         return filters;

package/dist/typechecker/index.d.ts

@@ -9,12 +9,14 @@ 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;
     constructor(source?: string, filePath?: string);
     private getNodeLocation;
     private report;
@@ -23,6 +25,7 @@ export declare class TypeChecker {
      */
     check(program: Program): DiagnosticError[];
     private checkFunction;
+    private checkFunctionDecorators;
     private checkBlock;
     private checkStmt;
     private checkLetStmt;
@@ -33,9 +36,23 @@ export declare class TypeChecker {
     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;