redscript-mc 1.2.30 → 2.1.0

package/dist/{parser → src/parser}/index.js

@@ -140,7 +140,9 @@ class Parser {
         const implBlocks = [];
         const enums = [];
         const consts = [];
+        const imports = [];
         let isLibrary = false;
+        let moduleName;
         // Check for namespace declaration
         if (this.check('namespace')) {
             this.advance();
@@ -148,7 +150,7 @@ class Parser {
             namespace = name.value;
             this.expect(';');
         }
-        // Check for module declaration: `module library;`
+        // Check for module declaration: `module library;` or `module <name>;`
         // Library-mode: all functions parsed from this point are marked isLibraryFn=true.
         // When using the `librarySources` compile option, each library source is parsed
         // by its own fresh Parser — so this flag never bleeds into user code.
@@ -159,9 +161,13 @@ class Parser {
                 isLibrary = true;
                 this.inLibraryMode = true;
             }
+            else {
+                // Named module declaration: `module math;`
+                moduleName = modKind.value;
+            }
             this.expect(';');
         }
-        // Parse struct and function declarations
+        // Parse struct, function, and import declarations
         while (!this.check('eof')) {
             if (this.check('let')) {
                 globals.push(this.parseGlobalDecl(true));
@@ -183,11 +189,31 @@ class Parser {
                 this.advance(); // consume 'declare'
                 this.parseDeclareStub();
             }
+            else if (this.check('export')) {
+                declarations.push(this.parseExportedFnDecl());
+            }
+            else if (this.check('ident') && this.peek().value === 'import') {
+                // `import math::sin;` or `import math::*;`
+                this.advance(); // consume 'import'
+                const importToken = this.peek();
+                const modName = this.expect('ident').value;
+                this.expect('::');
+                let symbol;
+                if (this.check('*')) {
+                    this.advance();
+                    symbol = '*';
+                }
+                else {
+                    symbol = this.expect('ident').value;
+                }
+                this.expect(';');
+                imports.push(this.withLoc({ moduleName: modName, symbol }, importToken));
+            }
             else {
                 declarations.push(this.parseFnDecl());
             }
         }
-        return { namespace, globals, declarations, structs, implBlocks, enums, consts, isLibrary };
+        return { namespace, moduleName, globals, declarations, structs, implBlocks, enums, consts, imports, isLibrary };
     }
     // -------------------------------------------------------------------------
     // Struct Declaration
@@ -274,10 +300,36 @@ class Parser {
     // -------------------------------------------------------------------------
     // Function Declaration
     // -------------------------------------------------------------------------
+    /** Parse `export fn name(...)` — marks the function as exported (survives DCE). */
+    parseExportedFnDecl() {
+        this.expect('export');
+        const fn = this.parseFnDecl();
+        fn.isExported = true;
+        return fn;
+    }
     parseFnDecl(implTypeName) {
         const decorators = this.parseDecorators();
+        // Map @keep decorator to isExported flag (backward compat)
+        let isExported;
+        const filteredDecorators = decorators.filter(d => {
+            if (d.name === 'keep') {
+                isExported = true;
+                return false;
+            }
+            return true;
+        });
         const fnToken = this.expect('fn');
         const name = this.expect('ident').value;
+        // Parse optional generic type parameters: fn max<T>(...)
+        let typeParams;
+        if (this.check('<')) {
+            this.advance(); // consume '<'
+            typeParams = [];
+            do {
+                typeParams.push(this.expect('ident').value);
+            } while (this.match(','));
+            this.expect('>');
+        }
         this.expect('(');
         const params = this.parseParams(implTypeName);
         this.expect(')');
@@ -286,7 +338,8 @@ class Parser {
             returnType = this.parseType();
         }
         const body = this.parseBlock();
-        const fn = this.withLoc({ name, params, returnType, decorators, body, isLibraryFn: this.inLibraryMode || undefined }, fnToken);
+        const fn = this.withLoc({ name, typeParams, params, returnType, decorators: filteredDecorators, body,
+            isLibraryFn: this.inLibraryMode || undefined, isExported }, fnToken);
         return fn;
     }
     /** Parse a `declare fn name(params): returnType;` stub — no body, just discard. */
@@ -377,12 +430,21 @@ class Parser {
             }
             return { name, rawArgs };
         }
-        // Handle key=value format (e.g., rate=20)
+        // Handle key=value format (e.g., rate=20, batch=10, onDone=fn_name)
         for (const part of argsStr.split(',')) {
             const [key, val] = part.split('=').map(s => s.trim());
             if (key === 'rate') {
                 args.rate = parseInt(val, 10);
             }
+            else if (key === 'ticks') {
+                args.ticks = parseInt(val, 10);
+            }
+            else if (key === 'batch') {
+                args.batch = parseInt(val, 10);
+            }
+            else if (key === 'onDone') {
+                args.onDone = val;
+            }
             else if (key === 'trigger') {
                 args.trigger = val;
             }
@@ -425,7 +487,24 @@ class Parser {
         const token = this.peek();
         let type;
         if (token.kind === '(') {
-            return this.parseFunctionType();
+            // Disambiguate: tuple type `(T, T)` vs function type `(T) -> R`
+            // Look ahead: parse elements, then check if '->' follows.
+            const saved = this.pos;
+            this.advance(); // consume '('
+            const elements = [];
+            if (!this.check(')')) {
+                do {
+                    elements.push(this.parseType());
+                } while (this.match(','));
+            }
+            this.expect(')');
+            if (this.check('->')) {
+                // It's a function type — restore and use existing parseFunctionType
+                this.pos = saved;
+                return this.parseFunctionType();
+            }
+            // 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' ||
@@ -444,6 +523,12 @@ class Parser {
             else if (token.value === 'selector') {
                 type = { kind: 'selector' };
             }
+            else if (token.value === 'Option' && this.check('<')) {
+                this.advance(); // consume <
+                const inner = this.parseType();
+                this.expect('>');
+                type = { kind: 'option', inner };
+            }
             else {
                 type = { kind: 'struct', name: token.value };
             }
@@ -546,6 +631,23 @@ class Parser {
     }
     parseLetStmt() {
         const letToken = this.expect('let');
+        // Destructuring: let (a, b, c) = expr;
+        if (this.check('(')) {
+            this.advance(); // consume '('
+            const names = [];
+            do {
+                names.push(this.expect('ident').value);
+            } while (this.match(','));
+            this.expect(')');
+            let type;
+            if (this.match(':')) {
+                type = this.parseType();
+            }
+            this.expect('=');
+            const init = this.parseExpr();
+            this.expect(';');
+            return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken);
+        }
         const name = this.expect('ident').value;
         let type;
         if (this.match(':')) {
@@ -567,6 +669,27 @@ class Parser {
     }
     parseIfStmt() {
         const ifToken = this.expect('if');
+        // if let Some(x) = expr { ... }
+        if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(1).value === 'Some') {
+            this.advance(); // consume 'let'
+            this.advance(); // consume 'Some'
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            this.expect('=');
+            const init = this.parseExpr();
+            const then = this.parseBlock();
+            let else_;
+            if (this.match('else')) {
+                if (this.check('if')) {
+                    else_ = [this.parseIfStmt()];
+                }
+                else {
+                    else_ = this.parseBlock();
+                }
+            }
+            return this.withLoc({ kind: 'if_let_some', binding, init, then, else_ }, ifToken);
+        }
         this.expect('(');
         const cond = this.parseExpr();
         this.expect(')');
@@ -976,9 +1099,47 @@ class Parser {
         const prev = this.tokens[this.pos - 1];
         return ['int_lit', 'float_lit', 'ident', ')', ']'].includes(prev.kind);
     }
+    /**
+     * Try to parse `<Type, ...>` as explicit generic type arguments.
+     * Returns the parsed type list if successful, null if this looks like a comparison.
+     * Does NOT consume any tokens if it returns null.
+     */
+    tryParseTypeArgs() {
+        const saved = this.pos;
+        this.advance(); // consume '<'
+        const typeArgs = [];
+        try {
+            do {
+                typeArgs.push(this.parseType());
+            } while (this.match(','));
+            if (!this.check('>')) {
+                this.pos = saved;
+                return null;
+            }
+            this.advance(); // consume '>'
+            return typeArgs;
+        }
+        catch {
+            this.pos = saved;
+            return null;
+        }
+    }
     parsePostfixExpr() {
         let expr = this.parsePrimaryExpr();
         while (true) {
+            // Generic call: ident<Type>(args) — check before regular '(' handling
+            if (expr.kind === 'ident' && this.check('<')) {
+                const typeArgs = this.tryParseTypeArgs();
+                if (typeArgs !== null && this.check('(')) {
+                    const openParenToken = this.peek();
+                    this.advance(); // consume '('
+                    const args = this.parseArgs();
+                    this.expect(')');
+                    expr = this.withLoc({ kind: 'call', fn: expr.name, args, typeArgs }, this.getLocToken(expr) ?? openParenToken);
+                    continue;
+                }
+                // Not a generic call — fall through to normal expression handling
+            }
             // Function call
             if (this.match('(')) {
                 const openParenToken = this.tokens[this.pos - 1];
@@ -1051,11 +1212,16 @@ class Parser {
         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);
+            const memberToken = this.expect('ident');
+            if (this.check('(')) {
+                // Static method call: Type::method(args)
+                this.advance(); // consume '('
+                const args = this.parseArgs();
+                this.expect(')');
+                return this.withLoc({ kind: 'static_call', type: typeToken.value, method: memberToken.value, args }, typeToken);
+            }
+            // Enum variant access: Enum::Variant
+            return this.withLoc({ kind: 'path_expr', enumName: typeToken.value, variant: memberToken.value }, typeToken);
         }
         if (token.kind === 'ident' && this.peek(1).kind === '=>') {
             return this.parseSingleParamLambda();
@@ -1135,12 +1301,25 @@ class Parser {
                 sel: this.parseSelectorValue(token.value),
             }, token);
         }
+        // Some(expr) — Option constructor
+        if (token.kind === 'ident' && token.value === 'Some' && this.peek(1).kind === '(') {
+            this.advance(); // consume 'Some'
+            this.advance(); // consume '('
+            const value = this.parseExpr();
+            this.expect(')');
+            return this.withLoc({ kind: 'some_lit', value }, token);
+        }
+        // None — Option empty constructor
+        if (token.kind === 'ident' && token.value === 'None') {
+            this.advance();
+            return this.withLoc({ kind: 'none_lit' }, token);
+        }
         // Identifier
         if (token.kind === 'ident') {
             this.advance();
             return this.withLoc({ kind: 'ident', name: token.value }, token);
         }
-        // Grouped expression
+        // Grouped expression or tuple literal
         if (token.kind === '(') {
             if (this.isBlockPosLiteral()) {
                 return this.parseBlockPos();
@@ -1149,9 +1328,20 @@ class Parser {
                 return this.parseLambdaExpr();
             }
             this.advance();
-            const expr = this.parseExpr();
+            const first = this.parseExpr();
+            // If followed by a comma, it's a tuple literal
+            if (this.match(',')) {
+                const elements = [first];
+                if (!this.check(')')) {
+                    do {
+                        elements.push(this.parseExpr());
+                    } while (this.match(','));
+                }
+                this.expect(')');
+                return this.withLoc({ kind: 'tuple_lit', elements }, token);
+            }
             this.expect(')');
-            return expr;
+            return first;
         }
         // Struct literal or block: { x: 10, y: 20 }
         if (token.kind === '{') {

package/dist/{repl.d.ts → src/repl.d.ts}

@@ -1,4 +1,4 @@
-import type { DatapackFile } from './codegen/mcfunction';
+import type { DatapackFile } from './emit/index';
 export interface ReplEvaluation {
     source: string;
     files: DatapackFile[];

package/dist/{runtime → src/runtime}/index.js

@@ -1385,7 +1385,7 @@ class MCRuntime {
     // -------------------------------------------------------------------------
     compileAndLoad(source) {
         const result = (0, compile_1.compile)(source, { namespace: this.namespace });
-        if (!result.success || !result.files) {
+        if (!result.files) {
             throw new Error('Compilation failed');
         }
         // Load all .mcfunction files

package/dist/{typechecker → src/typechecker}/index.d.ts

@@ -13,6 +13,7 @@ export declare class TypeChecker {
     private structs;
     private enums;
     private consts;
+    private globals;
     private currentFn;
     private currentReturnType;
     private scope;
@@ -29,6 +30,7 @@ export declare class TypeChecker {
     private checkFunctionDecorators;
     private checkBlock;
     private checkStmt;
+    private checkLetDestructStmt;
     private checkLetStmt;
     private checkReturnStmt;
     private checkExpr;
@@ -55,6 +57,8 @@ 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). */
+    private isNumericMismatch;
     private typesMatch;
     private typeToString;
     private normalizeType;