redscript-mc 3.0.1 → 3.0.2

package/dist/src/parser/stmt-parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * StmtParser — statement parsing (if/while/for/match/execute/etc).
+ * Extends ExprParser so statement methods can call expression methods.
+ */
+import type { Stmt, Block } from '../ast/types';
+import { ExprParser } from './expr-parser';
+export declare class StmtParser extends ExprParser {
+    parseBlock(): Block;
+    parseStmt(): Stmt;
+    private parseLetStmt;
+    private parseLocalConstDecl;
+    private parseReturnStmt;
+    private parseIfStmt;
+    private parseWhileStmt;
+    private parseDoWhileStmt;
+    private parseRepeatStmt;
+    private parseParenOptionalCond;
+    private parseForStmt;
+    private parseForRangeStmt;
+    private parseForeachStmt;
+    private parseMatchPattern;
+    private parseMatchStmt;
+    private parseAsStmt;
+    private parseAtStmt;
+    private parseExecuteStmt;
+    private parseExecuteCondition;
+    private parseExprStmt;
+}

package/dist/src/parser/stmt-parser.js

@@ -0,0 +1,577 @@
+"use strict";
+/**
+ * StmtParser — statement parsing (if/while/for/match/execute/etc).
+ * Extends ExprParser so statement methods can call expression methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StmtParser = void 0;
+const diagnostics_1 = require("../diagnostics");
+const expr_parser_1 = require("./expr-parser");
+class StmtParser extends expr_parser_1.ExprParser {
+    // -------------------------------------------------------------------------
+    // Block
+    // -------------------------------------------------------------------------
+    parseBlock() {
+        this.expect('{');
+        const stmts = [];
+        while (!this.check('}') && !this.check('eof')) {
+            try {
+                stmts.push(this.parseStmt());
+            }
+            catch (err) {
+                if (err instanceof diagnostics_1.DiagnosticError) {
+                    this.parseErrors.push(err);
+                    this.syncToNextStmt();
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        this.expect('}');
+        return stmts;
+    }
+    // -------------------------------------------------------------------------
+    // Statement dispatch
+    // -------------------------------------------------------------------------
+    parseStmt() {
+        if (this.check('let'))
+            return this.parseLetStmt();
+        if (this.check('const'))
+            return this.parseLocalConstDecl();
+        if (this.check('return'))
+            return this.parseReturnStmt();
+        if (this.check('break')) {
+            const token = this.advance();
+            if (this.check('ident')) {
+                const labelToken = this.advance();
+                this.match(';');
+                return this.withLoc({ kind: 'break_label', label: labelToken.value }, token);
+            }
+            this.match(';');
+            return this.withLoc({ kind: 'break' }, token);
+        }
+        if (this.check('continue')) {
+            const token = this.advance();
+            if (this.check('ident')) {
+                const labelToken = this.advance();
+                this.match(';');
+                return this.withLoc({ kind: 'continue_label', label: labelToken.value }, token);
+            }
+            this.match(';');
+            return this.withLoc({ kind: 'continue' }, token);
+        }
+        if (this.check('if'))
+            return this.parseIfStmt();
+        // Labeled loop: ident ':' (while|for|foreach|repeat)
+        if (this.check('ident') && this.peek(1).kind === ':') {
+            const labelToken = this.advance();
+            this.advance(); // consume ':'
+            let loopStmt;
+            if (this.check('while')) {
+                loopStmt = this.parseWhileStmt();
+            }
+            else if (this.check('for')) {
+                loopStmt = this.parseForStmt();
+            }
+            else if (this.check('foreach')) {
+                loopStmt = this.parseForeachStmt();
+            }
+            else if (this.check('repeat')) {
+                loopStmt = this.parseRepeatStmt();
+            }
+            else {
+                throw new diagnostics_1.DiagnosticError('ParseError', `Expected loop statement after label '${labelToken.value}:', found '${this.peek().kind}'`, { line: labelToken.line, col: labelToken.col });
+            }
+            return this.withLoc({ kind: 'labeled_loop', label: labelToken.value, body: loopStmt }, labelToken);
+        }
+        if (this.check('while'))
+            return this.parseWhileStmt();
+        if (this.check('do'))
+            return this.parseDoWhileStmt();
+        if (this.check('repeat'))
+            return this.parseRepeatStmt();
+        if (this.check('for'))
+            return this.parseForStmt();
+        if (this.check('foreach'))
+            return this.parseForeachStmt();
+        if (this.check('match'))
+            return this.parseMatchStmt();
+        if (this.check('as'))
+            return this.parseAsStmt();
+        if (this.check('at'))
+            return this.parseAtStmt();
+        if (this.check('execute'))
+            return this.parseExecuteStmt();
+        if (this.check('raw_cmd')) {
+            const token = this.advance();
+            const cmd = token.value;
+            this.match(';');
+            return this.withLoc({ kind: 'raw', cmd }, token);
+        }
+        return this.parseExprStmt();
+    }
+    // -------------------------------------------------------------------------
+    // Individual statement parsers
+    // -------------------------------------------------------------------------
+    parseLetStmt() {
+        const letToken = this.expect('let');
+        if (this.check('(')) {
+            this.advance();
+            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.match(';');
+            return this.withLoc({ kind: 'let_destruct', names, type, init }, letToken);
+        }
+        const name = this.expect('ident').value;
+        let type;
+        if (this.match(':'))
+            type = this.parseType();
+        this.expect('=');
+        const init = this.parseExpr();
+        this.match(';');
+        return this.withLoc({ kind: 'let', name, type, init }, letToken);
+    }
+    parseLocalConstDecl() {
+        const constToken = this.expect('const');
+        const name = this.expect('ident').value;
+        this.expect(':');
+        const type = this.parseType();
+        this.expect('=');
+        const value = this.parseExpr();
+        this.match(';');
+        return this.withLoc({ kind: 'const_decl', name, type, value }, constToken);
+    }
+    parseReturnStmt() {
+        const returnToken = this.expect('return');
+        let value;
+        if (!this.check(';') && !this.check('}') && !this.check('eof')) {
+            value = this.parseExpr();
+        }
+        this.match(';');
+        return this.withLoc({ kind: 'return', value }, returnToken);
+    }
+    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();
+            this.advance();
+            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')) {
+                else_ = this.check('if') ? [this.parseIfStmt()] : this.parseBlock();
+            }
+            return this.withLoc({ kind: 'if_let_some', binding, init, then, else_ }, ifToken);
+        }
+        const cond = this.parseParenOptionalCond();
+        const then = this.parseBlock();
+        let else_;
+        if (this.match('else')) {
+            else_ = this.check('if') ? [this.parseIfStmt()] : this.parseBlock();
+        }
+        return this.withLoc({ kind: 'if', cond, then, else_ }, ifToken);
+    }
+    parseWhileStmt() {
+        const whileToken = this.expect('while');
+        if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(1).value === 'Some') {
+            this.advance();
+            this.advance();
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            this.expect('=');
+            const init = this.parseExpr();
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'while_let_some', binding, init, body }, whileToken);
+        }
+        const cond = this.parseParenOptionalCond();
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'while', cond, body }, whileToken);
+    }
+    parseDoWhileStmt() {
+        const doToken = this.expect('do');
+        const body = this.parseBlock();
+        this.expect('while');
+        const cond = this.parseParenOptionalCond();
+        this.match(';');
+        return this.withLoc({ kind: 'do_while', cond, body }, doToken);
+    }
+    parseRepeatStmt() {
+        const repeatToken = this.expect('repeat');
+        const countToken = this.expect('int_lit');
+        const count = parseInt(countToken.value, 10);
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'repeat', count, body }, repeatToken);
+    }
+    parseParenOptionalCond() {
+        if (this.match('(')) {
+            const cond = this.parseExpr();
+            this.expect(')');
+            return cond;
+        }
+        return this.parseExpr();
+    }
+    parseForStmt() {
+        const forToken = this.expect('for');
+        if (this.check('ident') && this.peek(1).kind === 'in') {
+            return this.parseForRangeStmt(forToken);
+        }
+        this.expect('(');
+        if (this.check('let') && this.peek(1).kind === 'ident' && this.peek(2).kind === 'in' && this.peek(3).kind === 'ident' && this.peek(4).kind === ',') {
+            this.advance();
+            const binding = this.expect('ident').value;
+            this.expect('in');
+            const arrayName = this.expect('ident').value;
+            this.expect(',');
+            const lenExpr = this.parseExpr();
+            this.expect(')');
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'for_in_array', binding, arrayName, lenExpr, body }, forToken);
+        }
+        let init;
+        if (this.check('let')) {
+            const letToken = this.expect('let');
+            const name = this.expect('ident').value;
+            let type;
+            if (this.match(':'))
+                type = this.parseType();
+            this.expect('=');
+            const initExpr = this.parseExpr();
+            const initStmt = { kind: 'let', name, type, init: initExpr };
+            init = this.withLoc(initStmt, letToken);
+        }
+        this.expect(';');
+        const cond = this.parseExpr();
+        this.expect(';');
+        const step = this.parseExpr();
+        this.expect(')');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'for', init, cond, step, body }, forToken);
+    }
+    parseForRangeStmt(forToken) {
+        const varName = this.expect('ident').value;
+        this.expect('in');
+        let start;
+        let end;
+        let inclusive = false;
+        if (this.check('range_lit')) {
+            const rangeToken = this.advance();
+            const raw = rangeToken.value;
+            inclusive = raw.includes('..=');
+            const range = this.parseRangeValue(raw);
+            start = this.withLoc({ kind: 'int_lit', value: range.min ?? 0 }, rangeToken);
+            if (range.max !== null && range.max !== undefined) {
+                end = this.withLoc({ kind: 'int_lit', value: range.max }, rangeToken);
+            }
+            else {
+                end = this.parseUnaryExpr();
+            }
+        }
+        else {
+            const arrayOrStart = this.parseExpr();
+            if (!this.check('range_lit')) {
+                const body = this.parseBlock();
+                return this.withLoc({ kind: 'for_each', binding: varName, array: arrayOrStart, body }, forToken);
+            }
+            start = arrayOrStart;
+            if (this.check('range_lit')) {
+                const rangeOp = this.advance();
+                inclusive = rangeOp.value.includes('=');
+                const afterOp = rangeOp.value.replace(/^\.\.=?/, '');
+                if (afterOp.length > 0) {
+                    end = this.withLoc({ kind: 'int_lit', value: parseInt(afterOp, 10) }, rangeOp);
+                }
+                else {
+                    end = this.parseExpr();
+                }
+            }
+            else {
+                this.error('Expected .. or ..= in for-range expression. Example: for i in 0..10 { ... }');
+            }
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'for_range', varName, start, end, inclusive, body }, forToken);
+    }
+    parseForeachStmt() {
+        const foreachToken = this.expect('foreach');
+        this.expect('(');
+        const binding = this.expect('ident').value;
+        this.expect('in');
+        const iterable = this.parseExpr();
+        this.expect(')');
+        let executeContext;
+        const execIdentKeywords = ['positioned', 'rotated', 'facing', 'anchored', 'align', 'on', 'summon'];
+        if (this.check('as') || this.check('at') || this.check('in') || (this.check('ident') && execIdentKeywords.includes(this.peek().value))) {
+            let context = '';
+            while (!this.check('{') && !this.check('eof')) {
+                context += this.advance().value + ' ';
+            }
+            executeContext = context.trim();
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'foreach', binding, iterable, body, executeContext }, foreachToken);
+    }
+    // -------------------------------------------------------------------------
+    // Match
+    // -------------------------------------------------------------------------
+    parseMatchPattern() {
+        if (this.check('ident') && this.peek().value === '_') {
+            this.advance();
+            return { kind: 'PatWild' };
+        }
+        if (this.check('ident') && this.peek().value === 'None') {
+            this.advance();
+            return { kind: 'PatNone' };
+        }
+        if (this.check('ident') && this.peek().value === 'Some') {
+            this.advance();
+            this.expect('(');
+            const binding = this.expect('ident').value;
+            this.expect(')');
+            return { kind: 'PatSome', binding };
+        }
+        if (this.check('ident') && this.peek(1).kind === '::') {
+            const enumName = this.advance().value;
+            this.expect('::');
+            const variant = this.expect('ident').value;
+            const bindings = [];
+            if (this.check('(')) {
+                this.advance();
+                while (!this.check(')') && !this.check('eof')) {
+                    bindings.push(this.expect('ident').value);
+                    if (!this.match(','))
+                        break;
+                }
+                this.expect(')');
+            }
+            return { kind: 'PatEnum', enumName, variant, bindings };
+        }
+        if (this.check('int_lit')) {
+            const tok = this.advance();
+            return { kind: 'PatInt', value: parseInt(tok.value, 10) };
+        }
+        if (this.check('-') && this.peek(1).kind === 'int_lit') {
+            this.advance();
+            const tok = this.advance();
+            return { kind: 'PatInt', value: -parseInt(tok.value, 10) };
+        }
+        const e = this.parseExpr();
+        return { kind: 'PatExpr', expr: e };
+    }
+    parseMatchStmt() {
+        const matchToken = this.expect('match');
+        let expr;
+        if (this.check('(')) {
+            this.advance();
+            expr = this.parseExpr();
+            this.expect(')');
+        }
+        else {
+            expr = this.parseExpr();
+        }
+        this.expect('{');
+        const arms = [];
+        while (!this.check('}') && !this.check('eof')) {
+            const pattern = this.parseMatchPattern();
+            this.expect('=>');
+            const body = this.parseBlock();
+            this.match(',');
+            arms.push({ pattern, body });
+        }
+        this.expect('}');
+        return this.withLoc({ kind: 'match', expr, arms }, matchToken);
+    }
+    // -------------------------------------------------------------------------
+    // As / At / Execute
+    // -------------------------------------------------------------------------
+    parseAsStmt() {
+        const asToken = this.expect('as');
+        const as_sel = this.parseSelector();
+        if (this.match('at')) {
+            const at_sel = this.parseSelector();
+            const body = this.parseBlock();
+            return this.withLoc({ kind: 'as_at', as_sel, at_sel, body }, asToken);
+        }
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'as_block', selector: as_sel, body }, asToken);
+    }
+    parseAtStmt() {
+        const atToken = this.expect('at');
+        const selector = this.parseSelector();
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'at_block', selector, body }, atToken);
+    }
+    parseExecuteStmt() {
+        const executeToken = this.expect('execute');
+        const subcommands = [];
+        while (!this.check('run') && !this.check('eof')) {
+            if (this.match('as')) {
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'as', selector });
+            }
+            else if (this.match('at')) {
+                const selector = this.parseSelector();
+                subcommands.push({ kind: 'at', selector });
+            }
+            else if (this.checkIdent('positioned')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'positioned_as', selector });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'positioned', x, y, z });
+                }
+            }
+            else if (this.checkIdent('rotated')) {
+                this.advance();
+                if (this.match('as')) {
+                    const selector = this.parseSelector();
+                    subcommands.push({ kind: 'rotated_as', selector });
+                }
+                else {
+                    const yaw = this.parseCoordToken();
+                    const pitch = this.parseCoordToken();
+                    subcommands.push({ kind: 'rotated', yaw, pitch });
+                }
+            }
+            else if (this.checkIdent('facing')) {
+                this.advance();
+                if (this.checkIdent('entity')) {
+                    this.advance();
+                    const selector = this.parseSelector();
+                    const anchor = this.checkIdent('eyes') || this.checkIdent('feet') ? this.advance().value : 'feet';
+                    subcommands.push({ kind: 'facing_entity', selector, anchor });
+                }
+                else {
+                    const x = this.parseCoordToken();
+                    const y = this.parseCoordToken();
+                    const z = this.parseCoordToken();
+                    subcommands.push({ kind: 'facing', x, y, z });
+                }
+            }
+            else if (this.checkIdent('anchored')) {
+                this.advance();
+                const anchor = this.advance().value;
+                subcommands.push({ kind: 'anchored', anchor });
+            }
+            else if (this.checkIdent('align')) {
+                this.advance();
+                const axes = this.advance().value;
+                subcommands.push({ kind: 'align', axes });
+            }
+            else if (this.checkIdent('on')) {
+                this.advance();
+                const relation = this.advance().value;
+                subcommands.push({ kind: 'on', relation });
+            }
+            else if (this.checkIdent('summon')) {
+                this.advance();
+                const entity = this.advance().value;
+                subcommands.push({ kind: 'summon', entity });
+            }
+            else if (this.checkIdent('store')) {
+                this.advance();
+                const storeType = this.advance().value;
+                if (this.checkIdent('score')) {
+                    this.advance();
+                    const target = this.advance().value;
+                    const targetObj = this.advance().value;
+                    if (storeType === 'result') {
+                        subcommands.push({ kind: 'store_result', target, targetObj });
+                    }
+                    else {
+                        subcommands.push({ kind: 'store_success', target, targetObj });
+                    }
+                }
+                else {
+                    this.error('store currently only supports score target');
+                }
+            }
+            else if (this.match('if')) {
+                this.parseExecuteCondition(subcommands, 'if');
+            }
+            else if (this.match('unless')) {
+                this.parseExecuteCondition(subcommands, 'unless');
+            }
+            else if (this.match('in')) {
+                let dim = this.advance().value;
+                if (this.match(':'))
+                    dim += ':' + this.advance().value;
+                subcommands.push({ kind: 'in', dimension: dim });
+            }
+            else {
+                this.error(`Unexpected token in execute statement: '${this.peek().value || this.peek().kind}'. Valid subcommands: as, at, positioned, align, facing, rotated, anchored, if, unless, in, store`);
+            }
+        }
+        this.expect('run');
+        const body = this.parseBlock();
+        return this.withLoc({ kind: 'execute', subcommands, body }, executeToken);
+    }
+    parseExecuteCondition(subcommands, type) {
+        if (this.checkIdent('entity') || this.check('selector')) {
+            if (this.checkIdent('entity'))
+                this.advance();
+            const selectorOrVar = this.parseSelectorOrVarSelector();
+            subcommands.push({ kind: type === 'if' ? 'if_entity' : 'unless_entity', ...selectorOrVar });
+        }
+        else if (this.checkIdent('block')) {
+            this.advance();
+            const x = this.parseCoordToken();
+            const y = this.parseCoordToken();
+            const z = this.parseCoordToken();
+            const block = this.parseBlockId();
+            subcommands.push({ kind: type === 'if' ? 'if_block' : 'unless_block', pos: [x, y, z], block });
+        }
+        else if (this.checkIdent('score')) {
+            this.advance();
+            const target = this.advance().value;
+            const targetObj = this.advance().value;
+            if (this.checkIdent('matches')) {
+                this.advance();
+                const range = this.advance().value;
+                subcommands.push({ kind: type === 'if' ? 'if_score_range' : 'unless_score_range', target, targetObj, range });
+            }
+            else {
+                const op = this.advance().value;
+                const source = this.advance().value;
+                const sourceObj = this.advance().value;
+                subcommands.push({
+                    kind: type === 'if' ? 'if_score' : 'unless_score',
+                    target, targetObj, op, source, sourceObj
+                });
+            }
+        }
+        else {
+            this.error(`Unknown condition type after ${type}`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Expression statement
+    // -------------------------------------------------------------------------
+    parseExprStmt() {
+        const expr = this.parseExpr();
+        this.match(';');
+        const exprToken = this.getLocToken(expr) ?? this.peek();
+        return this.withLoc({ kind: 'expr', expr }, exprToken);
+    }
+}
+exports.StmtParser = StmtParser;
+//# sourceMappingURL=stmt-parser.js.map

package/dist/src/parser/type-parser.d.ts

@@ -0,0 +1,20 @@
+/**
+ * TypeParser — parses type annotations and generic type arguments.
+ * Extends ParserBase to gain token navigation.
+ */
+import type { TypeNode, Param } from '../ast/types';
+import { ParserBase } from './utils';
+export declare class TypeParser extends ParserBase {
+    parseType(): TypeNode;
+    parseFunctionType(): TypeNode;
+    /**
+     * 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(): TypeNode[] | null;
+    isLambdaStart(): boolean;
+    typeTokenLength(offset: number): number;
+    parseParams(implTypeName?: string): Param[];
+    parseInterfaceParams(): Param[];
+}