redscript-mc 1.1.0 → 1.2.0

package/dist/parser/index.d.ts

@@ -23,6 +23,7 @@ export declare class Parser {
     parse(defaultNamespace?: string): Program;
     private parseStructDecl;
     private parseEnumDecl;
+    private parseImplBlock;
     private parseConstDecl;
     private parseGlobalDecl;
     private parseFnDecl;
@@ -49,6 +50,7 @@ export declare class Parser {
     private parseAssignment;
     private parseBinaryExpr;
     private parseUnaryExpr;
+    private parseEntityTypeName;
     private isSubtraction;
     private parsePostfixExpr;
     private parseArgs;

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();
         }

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;